예제 #1
0
            public void Clear()
            {
                points.Clear();
                normals.Clear();
                uv0.Clear();
                uv1.Clear();
                colors.Clear();

                submeshData.Clear();
                submeshIndices.Clear();
            }
예제 #2
0
            public void Capture(Mesh mesh, Cloth cloth, MeshBuffer mbuf, AlembicRecorderSettings settings)
            {
                if (mesh == null || cloth == null)
                {
                    mbuf.Clear();
                    return;
                }

                if (remap.Count != mesh.vertexCount)
                {
                    GenerateRemapIndices(mesh, mbuf);
                }

                // capture cloth points and normals
                vertices.Assign(cloth.vertices);
                if (numRemappedVertices != vertices.Count)
                {
                    Debug.LogWarning("numRemappedVertices != vertices.Count");
                    return;
                }

                if (settings.MeshNormals)
                {
                    normals.Assign(cloth.normals);
                }
                else
                {
                    normals.Clear();
                }

                // apply root bone transform
                if (rootBone != null)
                {
                    var mat = Matrix4x4.TRS(rootBone.localPosition, rootBone.localRotation, Vector3.one);
                    NativeMethods.aeApplyMatrixP(vertices, vertices.Count, ref mat);
                    NativeMethods.aeApplyMatrixV(normals, normals.Count, ref mat);
                }

                // remap vertices and normals
                for (int vi = 0; vi < remap.Count; ++vi)
                {
                    mbuf.points[vi] = vertices[remap[vi]];
                }
                if (normals.Count > 0)
                {
                    mbuf.normals.ResizeDiscard(remap.Count);
                    for (int vi = 0; vi < remap.Count; ++vi)
                    {
                        mbuf.normals[vi] = normals[remap[vi]];
                    }
                }

                // capture other components
                if (settings.MeshUV0)
                {
                    mbuf.uv0.LockList(ls => mesh.GetUVs(0, ls));
                }
                else
                {
                    mbuf.uv0.Clear();
                }

                if (settings.MeshUV1)
                {
                    mbuf.uv1.LockList(ls => mesh.GetUVs(1, ls));
                }
                else
                {
                    mbuf.uv1.Clear();
                }

                if (settings.MeshColors)
                {
                    mbuf.colors.LockList(ls => mesh.GetColors(ls));
                }
                else
                {
                    mbuf.colors.Clear();
                }
            }