Beispiel #1
0
        public void TestVertexPosition()
        {
            Assert.That(VertexPosition.VertexDeclaration.VertexStride, Is.EqualTo(12));

            var vertexElements = VertexPosition.VertexDeclaration.GetVertexElements();
            Assert.That(vertexElements, Has.Length.EqualTo(1));
            Assert.That(vertexElements[0].Offset, Is.EqualTo(0));
            Assert.That(vertexElements[0].UsageIndex, Is.EqualTo(0));
            Assert.That(vertexElements[0].VertexElementFormat, Is.EqualTo(VertexElementFormat.Vector3));
            Assert.That(vertexElements[0].VertexElementUsage, Is.EqualTo(VertexElementUsage.Position));

            var vertex1 = new VertexPosition(Vector3.One);
            var vertex2 = new VertexPosition(Vector3.One);
            var vertex3 = new VertexPosition(Vector3.Zero);

            Assert.That(vertex1 == vertex2, Is.True);
            Assert.That(vertex1 != vertex2, Is.False);
            Assert.That(vertex1 == vertex3, Is.False);
            Assert.That(vertex1 != vertex3, Is.True);
            Assert.That(vertex1.Equals(vertex2), Is.True);
            Assert.That(vertex1.Equals(vertex3), Is.False);
        }
        public static ModelBoundingBoxBuffer CalcBoundingBoxes(Model scene)
        {
            ModelBoundingBoxBuffer ret = new ModelBoundingBoxBuffer();
            ret.Model = scene;

            foreach (ModelMesh mesh in scene.Meshes)
            {
                ModelMeshBoundingBoxBuffer meshBox = new ModelMeshBoundingBoxBuffer();
                meshBox.Mesh = mesh;

                ret.MeshList.Add(meshBox);

                for (int j = 0; j < mesh.MeshParts.Count; j++)
                {
                    ModelMeshPart part = mesh.MeshParts[j];

                    Vector3 min = Vector3.One * float.MaxValue;
                    Vector3 max = Vector3.One * float.MinValue;

                    VertexPosition[] vertices = new VertexPosition[part.NumVertices];

                    //mesh.VertexBuffer.GetData<VertexPosition>(part.BaseVertex * part.VertexStride, vertices, 0, part.NumVertices, part.VertexStride);

                    //mesh.VertexBuffer.GetData<VertexPosition>(part.BaseVertex * part.VertexStride, vertices, 0, part.NumVertices, part.VertexStride);
                    part.VertexBuffer.GetData<VertexPosition>(vertices);

                    for (int x = 0; x < part.NumVertices; x++)
                    {
                        min = Vector3.Min(min, vertices[x].Position);
                        max = Vector3.Max(max, vertices[x].Position);
                    }

                    meshBox.BoundingBoxes.Add(new BoundingBox(min, max));
                }
            }
            return ret;
        }
 public Line2D(Vector3 p1, Vector3 p2)
 {
     vertexBuffer = new VertexBuffer(GraphicsDeviceHolder.Device, sizeof(float) * 6, BufferUsage.None);
      var data = new VertexPosition[] { new VertexPosition(p1), new VertexPosition(p2) };
      vertexBuffer.SetData<VertexPosition>(data);
 }
        public static bool SelectPolyFromModel(Model scene,
                                 Matrix sceneTransform,
                                 Ray pickRay,
                                 out int meshIndex,
                                 out int meshPartIndex,
                                 out int polyIndex)
        {
            meshIndex = -1;
            polyIndex = -1;
            meshPartIndex = -1;

            float fClosestPoly = float.MaxValue;

            Matrix[] transforms = new Matrix[scene.Bones.Count];
            scene.CopyAbsoluteBoneTransformsTo(transforms);

            Ray meshSpaceRay = new Ray();

            for (int i = 0; i < scene.Meshes.Count; i++)
            {
                ModelMesh mesh = scene.Meshes[i];

                Matrix inverseSceneTransform =
                    Matrix.Invert(transforms[mesh.ParentBone.Index] * sceneTransform);

                Vector3 rayPosition = Vector3.Transform(pickRay.Position,
                                                        inverseSceneTransform);

                Vector3 rayDirection = Vector3.TransformNormal(pickRay.Direction,
                                                               inverseSceneTransform);

                meshSpaceRay.Position = rayPosition;
                meshSpaceRay.Direction = rayDirection;

                if (mesh.BoundingSphere.Intersects(meshSpaceRay).HasValue == false)
                {
                    //  continue;
                }

                List<collidingPart> collidingParts = new List<collidingPart>();

                if (!CollisionUtility.Contains(scene))
                {
                    CollisionUtility.ModelBoundingInfo.Add(CalcBoundingBoxes(scene));
                }
                else
                {
                    foreach (ModelBoundingBoxBuffer mbb in modelBoundingInfo)
                    {
                        for (int j = 0; j < mbb.MeshList[i].BoundingBoxes.Count; j++)
                        {
                            float? f = meshSpaceRay.Intersects(mbb.MeshList[i].BoundingBoxes[j]);
                            if (f.HasValue)
                            {
                                collidingPart cp;
                                cp.MeshIndex = i;
                                cp.MeshPartIndex = j;
                                cp.Distance = f.Value;
                                collidingParts.Add(cp);
                            }
                        }
                    }
                    collidingParts.Sort();
                }

                if (collidingParts.Count == 0)
                {
                    continue;
                }

                if (mesh.MeshParts[0].IndexBuffer.IndexElementSize == IndexElementSize.SixteenBits)
                {
                    for (int j = 0; j < collidingParts.Count; j++)
                    {
                        collidingPart prt = collidingParts[j];

                        ModelMeshPart part = mesh.MeshParts[prt.MeshPartIndex];

            #if DEBUG_RENDER
                        foreach (ModelBoundingBoxBuffer mbb in modelBoundingInfo)
                        {
                            for (int x = 0; x < mbb.MeshList[i].BoundingBoxes.Count; x++)
                            {
                                if (x == prt.MeshPartIndex)
                                {
                                    VectorRenderer.SetColor(Color.Red);
                                    VectorRenderer.SetWorldMatrix(transforms[mesh.ParentBone.Index] * sceneTransform);
                                    VectorRenderer.Draw(mbb.MeshList[i].BoundingBoxes[prt.MeshPartIndex]);
                                }
                            }
                        }
            #endif

                        short[] indices = new short[part.PrimitiveCount * 3];
                        //mesh.IndexBuffer.GetData<short>(part.StartIndex * sizeof(short), indices, 0, part.PrimitiveCount * 3);
                        part.IndexBuffer.GetData<short>(part.StartIndex * sizeof(short), indices, 0, part.PrimitiveCount * 3);

                        VertexPosition[] vertices = new VertexPosition[part.NumVertices];

                        //mesh.VertexBuffer.GetData<VertexPosition>(part.BaseVertex * part.VertexStride, vertices, 0, part.NumVertices, part.VertexStride);
                        part.VertexBuffer.GetData<CollisionUtility.VertexPosition>(vertices, part.StartIndex, part.NumVertices);

                        for (int x = 0; x < part.PrimitiveCount; x++)
                        {
                            float fDist;

                            if (Intersection.RayTriangleIntersect(
                                meshSpaceRay,
                                vertices[indices[x * 3 + 0]].Position,
                                vertices[indices[x * 3 + 1]].Position,
                                vertices[indices[x * 3 + 2]].Position,
                                out fDist))
                            {
                                if (fDist < fClosestPoly)
                                {
                                    meshIndex = i;
                                    meshPartIndex = prt.MeshPartIndex;
                                    polyIndex = x;

                                    fClosestPoly = fDist;
                                }
                            }
                        }
                    }
                }
                else if (mesh.MeshParts[0].IndexBuffer.IndexElementSize == IndexElementSize.ThirtyTwoBits)
                {
                    for (int j = 0; j < collidingParts.Count; j++)
                    {
                        collidingPart prt = collidingParts[j];

                        ModelMeshPart part = mesh.MeshParts[prt.MeshPartIndex];

            #if DEBUG_RENDER
                        foreach (ModelBoundingBoxBuffer mbb in modelBoundingInfo)
                        {
                            for (int x = 0; x < mbb.MeshList[i].BoundingBoxes.Count; x++)
                            {
                                if (x == prt.MeshPartIndex)
                                {
                                    VectorRenderer.SetColor(Color.Red);
                                    VectorRenderer.SetWorldMatrix(sceneTransform * transforms[mesh.ParentBone.Index]);
                                    VectorRenderer.Draw(mbb.MeshList[i].BoundingBoxes[prt.MeshPartIndex]);
                                }
                            }
                        }
            #endif
                        int[] indices = new int[part.PrimitiveCount * 3];
                        //mesh.IndexBuffer.GetData<int>(part.StartIndex * sizeof(int), indices, 0, part.PrimitiveCount * 3);
                        part.IndexBuffer.GetData<int>(part.StartIndex * sizeof(int), indices, 0, part.PrimitiveCount * 3);

                        VertexPosition[] vertices = new VertexPosition[part.NumVertices];

                        //mesh.VertexBuffer.GetData<VertexPosition>(part.BaseVertex * part.VertexStride, vertices, 0, part.NumVertices, part.VertexStride);
                        part.VertexBuffer.GetData<CollisionUtility.VertexPosition>(vertices, part.StartIndex, part.NumVertices);

                        for (int x = 0; x < part.PrimitiveCount; x++)
                        {
                            float fDist;

                            if (Intersection.RayTriangleIntersect(
                                meshSpaceRay,
                                vertices[indices[x * 3 + 0]].Position,
                                vertices[indices[x * 3 + 1]].Position,
                                vertices[indices[x * 3 + 2]].Position,
                                out fDist))
                            {
                                if (fDist < fClosestPoly)
                                {
                                    meshIndex = i;
                                    meshPartIndex = prt.MeshPartIndex;
                                    polyIndex = x;

                                    fClosestPoly = fDist;
                                }
                            }
                        }
                    }
                }
            }

            return meshIndex != -1 && polyIndex != -1 && meshPartIndex != -1;
        }
Beispiel #5
0
		VertexPosition[] generateVerts( Vector2[] points )
		{
			// we need to make tris from the points. all points will be shared with the center (0,0)
			var verts = new VertexPosition[points.Length + 1];

			// the first point is the center so we start at 1
			for( var i = 1; i <= points.Length; i++ )
			{
				verts[i].Position.X = points[i - 1].X;
				verts[i].Position.Y = points[i - 1].Y;
			}

			return verts;
		}