public override object WriteTo(object obj)
        {
            if (obj == null)
            {
                return(null);
            }

            Mesh o = (Mesh)obj;

            if (!m_assetDB.IsStaticResourceID(m_assetDB.ToID(o)))
            {
                o.indexFormat = indexFormat;
                if (vertices != null)
                {
                    o.vertices = vertices;
                }

                o.subMeshCount = subMeshCount;
                if (m_tris != null)
                {
                    if (m_topology != null && m_topology.Length == subMeshCount)
                    {
                        for (int i = 0; i < subMeshCount; ++i)
                        {
                            MeshTopology topology = m_topology[i];
                            switch (topology)
                            {
                            case MeshTopology.Points:
                            case MeshTopology.Lines:
                                o.SetIndices(m_tris[i].Array, topology, i);
                                break;

                            case MeshTopology.Triangles:
                                o.SetTriangles(m_tris[i].Array, i);
                                break;
                            }
                        }
                    }
                    else
                    {
                        for (int i = 0; i < subMeshCount; ++i)
                        {
                            o.SetTriangles(m_tris[i].Array, i);
                        }
                    }
                }

                o.boneWeights = boneWeights;
                o.bindposes   = bindposes;
                o.bounds      = bounds;
                o.normals     = normals;
                o.tangents    = tangents;
                o.uv          = uv;
                o.uv2         = uv2;
                o.uv3         = uv3;
                o.uv4         = uv4;
                o.uv5         = uv5;
                o.uv6         = uv6;
                o.uv7         = uv7;
                o.uv8         = uv8;
                o.colors      = colors;

                if (blendShapeCount > 0)
                {
                    o.ClearBlendShapes();

                    int index = 0;
                    for (int shapeIndex = 0; shapeIndex < blendShapeCount; ++shapeIndex)
                    {
                        int    frameCount     = blendShapeFrameCount[shapeIndex];
                        string blendShapeName = blendShapeNames[shapeIndex];
                        for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex)
                        {
                            PersistentBlendShapeFrame <TID> frame = blendShapeFrames[index];
                            o.AddBlendShapeFrame(blendShapeName, frame.Weight, frame.DeltaVertices, frame.DeltaNormals, frame.DeltaTangents);
                            index++;
                        }
                    }
                }
            }

            return(base.WriteTo(obj));
        }
        public override void ReadFrom(object obj)
        {
            base.ReadFrom(obj);
            if (obj == null)
            {
                return;
            }
            Mesh o = (Mesh)obj;

            if (!m_assetDB.IsStaticResourceID(m_assetDB.ToID(o)))
            {
                boneWeights = o.boneWeights;
                bindposes   = o.bindposes;
                bounds      = o.bounds;
                normals     = o.normals;
                tangents    = o.tangents;
                uv          = o.uv;
                uv2         = o.uv2;
                uv3         = o.uv3;
                uv4         = o.uv4;
                uv5         = o.uv5;
                uv6         = o.uv6;
                uv7         = o.uv7;
                uv8         = o.uv8;
                colors      = o.colors;

                indexFormat  = o.indexFormat;
                subMeshCount = o.subMeshCount;
                if (o.vertices != null)
                {
                    vertices = o.vertices;
                }

                m_tris     = new IntArray[subMeshCount];
                m_topology = new MeshTopology[subMeshCount];
                for (int i = 0; i < subMeshCount; ++i)
                {
                    MeshTopology topology = o.GetTopology(i);
                    m_topology[i] = topology;
                    switch (topology)
                    {
                    case MeshTopology.Points:
                        m_tris[i]       = new IntArray();
                        m_tris[i].Array = o.GetIndices(i);
                        break;

                    case MeshTopology.Lines:
                        m_tris[i]       = new IntArray();
                        m_tris[i].Array = o.GetIndices(i);
                        break;

                    case MeshTopology.Triangles:
                        m_tris[i]       = new IntArray();
                        m_tris[i].Array = o.GetTriangles(i);
                        break;
                    }
                }

                blendShapeCount = o.blendShapeCount;
                if (blendShapeCount > 0)
                {
                    blendShapeNames      = new string[blendShapeCount];
                    blendShapeFrameCount = new int[blendShapeCount];
                    blendShapeFrames     = new List <PersistentBlendShapeFrame <TID> >();
                    int vertexCount = o.vertexCount;
                    for (int shapeIndex = 0; shapeIndex < blendShapeCount; ++shapeIndex)
                    {
                        int frameCount = o.GetBlendShapeFrameCount(shapeIndex);
                        blendShapeFrameCount[shapeIndex] = frameCount;

                        string blendShapeName = o.GetBlendShapeName(shapeIndex);
                        blendShapeNames[shapeIndex] = blendShapeName;

                        for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex)
                        {
                            float weight = o.GetBlendShapeFrameWeight(shapeIndex, frameIndex);

                            Vector3[] deltaVertices = new Vector3[vertexCount];
                            Vector3[] deltaNormals  = new Vector3[vertexCount];
                            Vector3[] deltaTangents = new Vector3[vertexCount];
                            o.GetBlendShapeFrameVertices(shapeIndex, frameIndex, deltaVertices, deltaNormals, deltaTangents);

                            PersistentBlendShapeFrame <TID> frame = new PersistentBlendShapeFrame <TID>(weight, deltaVertices, deltaNormals, deltaTangents);
                            blendShapeFrames.Add(frame);
                        }
                    }
                }
            }
        }