///<summary>
        /// Cleans up the pair handler.
        ///</summary>
        public override void CleanUp()
        {
            base.CleanUp();

            mesh   = null;
            convex = null;
        }
Exemplo n.º 2
0
        public void LoadModelData(string ModelName, WorldRenderer Game)
        {
            ModelData = Game.Content.Load <Model>(ModelName);
            ModelDataExtractor.GetVerticesAndIndicesFromModel(ModelData, out ModelVertices, out ModelIndices);

            MeshData = new StaticMesh(ModelVertices, ModelIndices, new AffineTransform(new Vector3(0, 0, 0)));
            Globals.space.Add(MeshData);
            Globals.game.ModelDrawer.Add(MeshData);
        }
 //public default constructor
 public ServerTerrainCollision(string ContentFileName)
 {
     TerrainCollision = Globals.game.Content.Load <Model>("LowDetailTerrain");
     ModelDataExtractor.GetVerticesAndIndicesFromModel(TerrainCollision, out TerrainVertices, out TerrainIndices);
     TerrainMesh          = new StaticMesh(TerrainVertices, TerrainIndices, new AffineTransform(new Vector3(0, 0, 0)));
     Globals.TerrainVerts = TerrainVertices;
     Globals.TerrainInds  = TerrainIndices;
     Globals.space.Add(TerrainMesh);
 }
Exemplo n.º 4
0
        ///<summary>
        /// Initializes the pair handler.
        ///</summary>
        ///<param name="entryA">First entry in the pair.</param>
        ///<param name="entryB">Second entry in the pair.</param>
        public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
        {
            mesh = entryA as StaticMesh;
            if (mesh == null)
            {
                mesh = entryB as StaticMesh;
                if (mesh == null)
                {
                    throw new ArgumentException("Inappropriate types used to initialize pair.");
                }
            }


            base.Initialize(entryA, entryB);
        }
Exemplo n.º 5
0
        ///<summary>
        /// Initializes the manifold.
        ///</summary>
        ///<param name="newCollidableA">First collidable.</param>
        ///<param name="newCollidableB">Second collidable.</param>
        public override void Initialize(Collidable newCollidableA, Collidable newCollidableB)
        {
            convex = newCollidableA as ConvexCollidable;
            mesh   = newCollidableB as StaticMesh;


            if (convex == null || mesh == null)
            {
                convex = newCollidableB as ConvexCollidable;
                mesh   = newCollidableA as StaticMesh;
                if (convex == null || mesh == null)
                {
                    throw new ArgumentException("Inappropriate types used to initialize contact manifold.");
                }
            }
        }
        ///<summary>
        /// Initializes the pair handler.
        ///</summary>
        ///<param name="entryA">First entry in the pair.</param>
        ///<param name="entryB">Second entry in the pair.</param>
        public override void Initialize(BroadPhaseEntry entryA, BroadPhaseEntry entryB)
        {
            mesh   = entryA as StaticMesh;
            convex = entryB as ConvexCollidable;

            if (mesh == null || convex == null)
            {
                mesh   = entryB as StaticMesh;
                convex = entryA as ConvexCollidable;

                if (mesh == null || convex == null)
                {
                    throw new ArgumentException("Inappropriate types used to initialize pair.");
                }
            }

            //Contact normal goes from A to B.
            broadPhaseOverlap.entryA = convex;
            broadPhaseOverlap.entryB = mesh;

            UpdateMaterialProperties(convex.entity != null ? convex.entity.material : null, mesh.material);

            base.Initialize(entryA, entryB);
        }
Exemplo n.º 7
0
        //public ServerEntity WaypointTest;

        public WorldSimulator(WorldRenderer game)
        {
            Game           = game;
            parallelLooper = new ParallelLooper();
            if (Environment.ProcessorCount > 1)
            {
                for (int i = 0; i < Environment.ProcessorCount; i++)
                {
                    parallelLooper.AddThread();
                }
            }
            Globals.space             = new Space(parallelLooper);
            game.Camera.LockedUp      = Vector3.Up;
            game.Camera.ViewDirection = new Vector3(0, -1.5f, 1);
            game.Camera.Position      = new Vector3(-19.55f, 39.25f, -10.35f);
            ServerCamera = new FreeCamera(100, game.Camera, game);

            //Add some force of gravity to the simulation
            Globals.space.ForceUpdater.Gravity = new Vector3(0, -9.81f, 0);


            //Load the world terrain mesh data
            Vector3[] TerrainVertices;
            int[]     TerrainIndices;
            Model     TerrainCollision = Globals.game.Content.Load <Model>("LowDetailTerrain");

            ModelDataExtractor.GetVerticesAndIndicesFromModel(TerrainCollision, out TerrainVertices, out TerrainIndices);
            StaticMesh TerrainMesh = new StaticMesh(TerrainVertices, TerrainIndices, new AffineTransform(new Vector3(0, 0, 0)));

            Globals.TerrainVerts = TerrainVertices;
            Globals.TerrainInds  = TerrainIndices;
            Globals.space.Add(TerrainMesh);
            Globals.game.ModelDrawer.Add(TerrainMesh);

            //Create a new mesh node object for each unique location in the navigation mesh
            for (int i = 0; i < Globals.TerrainVerts.Length; i++)
            {
                //Dont create mesh nodes at locations already been used
                if (!NavMeshNodes.IsLocationAvailable(Globals.TerrainVerts[i]))
                {
                    continue;
                }

                //Add a new mesh node object to every other space in the terrain verts that we find to be available
                NavMeshNodes.AddNode(new NavMeshNode(Globals.TerrainVerts[i]));
            }

            //Now sort all of the mesh nodes into a dictionary sorted by their index in the level
            //Start with the first column of mesh nodes
            for (int i = 1; i < 10; i++)
            {
                Vector2     MeshIndex     = new Vector2(i, 1);
                int         MeshNodeIndex = (i - 1) * 2;
                NavMeshNode MeshNode      = NavMeshNodes.MeshNodes[MeshNodeIndex];
                NavMeshDictionary.AddNode(MeshNode, MeshIndex);
            }
            //Then the second column of mesh nodes
            int CurrentNodeIndex = 1;

            for (int i = 1; i < 10; i++)
            {
                Vector2 MeshIndex = new Vector2(i, 2);
                int     NodeIndex = CurrentNodeIndex;
                CurrentNodeIndex += 2;
                NavMeshNode MeshNode = NavMeshNodes.MeshNodes[NodeIndex];
                MeshNode.NodeIndex = MeshIndex;
                NavMeshDictionary.AddNode(MeshNode, MeshIndex);
            }
            //Add the other remaining columns
            int ListIndex = 18;

            for (int Column = 3; Column < 10; Column++)
            {
                for (int j = 1; j < 10; j++)
                {
                    Vector2     MeshIndex = new Vector2(j, Column);
                    NavMeshNode MeshNode  = NavMeshNodes.MeshNodes[ListIndex];
                    MeshNode.NodeIndex = MeshIndex;
                    ListIndex++;
                    NavMeshDictionary.AddNode(MeshNode, MeshIndex);
                }
            }

            //Add two game entities into the scene, the first entity will pathfind its way to the 2nd entity
            PrincessFox    = new GameEntity(new Vector3(-17.74f, 2.15f, 10.54f));
            PrincessTarget = new GameEntity(new Vector3(-41.17f, 0.89f, 24.15f));
            //Figure out which node each of these entities is closest two, these will be the ends of the pathway
            NavMeshNode StartNode = NavMeshDictionary.MeshDictionary[new Vector2(3, 4)];
            NavMeshNode EndNode   = NavMeshDictionary.MeshDictionary[new Vector2(7, 8)];

            //Find our pathway between the two entities
            List <NavMeshNode> NodePath = AStarSearch.FindPath(StartNode, EndNode, new Vector2(9, 9));
            //Now assign this path to the princess fox entity and have her navigate along to reach her target
        }