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();
}
