Esempio n. 1
0
        public Cylinder(int numSides)
        {
            VertexPNTTI[] vertices = new VertexPNTTI[numSides * 2];
            int deltaTheta = 360 / numSides;
            float deltaTCX = 1.0f / (float)(numSides-1);

            for (int i = 0; i < numSides; i++)
            {
                float a = MathHelper.ToRadians(deltaTheta * i);
                Vector3 pos = new Vector3((float)Math.Cos(a), 0, (float)Math.Sin(a));
                int index = i * 2;
                vertices[index].Position = pos;
                vertices[index].Texcoord = new Vector3(i * deltaTCX, 0, 1);
                //vertices[index].Normal +=
                vertices[index + 1].Position = pos + Vector3.Up;
                vertices[index + 1].Texcoord = new Vector3(i * deltaTCX, 1, 1);
            }
            /*
            vertices[numSides * 2].Position = new Vector4(Vector3.Up * -1, 1.0f);
            vertices[numSides * 2 + 1].Position = new Vector4(Vector3.Up, 1.0f);
            */
            ushort[] indices = new ushort[6 * numSides];
            for (int i = 0; i < numSides; i++)
            {
                int index = i*6;
                int indexVert = i*2;
                indices[index] = (ushort)(indexVert + 1);
                indices[index + 1] = (ushort)indexVert;
                indices[index + 2] = (ushort)(indexVert + 2);
                indices[index + 3] = (ushort)(indexVert + 2);
                indices[index + 4] = (ushort)(indexVert + 3);
                indices[index + 5] = (ushort)(indexVert + 1);
                if (i == numSides - 1)
                {
                    indices[index + 2] = (ushort)0;
                    indices[index + 4] = (ushort)1;
                    indices[index + 3] = (ushort)0;
                }
            }

            vertexBuffer = new VertexBuffer(GFX.Device, vertices.Length * VertexPNTTI.SizeInBytes, BufferUsage.WriteOnly);
            vertexBuffer.SetData<VertexPNTTI>(vertices);

            vertexCount = vertices.Length;

            indexBuffer = new IndexBuffer(GFX.Device, sizeof(ushort) * indices.Length, BufferUsage.WriteOnly, IndexElementSize.SixteenBits);
            indexBuffer.SetData<ushort>(indices);

            primitiveCount = indices.Length / 3;

            CreateInstancedBuffers(vertices, indices);
        }
Esempio n. 2
0
        void CreateInstancedBuffers(VertexPNTTI[] verts, ushort[] ib)
        {
            VertexPNTTI[] instVerts = new VertexPNTTI[verts.Length * GFXShaderConstants.NUM_INSTANCES];
            for (int i = 0; i < GFXShaderConstants.NUM_INSTANCES; i++)
            {
                for (int j = 0; j < verts.Length; j++)
                {
                    instVerts[i * verts.Length + j] = new VertexPNTTI(verts[j].Position, verts[j].Normal, verts[j].Texcoord, verts[j].Tangent, i);
                }
            }

            ushort[] instIB = new ushort[ib.Length * GFXShaderConstants.NUM_INSTANCES];
            for (int i = 0; i < GFXShaderConstants.NUM_INSTANCES; i++)
            {
                for (int j = 0; j < ib.Length; j++)
                {
                    instIB[i * ib.Length + j] = (ushort)(ib[j] + i * verts.Length);
                }
            }

            vertexBufferInstanced = new VertexBuffer(GFX.Device, instVerts.Length * VertexPNTTI.SizeInBytes, BufferUsage.None);
            vertexBufferInstanced.SetData<VertexPNTTI>(instVerts);

            indexBufferInstanced = new IndexBuffer(GFX.Device, sizeof(ushort) * instIB.Length, BufferUsage.None, IndexElementSize.SixteenBits);
            indexBufferInstanced.SetData<ushort>(instIB);
        }
Esempio n. 3
0
        /*
        public void Render(Matrix transform, SortedList<string, AnimationNode> animNodes, RenderView view, bool performCulling)
        {
            if (performCulling)
            {
                BoundingFrustum frustum = view.GetFrustum();
                Matrix oldMat = frustum.Matrix;
                frustum.Matrix = transform * view.GetViewProjection();
                Matrix[] transforms = new Matrix[nodes.Length];
                for (int i = 0; i < nodes.Length; i++)
                    transforms[i] = animNodes[nodes[i].Name].Transform;
                for (int i = 0; i < parts.Length; i++)
                {
                    if (frustum.Contains(parts[i].bounds) != ContainmentType.Disjoint)
                    {
                        RenderElement element = parts[i].renderElement;
                        element.Transform = transforms;
                        element.IsAnimated = true;
                        view.AddElement(parts[i].material, element);
                    }
                }
                frustum.Matrix = oldMat;
            }
            else
            {
                Matrix[] transforms = new Matrix[nodes.Length];
                for (int i = 0; i < nodes.Length; i++)
                    transforms[i] = animNodes[nodes[i].Name].Transform;
                for (int i = 0; i < parts.Length; i++)
                {
                    RenderElement element = parts[i].renderElement;
                    element.Transform = transforms;
                    element.IsAnimated = true;
                    view.AddElement(parts[i].material, element);
                }
            }
        }
        */
        void CreateInstanceData()
        {
            /*
            instanceTemp = new Vector4[GFXShaderConstants.INSTANCE_TEXTURE_SIZE*GFXShaderConstants.INSTANCE_TEXTURE_SIZE * 3];
            instanceCount = 0;
            for (int i = 0; i < instanceTexture.Length; i++)
                instanceTexture[i] = new Texture2D(GFX.Device, GFXShaderConstants.INSTANCE_TEXTURE_SIZE, GFXShaderConstants.INSTANCE_TEXTURE_SIZE, 1, TextureUsage.None, SurfaceFormat.Vector4);
            */
            VertexPNTTI[] vertData = new VertexPNTTI[vertexCount];
            vertexBuffer.GetData<VertexPNTTI>(vertData);
            VertexPNTTI[] instVerts = new VertexPNTTI[vertexCount * GFXShaderConstants.NUM_INSTANCES];
            for (int i = 0; i < GFXShaderConstants.NUM_INSTANCES; i++)
            {
                for (int j = 0; j < vertexCount; j++)
                {

                    int index = i * vertexCount + j;
                    instVerts[index] = vertData[j];
                    instVerts[index].Index = i;
                }
            }

            vertexBufferInstanced = new VertexBuffer(GFX.Device, instVerts.Length * VertexPNTTI.SizeInBytes, BufferUsage.None);
            vertexBufferInstanced.SetData<VertexPNTTI>(instVerts);

            for (int i = 0; i < parts.Length; i++)
            {
                parts[i].renderElementInstanced = parts[i].renderElement;
                IndexElementSize elementSize = parts[i].renderElement.IndexBuffer.IndexElementSize;
                IndexBuffer indexBufferInstanced;

                if (instVerts.Length > ushort.MaxValue)
                    elementSize = IndexElementSize.ThirtyTwoBits;
                if (elementSize == IndexElementSize.SixteenBits)
                {
                    ushort[] indexData = new ushort[parts[i].renderElement.PrimitiveCount * 3];
                    parts[i].renderElement.IndexBuffer.GetData<ushort>(indexData);

                    ushort[] instIB = new ushort[indexData.Length * GFXShaderConstants.NUM_INSTANCES];
                    for (int k = 0; k < GFXShaderConstants.NUM_INSTANCES; k++)
                    {
                        for (int j = 0; j < indexData.Length; j++)
                        {
                            int newIndex = indexData[j] + k * vertexCount;
                            if (newIndex > ushort.MaxValue)
                                Console.WriteLine("This is very very bad!");
                            instIB[k * indexData.Length + j] = (ushort)newIndex;
                        }
                    }

                    indexBufferInstanced = new IndexBuffer(GFX.Device, sizeof(ushort) * instIB.Length, BufferUsage.None, elementSize);

                    indexBufferInstanced.SetData<ushort>(instIB);
                }
                else
                {
                    ushort[] indexData = new ushort[parts[i].renderElement.PrimitiveCount * 3];
                    parts[i].renderElement.IndexBuffer.GetData<ushort>(indexData);

                    uint[] instIB = new uint[indexData.Length * GFXShaderConstants.NUM_INSTANCES];
                    for (int k = 0; k < GFXShaderConstants.NUM_INSTANCES; k++)
                    {
                        for (int j = 0; j < indexData.Length; j++)
                        {
                            ulong index = (ulong)indexData[j] + (ulong)k * (ulong)vertexCount;
                            if (index > ulong.MaxValue)
                                Console.WriteLine("This is very very bad!");
                            instIB[k * indexData.Length + j] = (uint)(indexData[j] + k * vertexCount);
                        }
                    }

                    indexBufferInstanced = new IndexBuffer(GFX.Device, sizeof(uint) * instIB.Length, BufferUsage.None, elementSize);

                    indexBufferInstanced.SetData<uint>(instIB);
                }
                parts[i].renderElementInstanced.VertexDec = GFXVertexDeclarations.PNTTIDec;
                parts[i].renderElementInstanced.VertexStride = VertexPNTTI.SizeInBytes;
                parts[i].renderElementInstanced.IsAnimated = false;
                parts[i].renderElementInstanced.VertexBuffer = vertexBufferInstanced;
                parts[i].renderElementInstanced.IndexBuffer = indexBufferInstanced;
            }
        }
Esempio n. 4
0
        void LoadMS3D(string filename)
        {
            using (FileStream fs = new FileStream(filename, FileMode.Open))
            {
                using (BinaryReader br = new BinaryReader(fs, System.Text.Encoding.Default))
                {
                    br.ReadChars(10);
                    br.ReadInt32();
                    vertexCount = br.ReadUInt16();
                    ModelVertex[] vertices = new ModelVertex[vertexCount];

                    Vector3 minVert = Vector3.One * float.PositiveInfinity;
                    Vector3 maxVert = Vector3.One * float.NegativeInfinity;
                    for (int i = 0; i < vertexCount; i++)
                    {
                        br.ReadByte();
                        vertices[i].Position = new Vector3(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());
                        minVert = Vector3.Min(minVert, vertices[i].Position);
                        maxVert = Vector3.Max(maxVert, vertices[i].Position);
                        vertices[i].BoneIndex = (int)br.ReadChar();
                        if (vertices[i].BoneIndex >= 255)
                            vertices[i].BoneIndex = 0;
                        vertices[i].Weight = 1;
                        br.ReadByte();
                    }

                    ushort triangleCount = br.ReadUInt16();

                    Triangle[] triList = new Triangle[triangleCount];
                    for (int i = 0; i < triangleCount; i++)
                    {
                        br.ReadUInt16(); //flag

                        //Indices
                        ushort v0 = br.ReadUInt16();
                        ushort v1 = br.ReadUInt16();
                        ushort v2 = br.ReadUInt16();
                        triList[i].vertex0 = v0;
                        triList[i].vertex1 = v1;
                        triList[i].vertex2 = v2;

                        //Vertex 0 Normal
                        vertices[v0].Normal += new Vector3(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());

                        //Vertex 1 Normal
                        vertices[v1].Normal += new Vector3(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());

                        //Vertex 2 Normal
                        vertices[v2].Normal += new Vector3(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());

                        //U
                        vertices[v0].TexCoord.X = br.ReadSingle();
                        vertices[v1].TexCoord.X = br.ReadSingle();
                        vertices[v2].TexCoord.X = br.ReadSingle();

                        //V
                        vertices[v0].TexCoord.Y = br.ReadSingle();
                        vertices[v1].TexCoord.Y = br.ReadSingle();
                        vertices[v2].TexCoord.Y = br.ReadSingle();

                        vertices[v0].Weight++;
                        vertices[v1].Weight++;
                        vertices[v2].Weight++;

                        //Smoothing
                        br.ReadByte();

                        //Group index
                        br.ReadByte();
                    }

                    for (int i = 0; i < vertexCount; i++)
                    {
                        vertices[i].Normal /= vertices[i].Weight;
                        vertices[i].Weight = 1;
                    }

                    for (int i = 0; i < triangleCount; i++)
                    {
                        vertices[triList[i].vertex0].AddTangent(vertices[triList[i].vertex1], vertices[triList[i].vertex2]);
                        vertices[triList[i].vertex1].AddTangent(vertices[triList[i].vertex0].Tangent, vertices[triList[i].vertex0].Tangent2);
                        vertices[triList[i].vertex2].AddTangent(vertices[triList[i].vertex0].Tangent, vertices[triList[i].vertex0].Tangent2);
                        //vertices[triList[i].vertex1].AddTangent(vertices[triList[i].vertex0], vertices[triList[i].vertex2]);
                        //vertices[triList[i].vertex2].AddTangent(vertices[triList[i].vertex0], vertices[triList[i].vertex1]);
                    }

                    VertexPNTTI[] verts = new VertexPNTTI[vertexCount];
                    for (int i = 0; i < vertexCount; i++)
                    {
                        Vector3 N = vertices[i].Normal;
                        N.Normalize();
                        Vector3 tangent = vertices[i].Tangent / vertices[i].Weight;
                        tangent = (tangent - N * Vector3.Dot(N, tangent));
                        tangent.Normalize();
                        vertices[i].Tangent = tangent;
                        vertices[i].Tangent2 /= vertices[i].Weight;
                        vertices[i].Weight = 1;
                        float binormSign = (Vector3.Dot(Vector3.Cross(N, tangent), vertices[i].Tangent2) < 0.0f) ? -1.0f : 1.0f;
                        verts[i] = new VertexPNTTI(vertices[i].Position, vertices[i].Normal, vertices[i].TexCoord, vertices[i].Tangent, vertices[i].BoneIndex, binormSign);
                    }
                    vertexBuffer = new VertexBuffer(GFX.Device, vertexCount * VertexPNTTI.SizeInBytes, BufferUsage.None);
                    vertexBuffer.SetData<VertexPNTTI>(verts);

                    ushort groupCount = br.ReadUInt16();
                    parts = new ModelPart[groupCount];
                    int[] matIndices = new int[groupCount];
                    for (int i = 0; i < groupCount; i++)
                    {
                        br.ReadByte();
                        parts[i] = new ModelPart();
                        parts[i].name = new string(br.ReadChars(32)); //Group Name
                        parts[i].name = parts[i].name.Replace("\0",string.Empty);
                        ushort numTriangles = br.ReadUInt16(); //numTriangles

                        parts[i].renderElement = new RenderElement();
                        parts[i].renderElement.PrimitiveCount = numTriangles;
                        parts[i].renderElement.StartVertex = 0;
                        parts[i].renderElement.VertexBuffer = vertexBuffer;
                        parts[i].renderElement.VertexCount = vertexCount;
                        parts[i].renderElement.VertexStride = VertexPNTTI.SizeInBytes;
                        parts[i].renderElement.VertexDec = GFXVertexDeclarations.PNTTIDec;
                        parts[i].bounds.Max = Vector3.Zero;
                        parts[i].bounds.Min = Vector3.Zero;

                        bool useIntIndices = (numTriangles >= ushort.MaxValue);
                        IndexElementSize size = (useIntIndices) ? IndexElementSize.ThirtyTwoBits : IndexElementSize.SixteenBits;
                        int stride = (useIntIndices) ? sizeof(uint) : sizeof(ushort);

                        parts[i].renderElement.IndexBuffer = new IndexBuffer(GFX.Device, stride * numTriangles * 3, BufferUsage.None, size);

                        List<ushort> ushortIndices = new List<ushort>();
                        List<uint> uintIndices = new List<uint>();
                        for (int l = 0; l < numTriangles; l++)
                        {
                            ushort t = br.ReadUInt16(); //triangle index
                            if (useIntIndices)
                            {
                                uintIndices.Add((uint)triList[t].vertex2);
                                uintIndices.Add((uint)triList[t].vertex1);
                                uintIndices.Add((uint)triList[t].vertex0);

                            }
                            else
                            {
                                ushortIndices.Add((ushort)triList[t].vertex2);
                                ushortIndices.Add((ushort)triList[t].vertex1);
                                ushortIndices.Add((ushort)triList[t].vertex0);
                            }
                            parts[i].bounds.Max = Vector3.Max(parts[i].bounds.Max, vertices[triList[t].vertex0].Position);
                            parts[i].bounds.Max = Vector3.Max(parts[i].bounds.Max, vertices[triList[t].vertex1].Position);
                            parts[i].bounds.Max = Vector3.Max(parts[i].bounds.Max, vertices[triList[t].vertex2].Position);

                            parts[i].bounds.Min = Vector3.Min(parts[i].bounds.Min, vertices[triList[t].vertex0].Position);
                            parts[i].bounds.Min = Vector3.Min(parts[i].bounds.Min, vertices[triList[t].vertex1].Position);
                            parts[i].bounds.Min = Vector3.Min(parts[i].bounds.Min, vertices[triList[t].vertex2].Position);
                        }
                        if (useIntIndices)
                            parts[i].renderElement.IndexBuffer.SetData<uint>(uintIndices.ToArray());
                        else
                            parts[i].renderElement.IndexBuffer.SetData<ushort>(ushortIndices.ToArray());

                        matIndices[i] = (int)br.ReadChar(); //Material index
                    }

                    meshBounds = new BoundingBox(parts[0].bounds.Min, parts[0].bounds.Max);
                    for (int i = 1; i < parts.Length; i++)
                    {
                        meshBounds.Min = Vector3.Min(parts[i].bounds.Min, meshBounds.Min);
                        meshBounds.Max = Vector3.Max(parts[i].bounds.Max, meshBounds.Max);
                    }

                    ushort MaterialCount = br.ReadUInt16();
                    string[] materialNames = new string[MaterialCount];
                    for (int i = 0; i < MaterialCount; i++)
                    {

                        materialNames[i] = new string(br.ReadChars(32));
                        materialNames[i] = materialNames[i].Replace("\0", string.Empty);
                        for (int l = 0; l < 4; l++)
                            br.ReadSingle();
                        for (int l = 0; l < 4; l++)
                            br.ReadSingle();
                        for (int l = 0; l < 4; l++)
                            br.ReadSingle();
                        for (int l = 0; l < 4; l++)
                            br.ReadSingle();

                        br.ReadSingle();
                        br.ReadSingle();
                        br.ReadChar();
                        br.ReadChars(128);
                        br.ReadChars(128);
                    }

                    CheckMissingMaterials(filename, matIndices, materialNames);

                    for (int i = 0; i < groupCount; i++)
                    {
                        int matIndex = matIndices[i];
                        if (matIndex < 255)
                            parts[i].material = ResourceManager.Inst.GetMaterial(materialNames[matIndex]);

                        if (parts[i].material == null)
                            parts[i].material = ResourceManager.Inst.GetMaterial("NULL");
                    }

                    float fps = br.ReadSingle();//FPS
                    br.ReadSingle();//current time
                    int frameCount = br.ReadInt32(); //Total frames

                    ushort boneCount = br.ReadUInt16();
                    nodes = new AnimationNode[boneCount];
                    if (boneCount > 0)
                    {
                        List<string> nodeParentNames = new List<string>();

                        for (int i = 0; i < boneCount; i++)
                        {
                            br.ReadByte(); //flag

                            string name = new string(br.ReadChars(32)).Replace("\0", "");
                            string parentName = new string(br.ReadChars(32)).Replace("\0", "");
                            nodeParentNames.Add(parentName);

                            Vector3 rotation = new Vector3(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());

                            Vector3 position = new Vector3(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());

                            nodes[i] = new AnimationNode(name, position, rotation);
                            namesToNodes.Add(name, nodes[i]);

                            ushort keyRotCount = br.ReadUInt16(); //Key frame rot count
                            ushort keyPosCount = br.ReadUInt16(); //Key frame pos count
                            //nodes[i].rotationFrames = new ModelBoneAnimationFrame[keyRotCount];
                            //nodes[i].translationFrames = new ModelBoneAnimationFrame[keyPosCount];
                            /*
                            for (int j = 0; j < keyRotCount; j++)
                            {
                                nodes[i].rotationFrames[j].time = br.ReadSingle() * fps; //time
                                nodes[i].rotationFrames[j].Displacement = new Vector3(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());
                                nodes[i].rotationFrames[j].boneName = name;
                            }

                            for (int j = 0; j < keyPosCount; j++)
                            {
                                nodes[i].translationFrames[j].time = br.ReadSingle() * fps; //time
                                nodes[i].translationFrames[j].Displacement = new Vector3(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());
                                nodes[i].translationFrames[j].boneName = name;
                            }*/
                            int count = (keyRotCount + keyPosCount) * 4;
                            for (int j = 0; j < count; j++)
                                br.ReadSingle();
                        }

                        List<AnimationNode> rootNodeList = new List<AnimationNode>();
                        for (int i = 0; i < nodes.Length; i++)
                        {
                            if (namesToNodes.ContainsKey(nodeParentNames[i]))
                            {
                                AnimationNode node = namesToNodes[nodeParentNames[i]];
                                node.children.Add(nodes[i]);
                            }
                            else
                                rootNodeList.Add(nodes[i]);
                        }
                        rootNodes = rootNodeList.ToArray();
                        for (int i = 0; i < rootNodes.Length; i++)
                        {
                            Matrix identityMat = Matrix.Identity;
                            rootNodes[i].ApplyTransform(ref identityMat);
                        }

                        Matrix[] inverseMats = new Matrix[nodes.Length];
                        Matrix[] invRotMats = new Matrix[nodes.Length];
                        for (int i = 0; i < inverseMats.Length; i++)
                        {
                            inverseMats[i] = Matrix.Invert(nodes[i].Transform);
                            invRotMats[i] = MathUtils.Invert3x3(nodes[i].Transform);
                        }

                        if (nodesAreAnimated)
                        {
                            for (int i = 0; i < verts.Length; i++)
                            {
                                verts[i].Position = Vector3.Transform(verts[i].Position, inverseMats[(int)verts[i].Index]);
                                verts[i].Normal = Vector3.TransformNormal(verts[i].Normal, inverseMats[(int)verts[i].Index]);
                                verts[i].Tangent = Vector3.TransformNormal(verts[i].Tangent, inverseMats[(int)verts[i].Index]);
                            }
                        }
                        vertexBuffer.SetData<VertexPNTTI>(verts);

                        for (int i = 0; i < nodes.Length; i++)
                        {
                            Vector3 Rotation = nodes[i].Rotation;
                            Matrix transform = Matrix.CreateRotationX(Rotation.X) * Matrix.CreateRotationY(Rotation.Y) * Matrix.CreateRotationZ(Rotation.Z);
                            transform.Translation = nodes[i].Translation;
                            nodes[i].Transform = transform;
                        }

                    }
                }
            }
        }
Esempio n. 5
0
        void CreateCollisionMesh(ModelPart collisionMesh)
        {
            SortedList<ushort, ushort> renamedVertexIndices = new SortedList<ushort, ushort>();
            SortedList<ushort, ushort> renamedVertexIndicesCollision = new SortedList<ushort, ushort>();
            RenderElement collisionElem = collisionMesh.renderElement;
            List<Vector3> collisionVerts = new List<Vector3>();
            List<TriangleVertexIndices> collisionIndices = new List<TriangleVertexIndices>(collisionElem.PrimitiveCount);
            VertexPNTTI[] vertexData = new VertexPNTTI[vertexCount];
            vertexBuffer.GetData<VertexPNTTI>(vertexData);
            ushort[] indexDataCollision = new ushort[collisionElem.PrimitiveCount * 3];
            collisionElem.IndexBuffer.GetData<ushort>(indexDataCollision);

            for (int i = 0; i < collisionElem.PrimitiveCount; i++)
            {
                int index = i * 3;
                for(int j = 0; j < 3; j++)
                {
                    ushort currIdx = indexDataCollision[index + j];
                    if(!renamedVertexIndicesCollision.ContainsKey(currIdx))
                    {
                        renamedVertexIndicesCollision.Add(currIdx, (ushort)collisionVerts.Count);
                        Vector3 pos;
                        pos.X = vertexData[currIdx].Position.X;
                        pos.Y = vertexData[currIdx].Position.Y;
                        pos.Z = vertexData[currIdx].Position.Z;
                        collisionVerts.Add(pos);
                    }
                }
                ushort idx0 = indexDataCollision[index + 0];
                ushort idx1 = indexDataCollision[index + 1];
                ushort idx2 = indexDataCollision[index + 2];
                collisionIndices.Add(new TriangleVertexIndices(renamedVertexIndicesCollision[idx2], renamedVertexIndicesCollision[idx1], renamedVertexIndicesCollision[idx0]));
            }
            /*
            this.collisionMesh = new TriangleMesh();
            this.collisionMesh.CreateMesh(collisionVerts, collisionIndices, 0, 0);
            */
            this.collisionMesh = new TriangleMesh(collisionVerts, collisionIndices);

            List<VertexPNTTI> newVertexData = new List<VertexPNTTI>();
            for (int i = 0; i < parts.Length; i++)
            {
                RenderElement currElem = parts[i].renderElement;
                ushort[] indexData = new ushort[currElem.PrimitiveCount * 3];
                currElem.IndexBuffer.GetData<ushort>(indexData);
                for (int j = 0; j < indexData.Length; j++)
                {
                    if (!renamedVertexIndices.ContainsKey(indexData[j]))
                    {
                        renamedVertexIndices.Add(indexData[j], (ushort)newVertexData.Count);
                        newVertexData.Add(vertexData[indexData[j]]);
                    }
                    indexData[j] = renamedVertexIndices[indexData[j]];
                }
                currElem.IndexBuffer.SetData<ushort>(indexData);
            }
            vertexBuffer.Dispose();

            vertexCount = newVertexData.Count;
            vertexBuffer = new VertexBuffer(GFX.Device, VertexPNTTI.SizeInBytes * newVertexData.Count, BufferUsage.None);
            vertexBuffer.SetData<VertexPNTTI>(newVertexData.ToArray());
            for (int i = 0; i < parts.Length; i++)
                parts[i].renderElement.VertexBuffer = vertexBuffer;
        }