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