unsafe private void ProcessMesh(HKX.HKPStorageExtendedMeshShapeMeshSubpartStorage mesh, CollisionSubmesh dest)
        {
            var verts        = mesh.Vertices.GetArrayData().Elements;
            var indices      = mesh.Indices16.GetArrayData().Elements;
            var MeshIndices  = new int[(indices.Count / 4) * 3];
            var MeshVertices = new CollisionLayout[(indices.Count / 4) * 3];

            dest.PickingVertices = new Vector3[(indices.Count / 4) * 3];
            dest.PickingIndices  = new int[(indices.Count / 4) * 3];

            var factory = Scene.Renderer.Factory;

            for (int id = 0; id < indices.Count; id += 4)
            {
                int i     = (id / 4) * 3;
                var vert1 = mesh.Vertices[mesh.Indices16[id].data].Vector;
                var vert2 = mesh.Vertices[mesh.Indices16[id + 1].data].Vector;
                var vert3 = mesh.Vertices[mesh.Indices16[id + 2].data].Vector;

                MeshVertices[i]     = new CollisionLayout();
                MeshVertices[i + 1] = new CollisionLayout();
                MeshVertices[i + 2] = new CollisionLayout();

                MeshVertices[i].Position     = new Vector3(vert1.X, vert1.Y, vert1.Z);
                MeshVertices[i + 1].Position = new Vector3(vert2.X, vert2.Y, vert2.Z);
                MeshVertices[i + 2].Position = new Vector3(vert3.X, vert3.Y, vert3.Z);
                dest.PickingVertices[i]      = new Vector3(vert1.X, vert1.Y, vert1.Z);
                dest.PickingVertices[i + 1]  = new Vector3(vert2.X, vert2.Y, vert2.Z);
                dest.PickingVertices[i + 2]  = new Vector3(vert3.X, vert3.Y, vert3.Z);
                var n = Vector3.Normalize(Vector3.Cross(MeshVertices[i + 2].Position - MeshVertices[i].Position, MeshVertices[i + 1].Position - MeshVertices[i].Position));
                MeshVertices[i].Normal[0]     = (sbyte)(n.X * 127.0f);
                MeshVertices[i].Normal[1]     = (sbyte)(n.Y * 127.0f);
                MeshVertices[i].Normal[2]     = (sbyte)(n.Z * 127.0f);
                MeshVertices[i + 1].Normal[0] = (sbyte)(n.X * 127.0f);
                MeshVertices[i + 1].Normal[1] = (sbyte)(n.Y * 127.0f);
                MeshVertices[i + 1].Normal[2] = (sbyte)(n.Z * 127.0f);
                MeshVertices[i + 2].Normal[0] = (sbyte)(n.X * 127.0f);
                MeshVertices[i + 2].Normal[1] = (sbyte)(n.Y * 127.0f);
                MeshVertices[i + 2].Normal[2] = (sbyte)(n.Z * 127.0f);

                MeshVertices[i].Color[0]           = (byte)(53);
                MeshVertices[i].Color[1]           = (byte)(157);
                MeshVertices[i].Color[2]           = (byte)(255);
                MeshVertices[i].Color[3]           = (byte)(255);
                MeshVertices[i + 1].Color[0]       = (byte)(53);
                MeshVertices[i + 1].Color[1]       = (byte)(157);
                MeshVertices[i + 1].Color[2]       = (byte)(255);
                MeshVertices[i + 1].Color[3]       = (byte)(255);
                MeshVertices[i + 2].Color[0]       = (byte)(53);
                MeshVertices[i + 2].Color[1]       = (byte)(157);
                MeshVertices[i + 2].Color[2]       = (byte)(255);
                MeshVertices[i + 2].Color[3]       = (byte)(255);
                MeshVertices[i].Barycentric[0]     = 0;
                MeshVertices[i].Barycentric[1]     = 0;
                MeshVertices[i + 1].Barycentric[0] = 1;
                MeshVertices[i + 1].Barycentric[1] = 0;
                MeshVertices[i + 2].Barycentric[0] = 0;
                MeshVertices[i + 2].Barycentric[1] = 1;

                MeshIndices[i]             = i;
                MeshIndices[i + 1]         = i + 1;
                MeshIndices[i + 2]         = i + 2;
                dest.PickingIndices[i]     = i;
                dest.PickingIndices[i + 1] = i + 1;
                dest.PickingIndices[i + 2] = i + 2;
            }

            dest.VertexCount = MeshVertices.Length;
            dest.IndexCount  = MeshIndices.Length;

            uint buffersize = (uint)dest.IndexCount * 4u;

            fixed(void *ptr = dest.PickingVertices)
            {
                dest.Bounds = BoundingBox.CreateFromPoints((Vector3 *)ptr, dest.PickingVertices.Count(), 12, Quaternion.Identity, Vector3.Zero, Vector3.One);
            }

            uint vbuffersize = (uint)MeshVertices.Length * CollisionLayout.SizeInBytes;

            dest.GeomBuffer = Scene.Renderer.GeometryBufferAllocator.Allocate(vbuffersize, buffersize, (int)CollisionLayout.SizeInBytes, 4, (h) =>
            {
                h.FillIBuffer(MeshIndices, () =>
                {
                    MeshIndices = null;
                });
                h.FillVBuffer(MeshVertices, () =>
                {
                    MeshVertices = null;
                });
            });
        }
        public FlverSubmeshRenderer(Model parent, HKX colhkx, HKX.HKPStorageExtendedMeshShapeMeshSubpartStorage meshdata)
        {
            Parent = parent;

            var vertices = new VertexPositionColorNormalTangentTexture[(meshdata.Indices16.Size / 4) * 3];

            //for (int i = 0; i < meshdata.Vertices.Size; i++)
            //{
            //    var vert = meshdata.Vertices.GetArrayData().Elements[i];
            //    vertices[i] = new VertexPositionColorNormalTangentTexture();
            //    vertices[i].Position = new Vector3(vert.Vector.X, vert.Vector.Y, vert.Vector.Z);
            //}

            MeshFacesets = new List <FlverSubmeshRendererFaceSet>();
            List <ushort> indices = new List <ushort>();
            int           j       = 0;

            for (var index = 0; index < meshdata.Indices16.Size / 4; index++)
            {
                var idx  = meshdata.Indices16.GetArrayData().Elements;
                var vtxs = meshdata.Vertices.GetArrayData().Elements;

                var vert1 = vtxs[idx[index * 4].data].Vector;
                var vert2 = vtxs[idx[index * 4 + 1].data].Vector;
                var vert3 = vtxs[idx[index * 4 + 2].data].Vector;

                vertices[index * 3].Position     = new Vector3(vert1.X, vert1.Y, vert1.Z);
                vertices[index * 3 + 1].Position = new Vector3(vert2.X, vert2.Y, vert2.Z);
                vertices[index * 3 + 2].Position = new Vector3(vert3.X, vert3.Y, vert3.Z);

                Vector3 a = new Vector3(vert2.X - vert1.X, vert2.Y - vert1.Y, vert2.Z - vert1.Z);
                Vector3 b = new Vector3(vert3.X - vert1.X, vert3.Y - vert1.Y, vert3.Z - vert1.Z);

                Vector3 normal = Vector3.Cross(a, b);
                normal.Normalize();

                vertices[index * 3].Normal     = normal;
                vertices[index * 3 + 1].Normal = normal;
                vertices[index * 3 + 2].Normal = normal;

                a.Normalize();
                vertices[index * 3].Tangent     = a;
                vertices[index * 3 + 1].Tangent = a;
                vertices[index * 3 + 2].Tangent = a;

                vertices[index * 3].Binormal     = Vector3.Cross(normal, a);
                vertices[index * 3 + 1].Binormal = Vector3.Cross(normal, a);
                vertices[index * 3 + 2].Binormal = Vector3.Cross(normal, a);

                indices.Add((ushort)(index * 3));
                indices.Add((ushort)(index * 3 + 1));
                indices.Add((ushort)(index * 3 + 2));
            }

            if (indices.Count > 0)
            {
                var newFaceSet = new FlverSubmeshRendererFaceSet()
                {
                    BackfaceCulling = false,
                    IsTriangleStrip = false,
                    IndexBuffer     = new IndexBuffer(
                        GFX.Device,
                        IndexElementSize.SixteenBits,
                        indices.Count,
                        BufferUsage.WriteOnly),
                    IndexCount = indices.Count,
                };

                newFaceSet.IndexBuffer.SetData(indices.Select(x => (ushort)x).ToArray());

                MeshFacesets.Add(newFaceSet);
            }
            else
            {
                vertices = new VertexPositionColorNormalTangentTexture[meshdata.Vertices.Size];

                for (int i = 0; i < meshdata.Vertices.Size; i++)
                {
                    var vert = meshdata.Vertices.GetArrayData().Elements[i];
                    vertices[i]          = new VertexPositionColorNormalTangentTexture();
                    vertices[i].Position = new Vector3(vert.Vector.X, vert.Vector.Y, vert.Vector.Z);
                }
            }

            Bounds = BoundingBox.CreateFromPoints(vertices.Select(x => x.Position));

            VertBuffer = new VertexBuffer(GFX.Device,
                                          typeof(VertexPositionColorNormalTangentTexture), vertices.Length, BufferUsage.WriteOnly);
            VertBuffer.SetData(vertices);

            VertBufferBinding = new VertexBufferBinding(VertBuffer, 0, 0);
        }