public static CompressedMesh Convert(IExportContainer container, ref CompressedMesh origin)
{
CompressedMesh instance = new CompressedMesh();
instance.Vertices = origin.Vertices.Convert(container);
instance.UV = origin.UV.Convert(container);
if (CompressedMesh.HasBindPoses(container.ExportVersion))
{
instance.BindPoses = origin.BindPoses.Convert(container);
}
instance.Normals = origin.Normals.Convert(container);
instance.Tangents = origin.Tangents.Convert(container);
instance.Weights = origin.Weights.Convert(container);
instance.NormalSigns = origin.NormalSigns.Convert(container);
instance.TangentSigns = origin.TangentSigns.Convert(container);
if (CompressedMesh.HasFloatColors(container.ExportVersion))
{
instance.FloatColors = GetFloatColors(container, ref origin);
}
instance.BoneIndices = origin.BoneIndices.Convert(container);
instance.Triangles = origin.Triangles.Convert(container);
if (CompressedMesh.HasColors(container.ExportVersion))
{
instance.Colors = GetColors(container, ref origin);
}
if (CompressedMesh.HasUVInfo(container.ExportVersion))
{
instance.UVInfo = GetUVInfo(container, ref origin);
}
return(instance);
}
private static uint GetUVInfo(IExportContainer container, ref CompressedMesh origin)
{
if (CompressedMesh.HasUVInfo(container.Version))
{
return(origin.UVInfo);
}
return(0);
}
private static PackedIntVector GetColors(IExportContainer container, ref CompressedMesh origin)
{
if (CompressedMesh.HasColors(container.Version))
{
return(origin.Colors.Convert(container));
}
return(new PackedIntVector(true));
}
private static PackedFloatVector GetFloatColors(IExportContainer container, ref CompressedMesh origin)
{
if (CompressedMesh.HasFloatColors(container.Version))
{
return(origin.FloatColors.Convert(container));
}
else
{
#warning TODO: convert Colors to FloatColors
if (origin.Colors.IsSet)
{
Logger.Log(LogType.Warning, LogCategory.Export, "Color conversion isn't implemented");
}
return(new PackedFloatVector(true));
}
}
public Mesh(AssetInfo assetInfo) :
base(assetInfo)
{
CompressedMesh = new CompressedMesh(AssetsFile);
if (IsReadBlendShapes)
{
Shapes = new BlendShapeData(AssetsFile);
}
if (IsReadLocalAABB)
{
LocalAABB = new AABB();
}
if (IsReadCollision)
{
CollisionData = new CollisionMeshData();
}
}
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, GetShapes(container.Version).ExportYAML(container));
node.Add(BindPoseName, GetBindPoses(container.Version).ExportYAML(container));
node.Add(BoneNameHashesName, GetBoneNameHashes(container.Version).ExportYAML(true));
node.Add(RootBoneNameHashName, RootBoneNameHash);
if (IsReadBonesAABB(container.ExportVersion))
{
node.Add(BonesAABBName, GetBonesAABB(container.Version).ExportYAML(container));
node.Add(VariableBoneCountWeightsName, GetVariableBoneCountWeights(container.Version).ExportYAML(container));
}
node.Add(MeshCompressionName, (byte)MeshCompression);
node.Add(IsReadableName, IsReadable);
node.Add(KeepVerticesName, KeepVertices);
node.Add(KeepIndicesName, KeepIndices);
node.Add(IndexFormatName, (int)IndexFormat);
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);
node.Add(BakedConvexCollisionMeshName, GetBakedConvexCollisionMesh(container.Version).ExportYAML());
node.Add(BakedTriangleCollisionMeshName, GetBakedTriangleCollisionMesh(container.Version).ExportYAML());
if (IsReadMeshOptimizationFlags(container.ExportVersion, container.ExportFlags))
{
node.Add(MeshOptimizationFlagsName, (int)GetMeshOptimizationFlags(container.Version, container.Flags));
}
else
{
node.Add(MeshOptimizedName, GetMeshOptimized(container.Version, container.Flags));
}
if (IsReadStreamData(container.ExportVersion))
{
StreamingInfo streamData = new StreamingInfo(true);
node.Add(StreamDataName, streamData.ExportYAML(container));
}
return(node);
}
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 override void Read(AssetStream stream)
{
base.Read(stream);
if (IsReadLODData(stream.Version))
{
m_LODData = stream.ReadArray <LOD>();
}
if (IsReadIndicesUsage(stream.Version))
{
Use16bitIndices = stream.ReadInt32() > 0;
}
if (IsReadIndexBuffer(stream.Version))
{
if (IsReadIndexBufferFirst(stream.Version))
{
m_indexBuffer = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
}
if (IsReadSubMeshes(stream.Version))
{
m_subMeshes = stream.ReadArray <SubMesh>();
}
if (IsReadBlendShapes(stream.Version))
{
Shapes.Read(stream);
}
if (IsReadBindPosesFirst(stream.Version))
{
m_bindPoses = stream.ReadArray <Matrix4x4f>();
}
if (IsReadBoneNameHashes(stream.Version))
{
m_boneNameHashes = stream.ReadUInt32Array();
RootBoneNameHash = stream.ReadUInt32();
}
if (IsReadMeshCompression(stream.Version))
{
MeshCompression = stream.ReadByte();
}
if (IsReadStreamCompression(stream.Version))
{
StreamCompression = stream.ReadByte();
}
if (IsReadIsReadable(stream.Version))
{
IsReadable = stream.ReadBoolean();
KeepVertices = stream.ReadBoolean();
KeepIndices = stream.ReadBoolean();
}
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadIndexFormat(stream.Version))
{
if (IsReadIndexFormatCondition(stream.Version))
{
if (MeshCompression == 0)
{
IndexFormat = stream.ReadInt32();
}
}
else
{
IndexFormat = stream.ReadInt32();
}
}
if (IsReadIndexBuffer(stream.Version))
{
if (!IsReadIndexBufferFirst(stream.Version))
{
m_indexBuffer = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
}
if (IsReadVertices(stream.Version))
{
if (IsReadVertexData(stream.Version))
{
if (MeshCompression != 0)
{
m_vertices = stream.ReadArray <Vector3f>();
}
}
else
{
m_vertices = stream.ReadArray <Vector3f>();
}
}
if (IsReadSkin(stream.Version))
{
m_skin = stream.ReadArray <BoneWeights4>();
}
if (IsReadBindPoses(stream.Version))
{
if (!IsReadBindPosesFirst(stream.Version))
{
m_bindPoses = stream.ReadArray <Matrix4x4f>();
}
}
if (IsReadVertexData(stream.Version))
{
if (IsReadOnlyVertexData(stream.Version))
{
VertexData.Read(stream);
}
else
{
if (MeshCompression == 0)
{
VertexData.Read(stream);
}
else
{
m_UV = stream.ReadArray <Vector2f>();
m_UV1 = stream.ReadArray <Vector2f>();
m_tangents = stream.ReadArray <Vector4f>();
m_normals = stream.ReadArray <Vector3f>();
m_colors = stream.ReadArray <ColorRGBA32>();
}
}
}
else
{
m_UV = stream.ReadArray <Vector2f>();
if (IsReadUV1(stream.Version))
{
m_UV1 = stream.ReadArray <Vector2f>();
}
if (IsReadTangentSpace(stream.Version))
{
m_tangentSpace = stream.ReadArray <Tangent>();
}
else
{
m_tangents = stream.ReadArray <Vector4f>();
m_normals = stream.ReadArray <Vector3f>();
}
}
if (IsReadAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadCompressedMesh(stream.Version))
{
CompressedMesh.Read(stream);
}
LocalAABB.Read(stream);
if (IsReadColors(stream.Version))
{
if (!IsReadVertexData(stream.Version))
{
m_colors = stream.ReadArray <ColorRGBA32>();
}
}
if (IsReadCollisionTriangles(stream.Version))
{
m_collisionTriangles = stream.ReadUInt32Array();
CollisionVertexCount = stream.ReadInt32();
}
if (IsReadMeshUsageFlags(stream.Version))
{
MeshUsageFlags = stream.ReadInt32();
}
if (IsReadCollision(stream.Version))
{
CollisionData.Read(stream);
}
if (IsReadMeshMetrics(stream.Version))
{
m_meshMetrics = new float[2];
m_meshMetrics[0] = stream.ReadSingle();
m_meshMetrics[1] = stream.ReadSingle();
}
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
if (HasLODData(container.ExportVersion))
{
node.Add(LODDataName, LODData.ExportYAML(container));
}
else
{
if (HasUse16bitIndices(container.ExportVersion))
{
node.Add(Use16BitIndicesName, Use16BitIndices);
}
if (IsIndexBufferFirst(container.ExportVersion))
{
node.Add(IndexBufferName, IndexBuffer.ExportYAML());
}
node.Add(SubMeshesName, SubMeshes.ExportYAML(container));
}
if (HasBlendShapes(container.ExportVersion))
{
if (HasBlendChannels(container.ExportVersion))
{
node.Add(ShapesName, Shapes.ExportYAML(container));
}
else
{
node.Add(ShapesName, BlendShapes.ExportYAML(container));
node.Add(ShapeVerticesName, ShapeVertices.ExportYAML(container));
}
}
if (HasBindPose(container.ExportVersion))
{
if (IsBindPoseFirst(container.ExportVersion))
{
node.Add(BindPoseName, BindPose.ExportYAML(container));
}
}
if (HasBoneNameHashes(container.ExportVersion))
{
node.Add(BoneNameHashesName, BoneNameHashes.ExportYAML(true));
node.Add(RootBoneNameHashName, RootBoneNameHash);
}
if (HasBonesAABB(container.ExportVersion))
{
node.Add(BonesAABBName, BonesAABB.ExportYAML(container));
node.Add(VariableBoneCountWeightsName, VariableBoneCountWeights.ExportYAML(container));
}
if (HasMeshCompression(container.ExportVersion))
{
node.Add(MeshCompressionName, (byte)MeshCompression);
}
if (HasStreamCompression(container.ExportVersion))
{
node.Add(StreamCompressionName, StreamCompression);
}
if (HasIsReadable(container.ExportVersion))
{
node.Add(IsReadableName, IsReadable);
node.Add(KeepVerticesName, KeepVertices);
node.Add(KeepIndicesName, KeepIndices);
}
if (HasIndexFormat(container.ExportVersion))
{
node.Add(IndexFormatName, (int)IndexFormat);
}
if (!HasLODData(container.ExportVersion))
{
if (!IsIndexBufferFirst(container.ExportVersion))
{
node.Add(IndexBufferName, IndexBuffer.ExportYAML());
}
}
if (HasVertexData(container.ExportVersion))
{
if (!IsOnlyVertexData(container.ExportVersion))
{
if (MeshCompression != MeshCompression.Off)
{
node.Add(VerticesName, Vertices.ExportYAML(container));
}
}
}
else
{
node.Add(VerticesName, Vertices.ExportYAML(container));
}
if (HasSkin(container.ExportVersion))
{
node.Add(SkinName, Skin.ExportYAML(container));
}
if (HasBindPose(container.ExportVersion))
{
if (!IsBindPoseFirst(container.ExportVersion))
{
node.Add(BindPoseName, BindPose.ExportYAML(container));
}
}
if (HasVertexData(container.ExportVersion))
{
if (IsOnlyVertexData(container.ExportVersion))
{
node.Add(VertexDataName, VertexData.ExportYAML(container));
}
else
{
if (MeshCompression == MeshCompression.Off)
{
node.Add(VertexDataName, VertexData.ExportYAML(container));
}
else
{
node.Add(UVName, UV.ExportYAML(container));
node.Add(UV1Name, UV1.ExportYAML(container));
node.Add(TangentsName, Tangents.ExportYAML(container));
node.Add(NormalsName, Normals.ExportYAML(container));
node.Add(ColorsName, Colors.ExportYAML(container));
}
}
}
else
{
node.Add(UVName, UV.ExportYAML(container));
if (HasUV1(container.ExportVersion))
{
node.Add(UV1Name, UV1.ExportYAML(container));
}
if (HasTangentSpace(container.ExportVersion))
{
node.Add(TangentSpaceName, Tangents.ExportYAML(container));
}
else
{
node.Add(TangentsName, Tangents.ExportYAML(container));
node.Add(NormalsName, Normals.ExportYAML(container));
}
}
if (HasCompressedMesh(container.ExportVersion))
{
node.Add(CompressedMeshName, CompressedMesh.ExportYAML(container));
}
node.Add(LocalAABBName, LocalAABB.ExportYAML(container));
if (!HasVertexData(container.ExportVersion))
{
node.Add(ColorsName, Colors.ExportYAML(container));
}
if (HasCollisionTriangles(container.ExportVersion))
{
node.Add(CollisionTrianglesName, CollisionTriangles.ExportYAML(true));
node.Add(CollisionVertexCountName, CollisionVertexCount);
}
if (HasMeshUsageFlags(container.ExportVersion))
{
node.Add(MeshUsageFlagsName, MeshUsageFlags);
}
if (HasCollision(container.ExportVersion))
{
node.Add(BakedConvexCollisionMeshName, CollisionData.BakedConvexCollisionMesh.ExportYAML());
node.Add(BakedTriangleCollisionMeshName, CollisionData.BakedTriangleCollisionMesh.ExportYAML());
}
if (HasMeshMetrics(container.ExportVersion))
{
node.Add(MeshMetricsName + "[0]", MeshMetrics[0]);
node.Add(MeshMetricsName + "[1]", MeshMetrics[1]);
}
if (HasMeshOptimization(container.ExportVersion, container.ExportFlags))
{
if (IsMeshOptimizationFlags(container.ExportVersion))
{
node.Add(MeshOptimizationFlagsName, (int)MeshOptimizationFlags);
}
else
{
node.Add(MeshOptimizedName, MeshOptimized);
}
}
if (HasStreamData(container.ExportVersion))
{
StreamingInfo streamData = new StreamingInfo(true);
node.Add(StreamDataName, streamData.ExportYAML(container));
}
return(node);
}
public override void Write(AssetWriter writer)
{
base.Write(writer);
if (HasLODData(writer.Version))
{
LODData.Write(writer);
}
else
{
if (HasUse16bitIndices(writer.Version))
{
writer.Write(Use16BitIndices);
}
if (IsIndexBufferFirst(writer.Version))
{
IndexBuffer.Write(writer);
writer.AlignStream(AlignType.Align4);
}
SubMeshes.Write(writer);
}
if (HasBlendShapes(writer.Version))
{
if (HasBlendChannels(writer.Version))
{
Shapes.Write(writer);
}
else
{
BlendShapes.Write(writer);
writer.AlignStream(AlignType.Align4);
ShapeVertices.Write(writer);
}
}
if (HasBindPose(writer.Version))
{
if (IsBindPoseFirst(writer.Version))
{
BindPose.Write(writer);
}
}
if (HasBoneNameHashes(writer.Version))
{
BoneNameHashes.Write(writer);
writer.Write(RootBoneNameHash);
}
if (HasBonesAABB(writer.Version))
{
BonesAABB.Write(writer);
VariableBoneCountWeights.Write(writer);
}
if (HasMeshCompression(writer.Version))
{
writer.Write((byte)MeshCompression);
}
if (HasStreamCompression(writer.Version))
{
writer.Write(StreamCompression);
}
if (HasIsReadable(writer.Version))
{
writer.Write(IsReadable);
writer.Write(KeepVertices);
writer.Write(KeepIndices);
}
if (IsAlignFlags(writer.Version))
{
writer.AlignStream(AlignType.Align4);
}
if (HasIndexFormat(writer.Version))
{
if (IsIndexFormatCondition(writer.Version))
{
if (MeshCompression == MeshCompression.Off)
{
writer.Write((int)IndexFormat);
}
}
else
{
writer.Write((int)IndexFormat);
}
}
if (!HasLODData(writer.Version))
{
if (!IsIndexBufferFirst(writer.Version))
{
IndexBuffer.Write(writer);
writer.AlignStream(AlignType.Align4);
}
}
if (HasVertexData(writer.Version))
{
if (!IsOnlyVertexData(writer.Version))
{
if (MeshCompression != MeshCompression.Off)
{
Vertices.Write(writer);
}
}
}
else
{
Vertices.Write(writer);
}
if (HasSkin(writer.Version))
{
Skin.Write(writer);
}
if (HasBindPose(writer.Version))
{
if (!IsBindPoseFirst(writer.Version))
{
BindPose.Write(writer);
}
}
if (HasVertexData(writer.Version))
{
if (IsOnlyVertexData(writer.Version))
{
VertexData.Write(writer);
}
else
{
if (MeshCompression == MeshCompression.Off)
{
VertexData.Write(writer);
}
else
{
UV.Write(writer);
UV1.Write(writer);
Tangents.Write(writer);
Normals.Write(writer);
Colors.Write(writer);
}
}
}
else
{
UV.Write(writer);
if (HasUV1(writer.Version))
{
UV1.Write(writer);
}
if (HasTangentSpace(writer.Version))
{
TangentSpace.Write(writer);
}
else
{
Tangents.Write(writer);
Normals.Write(writer);
}
}
if (IsAlignVertex(writer.Version))
{
writer.AlignStream(AlignType.Align4);
}
if (HasCompressedMesh(writer.Version))
{
CompressedMesh.Write(writer);
}
LocalAABB.Write(writer);
if (!HasVertexData(writer.Version))
{
Colors.Write(writer);
}
if (HasCollisionTriangles(writer.Version))
{
CollisionTriangles.Write(writer);
writer.Write(CollisionVertexCount);
}
if (HasMeshUsageFlags(writer.Version))
{
writer.Write(MeshUsageFlags);
}
if (HasCollision(writer.Version))
{
CollisionData.Write(writer);
}
if (HasMeshMetrics(writer.Version))
{
writer.Write(MeshMetrics[0]);
writer.Write(MeshMetrics[1]);
}
#if UNIVERSAL
if (HasMeshOptimization(writer.Version, writer.Flags))
{
if (IsMeshOptimizationFlags(writer.Version))
{
writer.Write((int)MeshOptimizationFlags);
}
else
{
writer.Write(MeshOptimized);
}
}
#endif
if (HasStreamData(writer.Version))
{
writer.AlignStream(AlignType.Align4);
StreamData.Write(writer);
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (HasLODData(reader.Version))
{
LODData = reader.ReadAssetArray <LOD>();
}
else
{
if (HasUse16bitIndices(reader.Version))
{
Use16BitIndices = reader.ReadUInt32();
}
if (IsIndexBufferFirst(reader.Version))
{
IndexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
SubMeshes = reader.ReadAssetArray <SubMesh>();
}
if (HasBlendShapes(reader.Version))
{
if (HasBlendChannels(reader.Version))
{
Shapes.Read(reader);
}
else
{
BlendShapes = reader.ReadAssetArray <BlendShape>();
reader.AlignStream(AlignType.Align4);
ShapeVertices = reader.ReadAssetArray <BlendShapeVertex>();
}
}
if (HasBindPose(reader.Version))
{
if (IsBindPoseFirst(reader.Version))
{
BindPose = reader.ReadAssetArray <Matrix4x4f>();
}
}
if (HasBoneNameHashes(reader.Version))
{
BoneNameHashes = reader.ReadUInt32Array();
RootBoneNameHash = reader.ReadUInt32();
}
if (HasBonesAABB(reader.Version))
{
BonesAABB = reader.ReadAssetArray <MinMaxAABB>();
VariableBoneCountWeights.Read(reader);
}
if (HasMeshCompression(reader.Version))
{
MeshCompression = (MeshCompression)reader.ReadByte();
}
if (HasStreamCompression(reader.Version))
{
StreamCompression = reader.ReadByte();
}
if (HasIsReadable(reader.Version))
{
IsReadable = reader.ReadBoolean();
KeepVertices = reader.ReadBoolean();
KeepIndices = reader.ReadBoolean();
}
if (IsAlignFlags(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (HasIndexFormat(reader.Version))
{
if (IsIndexFormatCondition(reader.Version))
{
if (MeshCompression == MeshCompression.Off)
{
IndexFormat = (IndexFormat)reader.ReadInt32();
}
}
else
{
IndexFormat = (IndexFormat)reader.ReadInt32();
}
}
if (!HasLODData(reader.Version))
{
if (!IsIndexBufferFirst(reader.Version))
{
IndexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
}
if (HasVertexData(reader.Version))
{
if (!IsOnlyVertexData(reader.Version))
{
if (MeshCompression != MeshCompression.Off)
{
Vertices = reader.ReadAssetArray <Vector3f>();
}
}
}
else
{
Vertices = reader.ReadAssetArray <Vector3f>();
}
if (HasSkin(reader.Version))
{
Skin = reader.ReadAssetArray <BoneWeights4>();
}
if (HasBindPose(reader.Version))
{
if (!IsBindPoseFirst(reader.Version))
{
BindPose = reader.ReadAssetArray <Matrix4x4f>();
}
}
if (HasVertexData(reader.Version))
{
if (IsOnlyVertexData(reader.Version))
{
VertexData.Read(reader);
}
else
{
if (MeshCompression == MeshCompression.Off)
{
VertexData.Read(reader);
}
else
{
UV = reader.ReadAssetArray <Vector2f>();
UV1 = reader.ReadAssetArray <Vector2f>();
Tangents = reader.ReadAssetArray <Vector4f>();
Normals = reader.ReadAssetArray <Vector3f>();
Colors = reader.ReadAssetArray <ColorRGBA32>();
}
}
}
else
{
UV = reader.ReadAssetArray <Vector2f>();
if (HasUV1(reader.Version))
{
UV1 = reader.ReadAssetArray <Vector2f>();
}
if (HasTangentSpace(reader.Version))
{
TangentSpace = reader.ReadAssetArray <Tangent>();
}
else
{
Tangents = reader.ReadAssetArray <Vector4f>();
Normals = reader.ReadAssetArray <Vector3f>();
}
}
if (IsAlignVertex(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (HasCompressedMesh(reader.Version))
{
CompressedMesh.Read(reader);
}
LocalAABB.Read(reader);
if (!HasVertexData(reader.Version))
{
Colors = reader.ReadAssetArray <ColorRGBA32>();
}
if (HasCollisionTriangles(reader.Version))
{
CollisionTriangles = reader.ReadUInt32Array();
CollisionVertexCount = reader.ReadInt32();
}
if (HasMeshUsageFlags(reader.Version))
{
MeshUsageFlags = reader.ReadInt32();
}
if (HasCollision(reader.Version))
{
CollisionData.Read(reader);
}
if (HasMeshMetrics(reader.Version))
{
MeshMetrics = new float[2];
MeshMetrics[0] = reader.ReadSingle();
MeshMetrics[1] = reader.ReadSingle();
}
#if UNIVERSAL
if (HasMeshOptimization(reader.Version, reader.Flags))
{
if (IsMeshOptimizationFlags(reader.Version))
{
MeshOptimizationFlags = (MeshOptimizationFlags)reader.ReadInt32();
}
else
{
MeshOptimized = reader.ReadBoolean();
}
}
#endif
if (HasStreamData(reader.Version))
{
reader.AlignStream(AlignType.Align4);
StreamData.Read(reader);
}
}
public override void Read(EndianStream stream)
{
base.Read(stream);
if (IsReadIndicesUsage)
{
IsUse16bitIndices = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
if (IsIndexBufferFirst)
{
m_indexBuffer = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
m_subMeshes = stream.ReadArray(() => new SubMesh(AssetsFile));
if (IsReadBlendShapes)
{
Shapes.Read(stream);
if (IsBindPosesFirst)
{
m_bindPoses = stream.ReadArray <Matrix4x4f>();
m_boneNameHashes = stream.ReadUInt32Array();
RootBoneNameHash = stream.ReadUInt32();
}
}
if (!IsIndexBufferFirst)
{
MeshCompression = stream.ReadByte();
if (IsReadBoolFlags)
{
if (IsReadStreamCompression)
{
StreamCompression = stream.ReadByte();
}
IsReadable = stream.ReadBoolean();
KeepVertices = stream.ReadBoolean();
KeepIndices = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
if (IsReadIndexFormat)
{
if (MeshCompression == 0)
{
IndexFormat = stream.ReadInt32();
}
}
m_indexBuffer = stream.ReadByteArray();
stream.AlignStream(AlignType.Align4);
}
if (IsReadVertices)
{
m_vertices = stream.ReadArray <Vector3f>();
m_bindPoses = stream.ReadArray <Matrix4x4f>();
#warning TODO:
throw new System.NotImplementedException();
}
else
{
m_skin = stream.ReadArray <BoneWeights4>();
stream.AlignStream(AlignType.Align4);
if (!IsBindPosesFirst)
{
m_bindPoses = stream.ReadArray <Matrix4x4f>();
}
VertexData = new VertexData(AssetsFile, MeshCompression);
VertexData.Read(stream);
CompressedMesh.Read(stream);
if (IsReadLocalAABB)
{
LocalAABB.Read(stream);
}
MeshUsageFlags = stream.ReadInt32();
if (IsReadCollision)
{
CollisionData.Read(stream);
}
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadLODData(reader.Version))
{
m_LODData = reader.ReadAssetArray <LOD>();
}
if (IsReadUse16bitIndices(reader.Version))
{
Use16bitIndices = reader.ReadInt32() > 0;
}
if (IsReadIndexBuffer(reader.Version))
{
if (IsReadIndexBufferFirst(reader.Version))
{
m_indexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
}
if (IsReadSubMeshes(reader.Version))
{
m_subMeshes = reader.ReadAssetArray <SubMesh>();
}
if (IsReadBlendShapes(reader.Version))
{
Shapes.Read(reader);
}
if (IsReadBindPosesFirst(reader.Version))
{
m_bindPoses = reader.ReadAssetArray <Matrix4x4f>();
}
if (IsReadBoneNameHashes(reader.Version))
{
m_boneNameHashes = reader.ReadUInt32Array();
RootBoneNameHash = reader.ReadUInt32();
}
if (IsReadBonesAABB(reader.Version))
{
m_bonesAABB = reader.ReadAssetArray <MinMaxAABB>();
VariableBoneCountWeights.Read(reader);
}
if (IsReadMeshCompression(reader.Version))
{
MeshCompression = (MeshCompression)reader.ReadByte();
}
if (IsReadStreamCompression(reader.Version))
{
StreamCompression = reader.ReadByte();
}
if (IsReadIsReadable(reader.Version))
{
IsReadable = reader.ReadBoolean();
KeepVertices = reader.ReadBoolean();
KeepIndices = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadIndexFormat(reader.Version))
{
if (IsReadIndexFormatCondition(reader.Version))
{
if (MeshCompression == 0)
{
IndexFormat = (IndexFormat)reader.ReadInt32();
}
}
else
{
IndexFormat = (IndexFormat)reader.ReadInt32();
}
}
if (IsReadIndexBuffer(reader.Version))
{
if (!IsReadIndexBufferFirst(reader.Version))
{
m_indexBuffer = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
}
}
if (IsReadVertices(reader.Version))
{
if (IsReadVertexData(reader.Version))
{
if (MeshCompression != 0)
{
m_vertices = reader.ReadAssetArray <Vector3f>();
}
}
else
{
m_vertices = reader.ReadAssetArray <Vector3f>();
}
}
if (IsReadSkin(reader.Version))
{
m_skin = reader.ReadAssetArray <BoneWeights4>();
}
if (IsReadBindPoses(reader.Version))
{
if (!IsReadBindPosesFirst(reader.Version))
{
m_bindPoses = reader.ReadAssetArray <Matrix4x4f>();
}
}
if (IsReadVertexData(reader.Version))
{
if (IsReadOnlyVertexData(reader.Version))
{
VertexData.Read(reader);
}
else
{
if (MeshCompression == 0)
{
VertexData.Read(reader);
}
else
{
m_UV = reader.ReadAssetArray <Vector2f>();
m_UV1 = reader.ReadAssetArray <Vector2f>();
m_tangents = reader.ReadAssetArray <Vector4f>();
m_normals = reader.ReadAssetArray <Vector3f>();
m_colors = reader.ReadAssetArray <ColorRGBA32>();
}
}
}
else
{
m_UV = reader.ReadAssetArray <Vector2f>();
if (IsReadUV1(reader.Version))
{
m_UV1 = reader.ReadAssetArray <Vector2f>();
}
if (IsReadTangentSpace(reader.Version))
{
m_tangentSpace = reader.ReadAssetArray <Tangent>();
}
else
{
m_tangents = reader.ReadAssetArray <Vector4f>();
m_normals = reader.ReadAssetArray <Vector3f>();
}
}
if (IsReadAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadCompressedMesh(reader.Version))
{
CompressedMesh.Read(reader);
}
LocalAABB.Read(reader);
if (IsReadColors(reader.Version))
{
if (!IsReadVertexData(reader.Version))
{
m_colors = reader.ReadAssetArray <ColorRGBA32>();
}
}
if (IsReadCollisionTriangles(reader.Version))
{
m_collisionTriangles = reader.ReadUInt32Array();
CollisionVertexCount = reader.ReadInt32();
}
if (IsReadMeshUsageFlags(reader.Version))
{
MeshUsageFlags = reader.ReadInt32();
}
if (IsReadCollision(reader.Version))
{
CollisionData.Read(reader);
}
if (IsReadMeshMetrics(reader.Version))
{
m_meshMetrics = new float[2];
m_meshMetrics[0] = reader.ReadSingle();
m_meshMetrics[1] = reader.ReadSingle();
}
#if UNIVERSAL
if (IsReadMeshOptimized(reader.Version, reader.Flags))
{
MeshOptimizationFlags = reader.ReadBoolean() ? MeshOptimizationFlags.Everything : 0;
}
else if (IsReadMeshOptimizationFlags(reader.Version, reader.Flags))
{
MeshOptimizationFlags = (MeshOptimizationFlags)reader.ReadInt32();
}
#endif
if (IsReadStreamData(reader.Version))
{
reader.AlignStream(AlignType.Align4);
StreamData.Read(reader);
}
}
