public void Read(AssetReader reader) { Vertices.Read(reader); UV.Read(reader); if (IsReadBindPoses(reader.Version)) { BindPoses.Read(reader); } Normals.Read(reader); Tangents.Read(reader); Weight.Read(reader); NormalSigns.Read(reader); TangentSigns.Read(reader); if (IsReadFloatColors(reader.Version)) { FloatColors.Read(reader); } BoneIndices.Read(reader); Triangles.Read(reader); if (IsReadColors(reader.Version)) { Colors.Read(reader); } if (IsReadUVInfo(reader.Version)) { UVInfo = reader.ReadUInt32(); } }
public YAMLNode ExportYAML(IExportContainer container) { YAMLMappingNode node = new YAMLMappingNode(); node.Add(VerticesName, Vertices.ExportYAML(container)); node.Add(UVName, UV.ExportYAML(container)); if (HasBindPoses(container.ExportVersion)) { node.Add(BindPosesName, BindPoses.ExportYAML(container)); } node.Add(NormalsName, Normals.ExportYAML(container)); node.Add(TangentsName, Tangents.ExportYAML(container)); node.Add(WeightsName, Weights.ExportYAML(container)); node.Add(NormalSignsName, NormalSigns.ExportYAML(container)); node.Add(TangentSignsName, TangentSigns.ExportYAML(container)); if (HasFloatColors(container.ExportVersion)) { node.Add(FloatColorsName, FloatColors.ExportYAML(container)); } node.Add(BoneIndicesName, BoneIndices.ExportYAML(container)); node.Add(TrianglesName, Triangles.ExportYAML(container)); if (HasColors(container.ExportVersion)) { node.Add(ColorsName, Colors.ExportYAML(container)); } if (HasUVInfo(container.ExportVersion)) { node.Add(UVInfoName, UVInfo); } return(node); }
public void Write(AssetWriter writer) { Vertices.Write(writer); UV.Write(writer); if (HasBindPoses(writer.Version)) { BindPoses.Write(writer); } Normals.Write(writer); Tangents.Write(writer); Weights.Write(writer); NormalSigns.Write(writer); TangentSigns.Write(writer); if (HasFloatColors(writer.Version)) { FloatColors.Write(writer); } BoneIndices.Write(writer); Triangles.Write(writer); if (HasColors(writer.Version)) { Colors.Write(writer); } if (HasUVInfo(writer.Version)) { writer.Write(UVInfo); } }
private void LoadPlayerSkeleton(GenderType gender, WeaponType weapType, RigType rig, int weapon, int body, int arms, int foot, int hair, int face, int back, int cap, int shield) { // First destroy any children of player int childs = player.transform.childCount; for (int i = childs - 1; i > 0; i--) { Utils.Destroy(player.transform.GetChild(i).gameObject); } Utils.Destroy(skeleton); if (rig == RigType.FOOT) { skeleton = rm.loadSkeleton(gender, weapType); } else { skeleton = rm.loadSkeleton(gender, rig); } bindPoses = rm.loadBindPoses(skeleton, gender, weapType); skeleton.transform.parent = player.transform; skeleton.transform.localPosition = new Vector3(0, 0, 0); skeleton.transform.localRotation = Quaternion.Euler(new Vector3(0, 0, 0)); // If player has already been initialized, make sure it knows that the skeleton has changed in order to restart its state machine with new animations PlayerController controller = player.GetComponent <PlayerController> (); if (controller != null) { controller.OnSkeletonChange(); } //load all objects playerBounds = new Bounds(player.transform.position, Vector3.zero); playerBounds.Encapsulate(LoadObject(BodyPartType.BODY, body)); playerBounds.Encapsulate(LoadObject(BodyPartType.ARMS, arms)); playerBounds.Encapsulate(LoadObject(BodyPartType.FOOT, foot)); playerBounds.Encapsulate(LoadObject(BodyPartType.FACE, face)); LoadObject(BodyPartType.CAP, cap); String hairOffsetStr = rm.stb_cap_list.Cells[cap][34]; int hairOffset = (hairOffsetStr == "") ? 0 : int.Parse(hairOffsetStr); playerBounds.Encapsulate(LoadObject(BodyPartType.HAIR, hair - hair % 5 + hairOffset)); LoadObject(BodyPartType.SUBWEAPON, shield); LoadObject(BodyPartType.WEAPON, weapon); LoadObject(BodyPartType.BACK, back); //player.SetActive(true); }
public void Read(EndianStream stream) { if (IsReadMeshData) { Vertices.Read(stream); UV.Read(stream); if (IsReadBindPoses) { BindPoses.Read(stream); } Normals.Read(stream); Tangents.Read(stream); Weight.Read(stream); NormalSigns.Read(stream); TangentSigns.Read(stream); if (IsReadFloatColors) { FloatColors.Read(stream); } BoneIndices.Read(stream); Triangles.Read(stream); } if (IsReadPlainColors) { LocalAABB.Read(stream); m_plainColors = stream.ReadArray <Color>(); #warning TODO: todo what? m_collisionTriangles = stream.ReadByteArray(); CollisionVertexCount = stream.ReadInt32(); } else { if (IsReadCompressedColors) { Colors.Read(stream); } else { UVInfo = stream.ReadUInt32(); } } }
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container) { YAMLMappingNode node = base.ExportYAMLRoot(container); node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion)); node.Add(SubMeshesName, GetSubMeshes(container.Version).ExportYAML(container)); node.Add(ShapesName, Shapes.ExportYAML(container)); node.Add(BindPoseName, IsReadBindPoses(container.Version) ? BindPoses.ExportYAML(container) : YAMLSequenceNode.Empty); #warning TODO? node.Add(BoneNamesName, YAMLSequenceNode.Empty); node.Add(BoneNameHashesName, IsReadBoneNameHashes(container.Version) ? BoneNameHashes.ExportYAML(false) : YAMLSequenceNode.Empty); #warning TODO? node.Add(RootBoneNameName, YAMLScalarNode.Empty); node.Add(RootBoneNameHashName, RootBoneNameHash); node.Add(MeshCompressionName, (byte)MeshCompression); node.Add(IsReadableName, IsReadable); node.Add(KeepVerticesName, KeepVertices); node.Add(KeepIndicesName, KeepIndices); node.Add(IndexBufferName, GetIndexBuffer(container.Version, container.Platform).ExportYAML()); node.Add(SkinName, GetSkin(container.Version).ExportYAML(container)); node.Add(VertexDataName, GetVertexData(container.Version).ExportYAML(container)); node.Add(CompressedMeshName, CompressedMesh.ExportYAML(container)); node.Add(LocalAABBName, LocalAABB.ExportYAML(container)); node.Add(MeshUsageFlagsName, MeshUsageFlags); if (IsReadCollision(container.Version)) { node.Add(BakedConvexCollisionMeshName, CollisionData.BakedConvexCollisionMesh.ExportYAML()); node.Add(BakedTriangleCollisionMeshName, CollisionData.BakedTriangleCollisionMesh.ExportYAML()); } else { node.Add(BakedConvexCollisionMeshName, ArrayExtensions.EmptyBytes.ExportYAML()); node.Add(BakedTriangleCollisionMeshName, ArrayExtensions.EmptyBytes.ExportYAML()); } #warning ??? node.Add(MeshOptimizedName, 0); if (IsReadStreamData(container.ExportVersion)) { node.Add(StreamDataName, StreamData.ExportYAML(container)); } return(node); }
protected override YAMLMappingNode ExportYAMLRoot() { #warning TODO: provide for null values YAMLMappingNode node = base.ExportYAMLRoot(); node.AddSerializedVersion(SerializedVersion); node.Add("m_SubMeshes", SubMeshes.ExportYAML()); node.Add("m_Shapes", Shapes.ExportYAML()); node.Add("m_BindPose", BindPoses.ExportYAML()); #warning ??? node.Add("m_BoneNames", YAMLSequenceNode.Empty); node.Add("m_BoneNameHashes", BoneNameHashes.ExportYAML(false)); #warning ??? node.Add("m_RootBoneName", YAMLScalarNode.Empty); node.Add("m_RootBoneNameHash", RootBoneNameHash); node.Add("m_MeshCompression", MeshCompression); node.Add("m_IsReadable", IsReadable); node.Add("m_KeepVertices", KeepVertices); node.Add("m_KeepIndices", KeepIndices); node.Add("m_IndexBuffer", IndexBuffer.ExportYAML()); node.Add("m_Skin", Skin.ExportYAML()); node.Add("m_VertexData", VertexData.ExportYAML()); node.Add("m_CompressedMesh", CompressedMesh.ExportYAML()); node.Add("m_LocalAABB", LocalAABB.ExportYAML()); node.Add("m_MeshUsageFlags", MeshUsageFlags); if (IsReadCollision) { node.Add("m_BakedConvexCollisionMesh", CollisionData.BakedConvexCollisionMesh.ExportYAML()); node.Add("m_BakedTriangleCollisionMesh", CollisionData.BakedTriangleCollisionMesh.ExportYAML()); } else { node.Add("m_BakedConvexCollisionMesh", ArrayExtensions.EmptyBytes.ExportYAML()); node.Add("m_BakedTriangleCollisionMesh", ArrayExtensions.EmptyBytes.ExportYAML()); } #warning ??? node.Add("m_MeshOptimized", 0); return(node); }
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container) { #warning TODO: values acording to read version (current 2017.3.0f3) YAMLMappingNode node = base.ExportYAMLRoot(container); node.AddSerializedVersion(GetSerializedVersion(container.Version)); node.Add("m_SubMeshes", GetSubMeshes(container.Version).ExportYAML(container)); node.Add("m_Shapes", Shapes.ExportYAML(container)); node.Add("m_BindPose", IsReadBindPoses(container.Version) ? BindPoses.ExportYAML(container) : YAMLSequenceNode.Empty); #warning TODO? node.Add("m_BoneNames", YAMLSequenceNode.Empty); node.Add("m_BoneNameHashes", IsReadBoneNameHashes(container.Version) ? BoneNameHashes.ExportYAML(false) : YAMLSequenceNode.Empty); #warning TODO? node.Add("m_RootBoneName", YAMLScalarNode.Empty); node.Add("m_RootBoneNameHash", RootBoneNameHash); node.Add("m_MeshCompression", MeshCompression); node.Add("m_IsReadable", IsReadable); node.Add("m_KeepVertices", KeepVertices); node.Add("m_KeepIndices", KeepIndices); node.Add("m_IndexBuffer", GetIndexBuffer(container.Version).ExportYAML()); node.Add("m_Skin", IsReadSkin(container.Version) ? Skin.ExportYAML(container) : YAMLSequenceNode.Empty); node.Add("m_VertexData", GetVertexData(container.Version).ExportYAML(container)); node.Add("m_CompressedMesh", CompressedMesh.ExportYAML(container)); node.Add("m_LocalAABB", LocalAABB.ExportYAML(container)); node.Add("m_MeshUsageFlags", MeshUsageFlags); if (IsReadCollision(container.Version)) { node.Add("m_BakedConvexCollisionMesh", CollisionData.BakedConvexCollisionMesh.ExportYAML()); node.Add("m_BakedTriangleCollisionMesh", CollisionData.BakedTriangleCollisionMesh.ExportYAML()); } else { node.Add("m_BakedConvexCollisionMesh", ArrayExtensions.EmptyBytes.ExportYAML()); node.Add("m_BakedTriangleCollisionMesh", ArrayExtensions.EmptyBytes.ExportYAML()); } #warning ??? node.Add("m_MeshOptimized", 0); return(node); }
public void Push(SkinnedMeshRenderer renderer) { var mesh = renderer.sharedMesh; if (mesh == null) { Debug.LogWarningFormat("{0} has no mesh", renderer.name); return; } Renderers.Add(renderer); 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()); } else { BoneWeights.AddRange(Enumerable.Range(0, mesh.vertexCount).Select(x => new BoneWeight()).ToArray()); } BindPoses.AddRange(mesh.bindposes); Bones.AddRange(renderer.bones); for (int i = 0; i < mesh.subMeshCount; ++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, }); } }
public MeshIntegrationResult Integrate(MeshEnumerateOption onlyBlendShapeRenderers) { var mesh = new Mesh(); if (Positions.Count > ushort.MaxValue) { Debug.LogFormat("exceed 65535 vertices: {0}", Positions.Count); mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32; } mesh.vertices = Positions.ToArray(); mesh.normals = Normals.ToArray(); mesh.uv = UV.ToArray(); mesh.tangents = Tangents.ToArray(); mesh.boneWeights = BoneWeights.ToArray(); mesh.subMeshCount = SubMeshes.Count; for (var i = 0; i < SubMeshes.Count; ++i) { mesh.SetIndices(SubMeshes[i].Indices.ToArray(), MeshTopology.Triangles, i); } mesh.bindposes = BindPoses.ToArray(); // blendshape switch (onlyBlendShapeRenderers) { case MeshEnumerateOption.OnlyWithBlendShape: { AddBlendShapesToMesh(mesh); mesh.name = INTEGRATED_MESH_WITH_BLENDSHAPE_NAME; break; } case MeshEnumerateOption.All: { AddBlendShapesToMesh(mesh); mesh.name = INTEGRATED_MESH_ALL_NAME; break; } case MeshEnumerateOption.OnlyWithoutBlendShape: { mesh.name = INTEGRATED_MESH_WITHOUT_BLENDSHAPE_NAME; break; } } // meshName var meshNode = new GameObject(); switch (onlyBlendShapeRenderers) { case MeshEnumerateOption.OnlyWithBlendShape: { meshNode.name = INTEGRATED_MESH_WITH_BLENDSHAPE_NAME; break; } case MeshEnumerateOption.OnlyWithoutBlendShape: { meshNode.name = INTEGRATED_MESH_WITHOUT_BLENDSHAPE_NAME; break; } case MeshEnumerateOption.All: { meshNode.name = INTEGRATED_MESH_ALL_NAME; break; } } var integrated = meshNode.AddComponent <SkinnedMeshRenderer>(); integrated.sharedMesh = mesh; integrated.sharedMaterials = SubMeshes.Select(x => x.Material).ToArray(); integrated.bones = Bones.ToArray(); Result.IntegratedRenderer = integrated; Result.MeshMap.Integrated = mesh; return(Result); }
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, }); } } }
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(); }