コード例 #1
0
ファイル: MeshIntegrator.cs プロジェクト: vrm-c/UniVRM
        public void Push(MeshRenderer renderer)
        {
            var meshFilter = renderer.GetComponent <MeshFilter>();

            if (meshFilter == null)
            {
                Debug.LogWarningFormat("{0} has no mesh filter", renderer.name);
                return;
            }
            var mesh = meshFilter.sharedMesh;

            if (mesh == null)
            {
                Debug.LogWarningFormat("{0} has no mesh", renderer.name);
                return;
            }
            Result.SourceMeshRenderers.Add(renderer);
            Result.MeshMap.Sources.Add(mesh);

            var indexOffset     = Positions.Count;
            var boneIndexOffset = Bones.Count;

            Positions.AddRange(mesh.vertices
                               .Select(x => renderer.transform.TransformPoint(x))
                               );
            Normals.AddRange(mesh.normals
                             .Select(x => renderer.transform.TransformVector(x))
                             );
            UV.AddRange(mesh.uv);
            Tangents.AddRange(mesh.tangents
                              .Select(t =>
            {
                var v = renderer.transform.TransformVector(t.x, t.y, t.z);
                return(new Vector4(v.x, v.y, v.z, t.w));
            })
                              );

            var self = renderer.transform;
            var bone = self.parent;

            if (bone == null)
            {
                Debug.LogWarningFormat("{0} is root gameobject.", self.name);
                return;
            }
            var bindpose = bone.worldToLocalMatrix;

            BoneWeights.AddRange(Enumerable.Range(0, mesh.vertices.Length)
                                 .Select(x => new BoneWeight()
            {
                boneIndex0 = Bones.Count,
                weight0    = 1,
            })
                                 );

            BindPoses.Add(bindpose);
            Bones.Add(bone);

            for (int i = 0; i < mesh.subMeshCount && i < renderer.sharedMaterials.Length; ++i)
            {
                var indices = mesh.GetIndices(i).Select(x => x + indexOffset);
                var mat     = renderer.sharedMaterials[i];
                var sameMaterialSubMeshIndex = SubMeshes.FindIndex(x => ReferenceEquals(x.Material, mat));
                if (sameMaterialSubMeshIndex >= 0)
                {
                    SubMeshes[sameMaterialSubMeshIndex].Indices.AddRange(indices);
                }
                else
                {
                    SubMeshes.Add(new SubMesh
                    {
                        Indices  = indices.ToList(),
                        Material = mat,
                    });
                }
            }
        }
コード例 #2
0
ファイル: MeshIntegrator.cs プロジェクト: vrm-c/UniVRM
        public void Push(SkinnedMeshRenderer renderer)
        {
            var mesh = renderer.sharedMesh;

            if (mesh == null)
            {
                Debug.LogWarningFormat("{0} has no mesh", renderer.name);
                return;
            }
            Result.SourceSkinnedMeshRenderers.Add(renderer);
            Result.MeshMap.Sources.Add(mesh);

            var indexOffset     = Positions.Count;
            var boneIndexOffset = Bones.Count;

            Positions.AddRange(mesh.vertices);
            Normals.AddRange(mesh.normals);
            UV.AddRange(mesh.uv);
            Tangents.AddRange(mesh.tangents);

            if (mesh.vertexCount == mesh.boneWeights.Length)
            {
                BoneWeights.AddRange(mesh.boneWeights.Select(x => AddBoneIndexOffset(x, boneIndexOffset)).ToArray());
                BindPoses.AddRange(mesh.bindposes);
                Bones.AddRange(renderer.bones);
            }
            else
            {
                // Bone Count 0 уБо SkinnedMeshRenderer
                var rigidBoneWeight = new BoneWeight
                {
                    boneIndex0 = boneIndexOffset,
                    weight0    = 1f,
                };
                BoneWeights.AddRange(Enumerable.Range(0, mesh.vertexCount).Select(x => rigidBoneWeight).ToArray());
                BindPoses.Add(renderer.transform.localToWorldMatrix);
                Bones.Add(renderer.transform);
            }

            for (int i = 0; i < mesh.subMeshCount && i < renderer.sharedMaterials.Length; ++i)
            {
                var indices = mesh.GetIndices(i).Select(x => x + indexOffset);
                var mat     = renderer.sharedMaterials[i];
                var sameMaterialSubMeshIndex = SubMeshes.FindIndex(x => ReferenceEquals(x.Material, mat));
                if (sameMaterialSubMeshIndex >= 0)
                {
                    SubMeshes[sameMaterialSubMeshIndex].Indices.AddRange(indices);
                }
                else
                {
                    SubMeshes.Add(new SubMesh
                    {
                        Indices  = indices.ToList(),
                        Material = mat,
                    });
                }
            }

            for (int i = 0; i < mesh.blendShapeCount; ++i)
            {
                var positions = (Vector3[])mesh.vertices.Clone();
                var normals   = (Vector3[])mesh.normals.Clone();
                var tangents  = mesh.tangents.Select(x => (Vector3)x).ToArray();

                mesh.GetBlendShapeFrameVertices(i, 0, positions, normals, tangents);
                BlendShapes.Add(new BlendShape
                {
                    VertexOffset = indexOffset,
                    FrameWeight  = mesh.GetBlendShapeFrameWeight(i, 0),
                    Name         = mesh.GetBlendShapeName(i),
                    Positions    = positions,
                    Normals      = normals,
                    Tangents     = tangents,
                });
            }
        }
コード例 #3
0
        public void Parse(DataReader reader)
        {
            Name = reader.ReadString(reader.ReadInt32());
            if (reader.BaseStream.Position % 4 != 0)
            {
                reader.BaseStream.Position += 4 - (reader.BaseStream.Position % 4);
            }

            int subMeshCount = reader.ReadInt32();

            for (int i = 0; i < subMeshCount; i++)
            {
                UnitySubMesh sm = new UnitySubMesh();
                sm.Parse(reader);
                SubMesh.Add(sm);
            }

            int blendCount = reader.ReadInt32();

            for (int i = 0; i < blendCount; i++)
            {
                var sm = new UnityBlendShapeVertex();
                sm.Parse(reader);
                BlendShapeVertices.Add(sm);
            }

            int blendShapeCount = reader.ReadInt32();

            for (int i = 0; i < blendShapeCount; i++)
            {
                var sm = new UnityBlendShape();
                sm.Parse(reader);
                BlendShapes.Add(sm);
            }
            int blendShapeChannelCount = reader.ReadInt32();

            for (int i = 0; i < blendShapeChannelCount; i++)
            {
                var sm = new UnityBlendShapeChannel();
                sm.Parse(reader);
                BlendShapeChannels.Add(sm);
            }
            int fullWeightCount = reader.ReadInt32();

            for (int i = 0; i < fullWeightCount; i++)
            {
                var sm = reader.ReadSingle();
                FullWeights.Add(sm);
            }

            int bindPoseCount = reader.ReadInt32();

            for (int i = 0; i < bindPoseCount; i++)
            {
                var sm = new Matrix4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(),
                                     reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(),
                                     reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(),
                                     reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
                BindPoses.Add(sm);
            }

            int boneNameHashCount = reader.ReadInt32();

            for (int i = 0; i < boneNameHashCount; i++)
            {
                BoneNameHashes.Add(reader.ReadInt32());
            }

            RootBoneNameHash = reader.ReadInt32();
            MeshCompression  = reader.ReadByte();
            IsReadable       = reader.ReadByte() == 1;
            KeepVertices     = reader.ReadByte() == 1;
            KeepIndices      = reader.ReadByte() == 1;

            int IndexBufferCount = reader.ReadInt32();

            for (int i = 0; i < IndexBufferCount / 2; i++)
            {
                IndexBuffer.Add(reader.ReadUInt16());
            }

            int BoneICount = reader.ReadInt32();

            for (int i = 0; i < BoneICount; i++)
            {
                var bi = new UnityBoneInfluence();
                bi.Parse(reader);
                BoneInfluences.Add(bi);
            }

            VertexData.Parse(reader);

            reader.PrintPosition();

            CompVertices.Parse(reader);

            reader.PrintPosition();
        }