Click here to Skip to main content
15,891,708 members
Articles / Multimedia / DirectX

Game Engine

Rate me:
Please Sign up or sign in to vote.
3.78/5 (6 votes)
20 Nov 2009CPL2 min read 47.5K   1.5K   34  
A game engine first prototype
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using MTV3D65;

namespace gefx
{
    public  class Object 
    {
         public List<TVMesh> Meshes = new List<TVMesh>();
         public const string ALL = "All";
         public struct Dimensions
         {

            public  float X;
            public float Y;
            public float Z;

            public float radius;
            public int  NumSlices;
            public int  NumStacks;

         };
        public enum ObjectType
        {
            Box,
            Sphere,
            Cube,
            Cilindar,
            Cone
            
        };
        public ObjectType TypeOf;
        private TVTextureFactory TF;
        private int IDDiffuse;
        private int IDMat;
        private TVMaterialFactory Mats;
        public TV_3DVECTOR GetMeshPosition(string Name)
        {
            TV_3DVECTOR Ret= new TV_3DVECTOR(0,0,0);

            foreach (TVMesh mesh in Meshes)
            {
                if (mesh.GetMeshName() == Name)
                {

                    Ret = mesh.GetPosition();
                    break;
                }

            }

            return Ret;

        }
        public void SetMeshPosition(TV_3DVECTOR Position,string Name)
        {
            foreach (TVMesh mesh in Meshes)
            {
                if (mesh.GetMeshName() == Name)
                {

                    mesh.SetPosition(Position.x, Position.y, Position.z);
                    break;
                }

            } 

        }
        public void SetMeshRotation(TV_3DVECTOR Rotation, string Name)
        {
            if (Name == ALL)
            {

                foreach (TVMesh Mesh in Meshes)
                {

                    Mesh.SetRotation(Rotation.x, Rotation.y, Rotation.z);

                }
            }
            else
            {
                foreach (TVMesh Mesh in Meshes)
                {
                    if (Mesh.GetMeshName() == Name)
                    {

                        Mesh.SetRotation(Rotation.x, Rotation.y, Rotation.z);
                        break;
                    }


                }

            }
        }
        public void SetMeshRotation(TV_3DVECTOR Rotation,float fbyTime,string Name)
        {
            if (Name == ALL)
            {

                foreach (TVMesh Mesh in Meshes)
                {

                    Mesh.SetRotation(Rotation.x * fbyTime, Rotation.y * fbyTime, Rotation.z * fbyTime);

                }
            }
            else
            {
                foreach (TVMesh Mesh in Meshes)
                {
                    if (Mesh.GetMeshName() == Name)
                    {

                        Mesh.SetRotation(Rotation.x * fbyTime, Rotation.y * fbyTime, Rotation.z * fbyTime);
                        break;
                    }


                }

            }

        }
        public TV_3DVECTOR GetMeshRotation(string Name)
        {
            TV_3DVECTOR Ret = new TV_3DVECTOR(0, 0, 0);

            foreach (TVMesh m in Meshes)
            {
                if (m.GetMeshName() == Name)
                {

                    Ret = m.GetRotation();
                }

            }
            return Ret;

        }
        public void AddTexture(string Name, string TexturePath, string TextureName)
        {
            TF = new TVTextureFactory();
            if (Name == ALL)
            {

                foreach (TVMesh Mesh in Meshes)
                {
                    IDDiffuse = TF.LoadTexture(TexturePath, TextureName, -1, -1, CONST_TV_COLORKEY.TV_COLORKEY_NO, true);
                    Mesh.SetTexture(IDDiffuse);     //Apply the texture to the cube
                }
            }
            else
            {
                foreach (TVMesh Mesh in Meshes)
                {
                    if (Mesh.GetMeshName() == Name)
                    {
                        IDDiffuse = TF.LoadTexture(TexturePath, TextureName, -1, -1, CONST_TV_COLORKEY.TV_COLORKEY_NO, true);
                        Mesh.SetTexture(IDDiffuse);     //Apply the texture to the cube
                        break;
                    }
                }
            }
            
        }
        public void AddMaterial(string Name)
        {
            Mats = new TVMaterialFactory();

            if (Name == ALL)
            {

                foreach (TVMesh Mesh in Meshes)
                {
                    IDMat = Mats.CreateLightMaterial(1, 1, 1, 1, 0.015f, 1, "basic x material" + Mesh.GetMeshName());

                    Mesh.SetMaterial(IDMat, -1);    
                    Mesh.SetLightingMode(CONST_TV_LIGHTINGMODE.TV_LIGHTING_NORMAL,
                        0, 1);

                }
            }
            else
            {
                foreach (TVMesh Mesh in Meshes)
                {
                    if (Mesh.GetMeshName() == Name)
                    {
                        IDMat = Mats.CreateLightMaterial(1, 1, 1, 1, 0.015f, 1, "basic x material" + Mesh.GetMeshName());

                        Mesh.SetMaterial(IDMat, -1);
                        Mesh.SetLightingMode(CONST_TV_LIGHTINGMODE.TV_LIGHTING_NORMAL,
                            0, 1);
                        
                        break;
                    }
                }
            }

        }
        public void UpdateObjects(string Name)
        {


            if (Name == ALL)
            {

                foreach (TVMesh Mesh in Meshes)
                {
                    Mesh.Update();
                }
            }
            else
            {
                foreach (TVMesh Mesh in Meshes)
                {
                    if (Mesh.GetMeshName() == Name)
                    {
                        Mesh.Update();
                        break;
                    }
                }
            }
        }
        public void  AddObject(ref TVScene Scene, ref TVGlobals Globals, ObjectType Type, string Name )
        {
            TVMesh Meshin = new TVMesh();

            if (Type == ObjectType.Cube)
            {

                Meshin = Scene.CreateMeshBuilder(Name);
                Meshin.CreateBox(5, 5, 5, false);
                Meshin.SetMeshName(Name);
                Meshes.Add(Meshin);

            }

        }
        public void AddObject(ref TVScene Scene, ref TVGlobals Globals,
            ObjectType Type, string Name,Dimensions dimenzije)
        {
            TVMesh Meshin = new TVMesh();

            if (Type == ObjectType.Cube)
            {

                Meshin = Scene.CreateMeshBuilder(Name);
                Meshin.CreateBox(dimenzije.X, dimenzije.Y, dimenzije.Z , false);
                Meshin.SetMeshName(Name);
                Meshes.Add(Meshin);

            }

            if (Type == ObjectType.Cilindar )
            {

                Meshin = Scene.CreateMeshBuilder(Name);
                Meshin.CreateCylinder(dimenzije.radius, dimenzije.X, dimenzije.NumStacks);
                Meshin.SetMeshName(Name);
                Meshes.Add(Meshin);

            }

            if (Type == ObjectType.Cone )
            {

                Meshin = Scene.CreateMeshBuilder(Name);
                Meshin.CreateCone(dimenzije.radius, dimenzije.X, dimenzije.NumSlices, true);
                Meshin.SetMeshName(Name);
                Meshes.Add(Meshin);

            }

            if (Type == ObjectType.Sphere)
            {

                Meshin = Scene.CreateMeshBuilder(Name);

                if (dimenzije.NumSlices == 0 && dimenzije.NumStacks == 0)
                {
                    Meshin.CreateSphere(dimenzije.radius);

                }
                else
                {

                    Meshin.CreateSphere(dimenzije.radius, dimenzije.NumSlices, dimenzije.NumStacks);
                }
                Meshin.SetMeshName(Name);
                Meshes.Add(Meshin);

            }

        }
        public void DrawObjects(string Para)
        {

            if (Para == "All")
            {

                foreach (TVMesh mesh in Meshes)
                {

                    mesh.Render();

                }

            }
            else
            {

                foreach (TVMesh mesh in Meshes)
                {
                    if (mesh.GetMeshName() == Para)
                    {
                        mesh.Render();
                        break;
                    }

                } 

            }

        }
        public void RotateObject(float x, float y, float z, string Name)
        {

            if (Name == ALL)
            {

                foreach (TVMesh Mesh in Meshes)
                {

                    Mesh.RotateX(x);
                    Mesh.RotateY(y);
                    Mesh.RotateZ(z);

                }
            }
            else
            {
                foreach (TVMesh Mesh in Meshes)
                {
                    if (Mesh.GetMeshName() == Name)
                    {

                        Mesh.RotateX(x);
                        Mesh.RotateY(y);
                        Mesh.RotateZ(z);
                        break;
                    }


                }

            }
        }
        public void RotateObject(float x, float y, float z, float time,string Name)
        {

            if (Name == ALL)
            {

                foreach (TVMesh Mesh in Meshes)
                {

                    Mesh.RotateX(x * time );
                    Mesh.RotateY(y * time);
                    Mesh.RotateZ(z * time);

                }
            }
            else
            {
                foreach (TVMesh Mesh in Meshes)
                {
                    if (Mesh.GetMeshName() == Name)
                    {

                        Mesh.RotateX(x * time);
                        Mesh.RotateY(y * time);
                        Mesh.RotateZ(z * time);
                        break;
                    }


                }

            }
        }
        public void SetModelScale(float x, float y, float z, string Name)
        {
            if (Name == ALL)
            {

                foreach (TVMesh Mesh in Meshes)
                {

                    Mesh.SetScale(x, y, z);
                }
            }
            else
            {
                foreach (TVMesh Mesh in Meshes)
                {
                    if (Mesh.GetMeshName() == Name)
                    {
                        Mesh.SetScale(x, y, z);

                        break;
                    }
                }
            }

        }
        public TV_3DVECTOR GetModelScale(string Name)
        {

            TV_3DVECTOR ret = new TV_3DVECTOR(0, 0, 0);
            foreach (TVMesh Mesh in Meshes)
            {
                if (Mesh.GetMeshName() == Name)
                {
                    ret = Mesh.GetScale();

                    break;
                }
            }
            return ret;

        }
        public int GetModelID(string Name)
        {
            int refint = 0;

            foreach (TVMesh Mesh in Meshes)
            {
                if (Mesh.GetMeshName() == Name)
                {
                    refint = Mesh.GetIndex();

                    break;
                }
            }
            return refint;


        }
        
    }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Common Public License Version 1.0 (CPL)


Written By
Software Developer
Croatia Croatia
Programer

Comments and Discussions