protected override void WriteObject(AssetsWriter writer) { writer.Write(Name); //writer.Write(MeshData); writer.WriteArrayOf(SubMeshes, (o, w) => o.Write(w)); BlendShapeData.Write(writer); writer.WriteArrayOf(BindPose, (o, w) => w.Write(o)); writer.WriteArrayOf(BoneNameHashes, (o, w) => w.Write(o)); writer.Write(RootBoneNameHash); writer.Write(MeshCompression); writer.Write(IsReadable); writer.Write(KeepVerticies); writer.Write(KeepIndicies); writer.AlignTo(4); writer.Write(IndexFormat); writer.WriteArray(IndexBuffer); writer.AlignTo(4); VertexData.Write(writer); CompressedMesh.Write(writer); LocalAABB.Write(writer); writer.Write(MeshUsageFlags); writer.WriteArray(BakedConvexCollisionMesh); writer.AlignTo(4); writer.WriteArray(BakedTriangleCollisionMesh); writer.AlignTo(4); writer.Write(MeshMetrics1); writer.Write(MeshMetrics2); StreamData.Write(writer); }
public YAMLNode ExportYAML(IExportContainer container) { YAMLMappingNode node = new YAMLMappingNode(); node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion)); node.Add(FirstByteName, FirstByte); node.Add(IndexCountName, IndexCount); if (HasTriangleCount(container.ExportVersion)) { node.Add(IsTriStripName, (int)Topology); node.Add(TriangleCountName, TriangleCount); } else { node.Add(TopologyName, (int)Topology); } if (HasBaseVertex(container.ExportVersion)) { node.Add(BaseVertexName, BaseVertex); } if (HasVertex(container.ExportVersion)) { node.Add(FirstVertexName, FirstVertex); node.Add(VertexCountName, VertexCount); node.Add(LocalAABBName, LocalAABB.ExportYAML(container)); } return(node); }
public unsafe override void GetCorners(Vector3D *corners) { LocalAABB.GetCornersUnsafe(corners); for (int i = 0; i < 8; i++) { corners[i] = Vector3D.Transform(corners[i], WorldMatrix); } }
public void Write(AssetsWriter writer) { writer.Write(FirstByte); writer.Write(IndexCount); writer.Write(Topology); writer.Write(BaseVertex); writer.Write(FirstVertex); writer.Write(VertexCount); LocalAABB.Write(writer); }
public YAMLNode ExportYAML() { YAMLMappingNode node = new YAMLMappingNode(); node.AddSerializedVersion(SerializedVersion); node.Add("firstByte", FirstByte); node.Add("indexCount", IndexCount); node.Add("topology", Topology); node.Add("firstVertex", FirstVertex); node.Add("vertexCount", VertexCount); node.Add("localAABB", LocalAABB.ExportYAML()); return(node); }
public YAMLNode ExportYAML(IExportContainer container) { #warning TODO: values acording to read version (current 2017.3.0f3) YAMLMappingNode node = new YAMLMappingNode(); node.AddSerializedVersion(GetSerializedVersion(container.Version)); node.Add("firstByte", FirstByte); node.Add("indexCount", IndexCount); node.Add("topology", (uint)GetTopology(container.Version)); node.Add("firstVertex", FirstVertex); node.Add("vertexCount", VertexCount); node.Add("localAABB", LocalAABB.ExportYAML(container)); return(node); }
public YAMLNode ExportYAML(IExportContainer container) { YAMLMappingNode node = new YAMLMappingNode(); node.AddSerializedVersion(GetSerializedVersion(container.Version)); node.Add("firstByte", FirstByte); node.Add("indexCount", IndexCount); node.Add("topology", (uint)GetTopology(container.Version)); node.Add("firstVertex", FirstVertex); node.Add("vertexCount", VertexCount); node.Add("localAABB", LocalAABB.ExportYAML(container)); return(node); }
public YAMLNode ExportYAML(IExportContainer container) { YAMLMappingNode node = new YAMLMappingNode(); node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion)); node.Add(FirstByteName, FirstByte); node.Add(IndexCountName, IndexCount); node.Add(TopologyName, (uint)GetTopology(container.Version)); node.Add(FirstVertexName, FirstVertex); node.Add(VertexCountName, VertexCount); node.Add(LocalAABBName, LocalAABB.ExportYAML(container)); return(node); }
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, 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); }
public override void DebugDrawDeactivated() { if (Activated || !Visible) { return; } Vector3 colorToDraw = MinerWarsMath.Color.Green.ToVector3(); float alpha = 1f; if (Type == MyDummyPointType.Box) { MyDebugDraw.DrawHiresBoxWireframe(Matrix.CreateScale(LocalAABB.Size()) * WorldMatrix, colorToDraw, alpha); } else { MyDebugDraw.DrawSphereWireframe(Matrix.CreateScale(Radius) * WorldMatrix, colorToDraw, alpha); } }
public void Read(AssetReader reader) { FirstByte = (int)reader.ReadUInt32(); IndexCount = (int)reader.ReadUInt32(); Topology = (MeshTopology)reader.ReadInt32(); if (HasTriangleCount(reader.Version)) { TriangleCount = (int)reader.ReadUInt32(); } if (HasBaseVertex(reader.Version)) { BaseVertex = (int)reader.ReadUInt32(); } if (HasVertex(reader.Version)) { FirstVertex = (int)reader.ReadUInt32(); VertexCount = (int)reader.ReadUInt32(); LocalAABB.Read(reader); } }
public void Write(AssetWriter writer) { writer.Write((uint)FirstByte); writer.Write((uint)IndexCount); writer.Write((int)Topology); if (HasTriangleCount(writer.Version)) { writer.Write(TriangleCount); } if (HasBaseVertex(writer.Version)) { writer.Write((uint)BaseVertex); } if (HasVertex(writer.Version)) { writer.Write((uint)FirstVertex); writer.Write((uint)VertexCount); LocalAABB.Write(writer); } }
public void Read(AssetStream stream) { FirstByte = (int)stream.ReadUInt32(); IndexCount = (int)stream.ReadUInt32(); Topology = (MeshTopology)stream.ReadUInt32(); if (IsReadTriangleCount(stream.Version)) { TriangleCount = (int)stream.ReadUInt32(); } if (IsReadBaseVertex(stream.Version)) { BaseVertex = stream.ReadUInt32(); } if (IsReadVertex(stream.Version)) { FirstVertex = stream.ReadUInt32(); VertexCount = stream.ReadUInt32(); LocalAABB.Read(stream); } }
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 Read(EndianStream stream) { FirstByte = stream.ReadUInt32(); //what is this in case of triangle strips? IndexCount = stream.ReadUInt32(); //isTriStrip Topology = stream.ReadInt32(); if (IsReadTriangleCount) { TriangleCount = stream.ReadUInt32(); } if (IsReadVertex) { if (IsReadBaseVertex) { BaseVertex = stream.ReadUInt32(); } FirstVertex = stream.ReadUInt32(); VertexCount = stream.ReadUInt32(); LocalAABB.Read(stream); } }
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(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 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); } }
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); } } }