public GPUSkinVertexStruct(SoftSkinVertexStruct sv)
 {
     InfluenceBones   = sv.InfluenceBones;
     InfluenceWeights = sv.InfluenceWeights;
     Position         = sv.Position;
     TangentX         = sv.TangentX;
     TangentY         = sv.TangentY;
     TangentZ         = sv.TangentZ;
     U        = sv.UV[0].X;
     V        = sv.UV[0].Y;
     Normals  = new float[3];
     Tangents = new float[3];
 }
            public void Serialize(SerializingContainer Container)
            {
                //basevertex
                BaseVertexIndex = Container + BaseVertexIndex;
                //rigid vertices
                int count = 0;

                if (!Container.isLoading)
                {
                    count = RiginSkinVertices.Count();
                }
                count = Container + count;
                if (Container.isLoading)
                {
                    RiginSkinVertices = new List <RigidSkinVertexStruct>();
                    for (int i = 0; i < count; i++)
                    {
                        RiginSkinVertices.Add(new RigidSkinVertexStruct());
                    }
                }
                for (int i = 0; i < count; i++)
                {
                    RigidSkinVertexStruct v = RiginSkinVertices[i];
                    v.Serialize(Container);
                    RiginSkinVertices[i] = v;
                }
                //soft vertices
                if (!Container.isLoading)
                {
                    count = SoftSkinVertices.Count();
                }
                count = Container + count;
                if (Container.isLoading)
                {
                    SoftSkinVertices = new List <SoftSkinVertexStruct>();
                    for (int i = 0; i < count; i++)
                    {
                        SoftSkinVertices.Add(new SoftSkinVertexStruct());
                    }
                }
                for (int i = 0; i < count; i++)
                {
                    SoftSkinVertexStruct v = SoftSkinVertices[i];
                    v.Serialize(Container);
                    SoftSkinVertices[i] = v;
                }
                //bonemap
                if (!Container.isLoading)
                {
                    count = BoneMap.Count();
                }
                count = Container + count;
                if (Container.isLoading)
                {
                    BoneMap = new List <ushort>();
                    for (int i = 0; i < count; i++)
                    {
                        BoneMap.Add(0);
                    }
                }
                for (int i = 0; i < count; i++)
                {
                    BoneMap[i] = Container + BoneMap[i];
                }
                //rest
                NumRigidVertices  = Container + NumRigidVertices;
                NumSoftVertices   = Container + NumSoftVertices;
                MaxBoneInfluences = Container + MaxBoneInfluences;
            }
            public void Serialize(SerializingContainer Container, MEVersion version)
            {
                //NumTexCoords
                NumTexCoords = 1;

                if (version == MEVersion.ME1)
                {
                    //VertexSize
                    VertexSize = Container + VertexSize;

                    Vertices = new List <GPUSkinVertexStruct>();
                    int VertsCount = 0;
                    VertsCount = Container + VertsCount;
                    for (int i = 0; i < VertsCount; i++)
                    {
                        var aSoftVert = new SoftSkinVertexStruct();
                        aSoftVert.Serialize(Container);
                        GPUSkinVertexStruct gpuv = new GPUSkinVertexStruct(aSoftVert);
                        Vertices.Add(gpuv);
                    }
                    UseFullPrecisionUVs = 1;
                    return;
                }

                ////UseFullPrecisionUVs
                UseFullPrecisionUVs = Container + UseFullPrecisionUVs;
                if (version == MEVersion.ME3)
                {
                    ////UsePackedPosition
                    UsePackedPosition = Container + UsePackedPosition;
                    //Extension
                    Extension.X = Container + Extension.X;
                    Extension.Y = Container + Extension.Y;
                    Extension.Z = Container + Extension.Z;
                    //origin
                    Origin.X = Container + Origin.X;
                    Origin.Y = Container + Origin.Y;
                    Origin.Z = Container + Origin.Z;
                }

                //vertexsize
                VertexSize = Container + VertexSize;
                int count = 0;

                if (!Container.isLoading)
                {
                    count = Vertices.Count();
                }
                count = Container + count;
                if (Container.isLoading)
                {
                    Vertices = new List <GPUSkinVertexStruct>();
                    for (int i = 0; i < count; i++)
                    {
                        Vertices.Add(new GPUSkinVertexStruct());
                    }
                }
                int VertexDiff = VertexSize - 32;

                for (int i = 0; i < count; i++)
                {
                    GPUSkinVertexStruct v = Vertices[i];
                    v.Serialize(Container, version);

                    if (VertexDiff > 0)
                    {
                        byte b = 0;
                        for (int j = 0; j < VertexDiff; j++)
                        {
                            b = Container + b;
                        }
                    }
                    Vertices[i] = v;
                }
            }