Esempio n. 1
0
        private unsafe void AddMeshTriangles(MyIsoMesh mesh, Vector3 offset, Matrix rotation, Matrix ownRotation)
        {
            for (int i = 0; i < mesh.TrianglesCount; i++)
            {
                ushort num2 = mesh.Triangles[i].V0;
                ushort num3 = mesh.Triangles[i].V1;
                ushort num4 = mesh.Triangles[i].V2;
                m_worldVertices.Triangles.Add(m_worldVertices.VerticesMaxValue + num4);
                m_worldVertices.Triangles.Add(m_worldVertices.VerticesMaxValue + num3);
                m_worldVertices.Triangles.Add(m_worldVertices.VerticesMaxValue + num2);
            }
            for (int j = 0; j < mesh.VerticesCount; j++)
            {
                Vector3 vector;
                mesh.GetUnpackedPosition(j, out vector);
                Vector3 *vectorPtr1 = (Vector3 *)ref vector;
                Vector3.Transform(ref (Vector3) ref vectorPtr1, ref ownRotation, out vector);
                vector -= offset;
                Vector3 *vectorPtr2 = (Vector3 *)ref vector;
                Vector3.Transform(ref (Vector3) ref vectorPtr2, ref rotation, out vector);
                m_worldVertices.Vertices.Add(vector);
            }
            WorldVerticesInfo worldVertices = m_worldVertices;

            worldVertices.VerticesMaxValue += mesh.VerticesCount;
        }
Esempio n. 2
0
        private unsafe void BoundingBoxToTranslatedTriangles(BoundingBoxD bbox, Matrix worldMatrix)
        {
            Vector3  result     = new Vector3(bbox.Min.X, bbox.Max.Y, bbox.Max.Z);
            Vector3  vector2    = new Vector3(bbox.Max.X, bbox.Max.Y, bbox.Max.Z);
            Vector3  vector3    = new Vector3(bbox.Min.X, bbox.Max.Y, bbox.Min.Z);
            Vector3  vector4    = new Vector3(bbox.Max.X, bbox.Max.Y, bbox.Min.Z);
            Vector3  vector5    = new Vector3(bbox.Min.X, bbox.Min.Y, bbox.Max.Z);
            Vector3  vector6    = new Vector3(bbox.Max.X, bbox.Min.Y, bbox.Max.Z);
            Vector3  vector7    = new Vector3(bbox.Min.X, bbox.Min.Y, bbox.Min.Z);
            Vector3  vector8    = new Vector3(bbox.Max.X, bbox.Min.Y, bbox.Min.Z);
            Vector3 *vectorPtr1 = (Vector3 *)ref result;

            Vector3.Transform(ref (Vector3) ref vectorPtr1, ref worldMatrix, out result);
            Vector3 *vectorPtr2 = (Vector3 *)ref vector2;

            Vector3.Transform(ref (Vector3) ref vectorPtr2, ref worldMatrix, out vector2);
            Vector3 *vectorPtr3 = (Vector3 *)ref vector3;

            Vector3.Transform(ref (Vector3) ref vectorPtr3, ref worldMatrix, out vector3);
            Vector3 *vectorPtr4 = (Vector3 *)ref vector4;

            Vector3.Transform(ref (Vector3) ref vectorPtr4, ref worldMatrix, out vector4);
            Vector3 *vectorPtr5 = (Vector3 *)ref vector5;

            Vector3.Transform(ref (Vector3) ref vectorPtr5, ref worldMatrix, out vector5);
            Vector3 *vectorPtr6 = (Vector3 *)ref vector6;

            Vector3.Transform(ref (Vector3) ref vectorPtr6, ref worldMatrix, out vector6);
            Vector3 *vectorPtr7 = (Vector3 *)ref vector7;

            Vector3.Transform(ref (Vector3) ref vectorPtr7, ref worldMatrix, out vector7);
            Vector3 *vectorPtr8 = (Vector3 *)ref vector8;

            Vector3.Transform(ref (Vector3) ref vectorPtr8, ref worldMatrix, out vector8);
            m_worldVertices.Vertices.Add(result);
            m_worldVertices.Vertices.Add(vector2);
            m_worldVertices.Vertices.Add(vector3);
            m_worldVertices.Vertices.Add(vector4);
            m_worldVertices.Vertices.Add(vector5);
            m_worldVertices.Vertices.Add(vector6);
            m_worldVertices.Vertices.Add(vector7);
            m_worldVertices.Vertices.Add(vector8);
            int verticesMaxValue = m_worldVertices.VerticesMaxValue;
            int item             = m_worldVertices.VerticesMaxValue + 1;
            int num3             = m_worldVertices.VerticesMaxValue + 2;
            int num4             = m_worldVertices.VerticesMaxValue + 3;
            int num5             = m_worldVertices.VerticesMaxValue + 4;
            int num6             = m_worldVertices.VerticesMaxValue + 5;
            int num7             = m_worldVertices.VerticesMaxValue + 6;
            int num8             = m_worldVertices.VerticesMaxValue + 7;

            m_worldVertices.Triangles.Add(num4);
            m_worldVertices.Triangles.Add(num3);
            m_worldVertices.Triangles.Add(verticesMaxValue);
            m_worldVertices.Triangles.Add(verticesMaxValue);
            m_worldVertices.Triangles.Add(item);
            m_worldVertices.Triangles.Add(num4);
            m_worldVertices.Triangles.Add(num5);
            m_worldVertices.Triangles.Add(num7);
            m_worldVertices.Triangles.Add(num8);
            m_worldVertices.Triangles.Add(num8);
            m_worldVertices.Triangles.Add(num6);
            m_worldVertices.Triangles.Add(num5);
            m_worldVertices.Triangles.Add(num3);
            m_worldVertices.Triangles.Add(num8);
            m_worldVertices.Triangles.Add(num7);
            m_worldVertices.Triangles.Add(num3);
            m_worldVertices.Triangles.Add(num4);
            m_worldVertices.Triangles.Add(num8);
            m_worldVertices.Triangles.Add(verticesMaxValue);
            m_worldVertices.Triangles.Add(num5);
            m_worldVertices.Triangles.Add(num6);
            m_worldVertices.Triangles.Add(num6);
            m_worldVertices.Triangles.Add(item);
            m_worldVertices.Triangles.Add(verticesMaxValue);
            m_worldVertices.Triangles.Add(num7);
            m_worldVertices.Triangles.Add(num5);
            m_worldVertices.Triangles.Add(verticesMaxValue);
            m_worldVertices.Triangles.Add(verticesMaxValue);
            m_worldVertices.Triangles.Add(num3);
            m_worldVertices.Triangles.Add(num7);
            m_worldVertices.Triangles.Add(item);
            m_worldVertices.Triangles.Add(num6);
            m_worldVertices.Triangles.Add(num8);
            m_worldVertices.Triangles.Add(num8);
            m_worldVertices.Triangles.Add(num4);
            m_worldVertices.Triangles.Add(item);
            WorldVerticesInfo worldVertices = m_worldVertices;

            worldVertices.VerticesMaxValue += 8;
        }
Esempio n. 3
0
        private unsafe void AddPhysicalShape(HkShape shape, Matrix rdWorldMatrix)
        {
            switch (shape.ShapeType)
            {
            case HkShapeType.Sphere:
            {
                HkSphereShape shape7 = (HkSphereShape)shape;
                m_icosphereMesh.AddTrianglesToWorldVertices(rdWorldMatrix.Translation, shape7.Radius);
                return;
            }

            case HkShapeType.Cylinder:
            case HkShapeType.Triangle:
            case HkShapeType.TriSampledHeightFieldCollection:
            case HkShapeType.TriSampledHeightFieldBvTree:
                break;

            case HkShapeType.Box:
            {
                HkBoxShape   shape2 = (HkBoxShape)shape;
                Vector3D     min    = new Vector3D((double)-shape2.HalfExtents.X, (double)-shape2.HalfExtents.Y, (double)-shape2.HalfExtents.Z);
                Vector3D     max    = new Vector3D((double)shape2.HalfExtents.X, (double)shape2.HalfExtents.Y, (double)shape2.HalfExtents.Z);
                BoundingBoxD bbox   = new BoundingBoxD(min, max);
                this.BoundingBoxToTranslatedTriangles(bbox, rdWorldMatrix);
                return;
            }

            case HkShapeType.Capsule:
                return;

            case HkShapeType.ConvexVertices:
            {
                Vector3 vector;
                HkConvexVerticesShape shape9   = (HkConvexVerticesShape)shape;
                HkGeometry            geometry = new HkGeometry();
                shape9.GetGeometry(geometry, out vector);
                int triangleIndex = 0;
                while (true)
                {
                    int num2;
                    int num3;
                    int num4;
                    int num5;
                    if (triangleIndex >= geometry.TriangleCount)
                    {
                        int vertexIndex = 0;
                        while (true)
                        {
                            if (vertexIndex >= geometry.VertexCount)
                            {
                                WorldVerticesInfo worldVertices = m_worldVertices;
                                worldVertices.VerticesMaxValue += geometry.VertexCount;
                                break;
                            }
                            Vector3  vertex     = geometry.GetVertex(vertexIndex);
                            Vector3 *vectorPtr1 = (Vector3 *)ref vertex;
                            Vector3.Transform(ref (Vector3) ref vectorPtr1, ref rdWorldMatrix, out vertex);
                            m_worldVertices.Vertices.Add(vertex);
                            vertexIndex++;
                        }
                        break;
                    }
                    geometry.GetTriangle(triangleIndex, out num2, out num3, out num4, out num5);
                    m_worldVertices.Triangles.Add(m_worldVertices.VerticesMaxValue + num2);
                    m_worldVertices.Triangles.Add(m_worldVertices.VerticesMaxValue + num3);
                    m_worldVertices.Triangles.Add(m_worldVertices.VerticesMaxValue + num4);
                    triangleIndex++;
                }
                break;
            }

            case HkShapeType.List:
            {
                HkShapeContainerIterator iterator = ((HkListShape)shape).GetIterator();
                while (iterator.IsValid)
                {
                    this.AddPhysicalShape(iterator.CurrentValue, rdWorldMatrix);
                    iterator.Next();
                }
                return;
            }

            case HkShapeType.Mopp:
            {
                HkMoppBvTreeShape shape4 = (HkMoppBvTreeShape)shape;
                this.AddPhysicalShape((HkShape)shape4.ShapeCollection, rdWorldMatrix);
                return;
            }

            case HkShapeType.ConvexTranslate:
            {
                HkConvexTranslateShape shape6 = (HkConvexTranslateShape)shape;
                Matrix matrix = Matrix.CreateTranslation(shape6.Translation);
                this.AddPhysicalShape((HkShape)shape6.ChildShape, matrix * rdWorldMatrix);
                return;
            }

            case HkShapeType.ConvexTransform:
            {
                HkConvexTransformShape shape5 = (HkConvexTransformShape)shape;
                this.AddPhysicalShape((HkShape)shape5.ChildShape, shape5.Transform * rdWorldMatrix);
                return;
            }

            default:
                return;
            }
        }