Files
AssetStudio/AssetStudio/Classes/Mesh.cs
T

1693 lines
62 KiB
C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using static AssetStudio.CustomOptions.GameSpecificOptions.CustomMeshOptions;
namespace AssetStudio
{
public class MeshData
{
public readonly List<uint> IndexBufferList;
public readonly bool IsTriangleStrip;
public MeshData(ObjectReader reader)
{
IndexBufferList = new List<uint>();
var facesCount = reader.ReadInt32();
for (var i = 0; i < facesCount; i++)
{
for (var j = 0; j < 3; j++) //Face data (Vector3)
{
IndexBufferList.Add(reader.ReadUInt16());
}
}
var stripsCount = reader.ReadInt32();
for (var i = 0; i < stripsCount; i++)
{
IndexBufferList.Add(reader.ReadUInt16());
}
IsTriangleStrip = stripsCount > 0;
}
}
public class LOD
{
private readonly List<MeshData> m_MeshData;
private readonly int m_VertexCount;
public readonly List<uint> IndexBufferList;
public LOD(ObjectReader reader)
{
m_MeshData = new List<MeshData>();
IndexBufferList = new List<uint>();
var meshDataCount = reader.ReadInt32();
for (var i = 0; i < meshDataCount; i++)
{
var meshData = new MeshData(reader);
m_MeshData.Add(meshData);
IndexBufferList.AddRange(meshData.IndexBufferList);
}
if (reader.version < (1, 5))
{
m_VertexCount = reader.ReadInt32();
var m_NewVertexStart = reader.ReadInt32();
var m_MeshError = reader.ReadSingle();
var m_MorphToVertexCount = reader.ReadInt32();
reader.Position += m_MorphToVertexCount * 2; //skip UInt16[] m_MorphToVertex
}
}
public List<SubMesh> ConvertToSubMeshes()
{
var subMeshList = new List<SubMesh>(m_MeshData.Count);
foreach (var meshData in m_MeshData)
{
subMeshList.Add(new SubMesh
{
firstByte = 0, //todo?
indexCount = (uint)meshData.IndexBufferList.Count,
topology = meshData.IsTriangleStrip ? GfxPrimitiveType.TriangleStrip : GfxPrimitiveType.Triangles,
vertexCount = (uint)m_VertexCount,
});
}
return subMeshList;
}
}
public class MinMaxAABB
{
public Vector3 m_Min;
public Vector3 m_Max;
public MinMaxAABB(ObjectReader reader)
{
m_Min = reader.ReadVector3();
m_Max = reader.ReadVector3();
}
}
public class CompressedMesh
{
public PackedFloatVector m_Vertices;
public PackedFloatVector m_UV;
public PackedFloatVector m_BindPoses;
public PackedFloatVector m_Normals;
public PackedFloatVector m_Tangents;
public PackedIntVector m_Weights;
public PackedIntVector m_NormalSigns;
public PackedIntVector m_TangentSigns;
public PackedFloatVector m_FloatColors;
public PackedIntVector m_BoneIndices;
public PackedIntVector m_Triangles;
public PackedIntVector m_Colors;
public uint m_UVInfo;
public CompressedMesh(ObjectReader reader)
{
var version = reader.version;
m_Vertices = new PackedFloatVector(reader);
m_UV = new PackedFloatVector(reader);
if (version < 5)
{
m_BindPoses = new PackedFloatVector(reader);
}
m_Normals = new PackedFloatVector(reader);
m_Tangents = new PackedFloatVector(reader);
m_Weights = new PackedIntVector(reader);
m_NormalSigns = new PackedIntVector(reader);
m_TangentSigns = new PackedIntVector(reader);
if (version >= 5)
{
m_FloatColors = new PackedFloatVector(reader);
}
m_BoneIndices = new PackedIntVector(reader);
m_Triangles = new PackedIntVector(reader);
if (version >= (3, 5)) //3.5 and up
{
if (version < 5)
{
m_Colors = new PackedIntVector(reader);
}
else
{
m_UVInfo = reader.ReadUInt32();
}
}
}
}
public class StreamInfo
{
public uint channelMask;
public uint offset;
public uint stride;
public uint align;
public byte dividerOp;
public ushort frequency;
public StreamInfo() { }
public StreamInfo(ObjectReader reader)
{
var version = reader.version;
channelMask = reader.ReadUInt32();
offset = reader.ReadUInt32();
if (version < 4) //4.0 down
{
stride = reader.ReadUInt32();
align = reader.ReadUInt32();
}
else
{
stride = reader.ReadByte();
dividerOp = reader.ReadByte();
frequency = reader.ReadUInt16();
}
}
}
public class ChannelInfo
{
public byte stream;
public byte offset;
public byte format;
public byte dimension;
public ChannelInfo() { }
public ChannelInfo(ObjectReader reader)
{
stream = reader.ReadByte();
offset = reader.ReadByte();
format = reader.ReadByte();
dimension = (byte)(reader.ReadByte() & 0xF);
}
}
public class VertexData
{
public uint m_CurrentChannels;
public uint m_VertexCount;
public List<ChannelInfo> m_Channels;
public List<StreamInfo> m_Streams;
public byte[] m_DataSize;
public VertexData(ObjectReader reader)
{
var version = reader.version;
if (version < 2018)//2018 down
{
m_CurrentChannels = reader.ReadUInt32();
}
m_VertexCount = reader.ReadUInt32();
if (version >= 4) //4.0 and up
{
var m_ChannelsSize = reader.ReadInt32();
m_Channels = new List<ChannelInfo>();
for (var i = 0; i < m_ChannelsSize; i++)
{
m_Channels.Add(new ChannelInfo(reader));
}
}
if (version < 5) //5.0 down
{
var streamCount = version < 4 //4.0 down
? 4
: reader.ReadInt32();
m_Streams = new List<StreamInfo>();
for (var i = 0; i < streamCount; i++)
{
m_Streams.Add(new StreamInfo(reader));
}
if (version < 4) //4.0 down
{
GetChannels(version);
}
}
else //5.0 and up
{
GetStreams(version);
}
m_DataSize = reader.ReadUInt8Array();
reader.AlignStream();
}
private void GetStreams(UnityVersion version)
{
var streamCount = m_Channels.Max(x => x.stream) + 1;
m_Streams = new List<StreamInfo>();
uint offset = 0;
for (var s = 0; s < streamCount; s++)
{
uint chnMask = 0;
uint stride = 0;
for (var chn = 0; chn < m_Channels.Count; chn++)
{
var m_Channel = m_Channels[chn];
if (m_Channel.stream == s)
{
if (m_Channel.dimension > 0)
{
chnMask |= 1u << chn;
stride += m_Channel.dimension * MeshHelper.GetFormatSize(MeshHelper.ToVertexFormat(m_Channel.format, version));
}
}
}
m_Streams.Add(new StreamInfo
{
channelMask = chnMask,
offset = offset,
stride = stride,
dividerOp = 0,
frequency = 0
});
offset += m_VertexCount * stride;
//static size_t AlignStreamSize (size_t size) { return (size + (kVertexStreamAlign-1)) & ~(kVertexStreamAlign-1); }
offset = (offset + (16u - 1u)) & ~(16u - 1u);
}
}
private void GetChannels(UnityVersion version)
{
m_Channels = new List<ChannelInfo>(6);
for (var i = 0; i < 6; i++)
{
m_Channels.Add(new ChannelInfo());
}
for (var s = 0; s < m_Streams.Count; s++)
{
var m_Stream = m_Streams[s];
var channelMask = new BitArray(new[] { (int)m_Stream.channelMask });
byte offset = 0;
for (var i = 0; i < 6; i++)
{
if (channelMask.Get(i))
{
var m_Channel = m_Channels[i];
m_Channel.stream = (byte)s;
m_Channel.offset = offset;
switch (i)
{
case 0: //kShaderChannelVertex
case 1: //kShaderChannelNormal
m_Channel.format = 0; //kChannelFormatFloat
m_Channel.dimension = 3;
break;
case 2: //kShaderChannelColor
m_Channel.format = 2; //kChannelFormatColor
m_Channel.dimension = 4;
break;
case 3: //kShaderChannelTexCoord0
case 4: //kShaderChannelTexCoord1
m_Channel.format = 0; //kChannelFormatFloat
m_Channel.dimension = 2;
break;
case 5: //kShaderChannelTangent
m_Channel.format = 0; //kChannelFormatFloat
m_Channel.dimension = 4;
break;
}
offset += (byte)(m_Channel.dimension * MeshHelper.GetFormatSize(MeshHelper.ToVertexFormat(m_Channel.format, version)));
}
}
}
}
}
public class BoneWeights4
{
public float[] weight;
public int[] boneIndex;
public BoneWeights4()
{
weight = new float[4];
boneIndex = new int[4];
}
public BoneWeights4(ObjectReader reader)
{
weight = reader.ReadSingleArray(4);
boneIndex = reader.ReadInt32Array(4);
}
}
public class BlendShapeVertex
{
public Vector3 vertex;
public Vector3 normal;
public Vector3 tangent;
public uint index;
public BlendShapeVertex(ObjectReader reader)
{
vertex = reader.ReadVector3();
normal = reader.ReadVector3();
tangent = reader.ReadVector3();
index = reader.ReadUInt32();
}
}
public class MeshBlendShape
{
public uint firstVertex;
public uint vertexCount;
public bool hasNormals;
public bool hasTangents;
public MeshBlendShape(ObjectReader reader)
{
var version = reader.version;
if (version < (4, 3)) //4.3 down
{
var name = reader.ReadAlignedString();
}
firstVertex = reader.ReadUInt32();
vertexCount = reader.ReadUInt32();
if (version < (4, 3)) //4.3 down
{
var aabbMinDelta = reader.ReadVector3();
var aabbMaxDelta = reader.ReadVector3();
}
hasNormals = reader.ReadBoolean();
hasTangents = reader.ReadBoolean();
if (version >= (4, 3)) //4.3 and up
{
reader.AlignStream();
}
}
}
public class MeshBlendShapeChannel
{
public string name;
public uint nameHash;
public int frameIndex;
public int frameCount;
public MeshBlendShapeChannel(ObjectReader reader)
{
name = reader.ReadAlignedString();
nameHash = reader.ReadUInt32();
frameIndex = reader.ReadInt32();
frameCount = reader.ReadInt32();
}
}
public class BlendShapeData
{
public BlendShapeVertex[] vertices;
public List<MeshBlendShape> shapes;
public List<MeshBlendShapeChannel> channels;
public float[] fullWeights;
public BlendShapeData(ObjectReader reader)
{
var version = reader.version;
if (version >= (4, 3)) //4.3 and up
{
int numVerts = reader.ReadInt32();
reader.ThrowIfTooLarge(numVerts * 40f);
vertices = new BlendShapeVertex[numVerts];
for (var i = 0; i < numVerts; i++)
{
vertices[i] = new BlendShapeVertex(reader);
}
int numShapes = reader.ReadInt32();
shapes = new List<MeshBlendShape>();
for (var i = 0; i < numShapes; i++)
{
shapes.Add(new MeshBlendShape(reader));
}
int numChannels = reader.ReadInt32();
channels = new List<MeshBlendShapeChannel>();
for (var i = 0; i < numChannels; i++)
{
channels.Add(new MeshBlendShapeChannel(reader));
}
fullWeights = reader.ReadSingleArray();
}
else
{
var m_ShapesSize = reader.ReadInt32();
var m_Shapes = new List<MeshBlendShape>();
for (var i = 0; i < m_ShapesSize; i++)
{
m_Shapes.Add(new MeshBlendShape(reader));
}
reader.AlignStream();
var m_ShapeVerticesSize = reader.ReadInt32();
reader.ThrowIfTooLarge(m_ShapeVerticesSize * 40f);
for (var i = 0; i < m_ShapeVerticesSize; i++)
{
var m_ShapeVertices = new BlendShapeVertex(reader); //MeshBlendShapeVertex
}
}
}
}
public enum GfxPrimitiveType
{
Triangles = 0,
TriangleStrip = 1,
Quads = 2,
Lines = 3,
LineStrip = 4,
Points = 5
};
public class SubMesh
{
public uint firstByte;
public uint indexCount;
public GfxPrimitiveType topology;
public uint triangleCount;
public uint baseVertex;
public uint firstVertex;
public uint vertexCount;
public AABB localAABB;
public SubMesh() { }
public SubMesh(ObjectReader reader)
{
var version = reader.version;
firstByte = reader.ReadUInt32();
indexCount = reader.ReadUInt32();
topology = (GfxPrimitiveType)reader.ReadInt32();
if (version < 4) //4.0 down
{
triangleCount = reader.ReadUInt32();
}
if (version >= (2017, 3)) //2017.3 and up
{
baseVertex = reader.ReadUInt32();
}
if (version >= 3) //3.0 and up
{
firstVertex = reader.ReadUInt32();
vertexCount = reader.ReadUInt32();
localAABB = new AABB(reader);
}
}
}
public class VGPackedHierarchyNode
{
public Vector4[] LODBounds = new Vector4[8];
public Vector3[] AABBCenter = new Vector3[8];
public uint[] MinLODError_MaxParentLODError = new uint[8];
public Vector3[] AABBExtent = new Vector3[8];
public uint[] ChildStartIndex = new uint[8];
public uint[] PageIndex_PageCount_PageBlockCount = new uint[8];
public VGPackedHierarchyNode(ObjectReader reader)
{
for (var i = 0; i < 8; i++)
{
LODBounds[i] = reader.ReadVector4();
AABBCenter[i] = reader.ReadVector3();
MinLODError_MaxParentLODError[i] = reader.ReadUInt32();
AABBExtent[i] = reader.ReadVector3();
ChildStartIndex[i] = reader.ReadUInt32();
PageIndex_PageCount_PageBlockCount[i] = reader.ReadUInt32();
}
}
}
public class VGPageStreamingInfo
{
public uint offset;
public uint wholeSize;
public uint dataSize;
public uint dependencyOffset;
public uint dependencyCount;
public uint flags;
public VGPageStreamingInfo(BinaryReader reader)
{
offset = reader.ReadUInt32();
wholeSize = reader.ReadUInt32();
dataSize = reader.ReadUInt32();
dependencyOffset = reader.ReadUInt32();
dependencyCount = reader.ReadUInt32();
flags = reader.ReadUInt32();
}
}
public class SharedClusterData //Tuanjie
{
public SharedClusterData(ObjectReader reader, byte rev)
{
var m_LightmapUseUV1 = reader.ReadInt32();
var m_fileScale = reader.ReadSingle();
if (rev == 1)
{
var NumInputTriangles = reader.ReadUInt32();
var NumInputVertices = reader.ReadUInt32();
var NumInputMeshes = reader.ReadUInt16();
var NumInputTexCoords = reader.ReadUInt16();
var ResourceFlags = reader.ReadUInt32();
}
var rootClusterPageSize = reader.ReadInt32();
reader.Position += rootClusterPageSize; //skip byte[] rootClusterPage
if (rev == 1)
{
var imposterAtlasSize = reader.ReadInt32();
reader.Position += imposterAtlasSize * 2; //skip ushort[] imposterAtlas
}
var hierarchyNodesSize = reader.ReadInt32();
for (var i = 0; i < hierarchyNodesSize; i++)
{
var hierarchyNode = new VGPackedHierarchyNode(reader);
}
if (rev == 1)
{
var hierarchyRootOffsetsSize = reader.ReadInt32();
reader.Position += hierarchyRootOffsetsSize * 4; //skip uint[] hierarchyRootOffsets
}
var pageStreamingInfosSize = reader.ReadInt32();
for (var i = 0; i < pageStreamingInfosSize; i++)
{
var pageStreamingInfo = new VGPageStreamingInfo(reader);
}
var pageIndicesOfDependenciesSize = reader.ReadInt32();
reader.Position += pageIndicesOfDependenciesSize * 4; //skip uint[] pageIndicesOfDependencies
if (rev == 2)
{
var inputTrianglesCount = reader.ReadUInt32();
var inputVerticesCount = reader.ReadUInt32();
var inputMeshesCount = reader.ReadUInt16();
var inputTexCoordsCount = reader.ReadUInt16();
var resourceFlags = reader.ReadUInt32();
var imposterAtlasSize = reader.ReadInt32();
reader.Position += imposterAtlasSize * 2; //skip ushort[] imposterAtlas
var hierarchyRootOffsetsSize = reader.ReadInt32();
reader.Position += hierarchyRootOffsetsSize * 4; //skip uint[] hierarchyRootOffsets
}
var streamableClusterPageSize = reader.ReadInt32();
reader.Position += streamableClusterPageSize; //skip byte[] streamableClusterPageSize
}
}
public sealed class Mesh : NamedObject
{
private bool isLoaded;
private bool m_Use16BitIndices = true;
public List<SubMesh> m_SubMeshes;
private uint[] m_IndexBuffer;
public BlendShapeData m_Shapes;
public Matrix4x4[] m_BindPose;
public uint[] m_BoneNameHashes;
public int m_VertexCount;
public float[] m_Vertices;
public BoneWeights4[] m_Skin;
public float[] m_Normals;
public float[] m_Colors;
public float[] m_UV0;
public float[] m_UV1;
public float[] m_UV2;
public float[] m_UV3;
public float[] m_UV4;
public float[] m_UV5;
public float[] m_UV6;
public float[] m_UV7;
public float[] m_Tangents;
private bool m_HasVirtualGeometryMesh;
private VertexData m_VertexData;
private CompressedMesh m_CompressedMesh;
private StreamingInfo m_StreamData;
public List<uint> m_Indices = new List<uint>();
public Mesh(ObjectReader reader) : base(reader)
{
if (version < 2) //2.0 down
{
LOD lod0 = null;
var m_LODDataCount = reader.ReadInt32();
for (var i = 0; i < m_LODDataCount; i++)
{
if (i == 0)
lod0 = new LOD(reader);
else
_ = new LOD(reader);
}
if (lod0 == null)
{
Logger.Warning("Can't find lod0 mesh data");
return;
}
m_IndexBuffer = lod0.IndexBufferList.ToArray();
m_SubMeshes = lod0.ConvertToSubMeshes();
}
else //2.0 and up
{
if (version < (3, 5)) //2.0 - 3.5 down
{
m_Use16BitIndices = reader.ReadInt32() > 0;
}
if (version <= (2, 5)) //2.0 - 2.5 down
{
int m_IndexBufferSize = reader.ReadInt32();
if (m_Use16BitIndices)
{
var indexBufferList = new List<uint>();
for (var i = 0; i < m_IndexBufferSize / 2; i++)
{
indexBufferList.Add(reader.ReadUInt16());
}
if (version >= (2, 1))
{
reader.AlignStream();
}
m_IndexBuffer = indexBufferList.ToArray();
}
else
{
m_IndexBuffer = reader.ReadUInt32Array(m_IndexBufferSize / 4);
}
}
int m_SubMeshesSize = reader.ReadInt32();
reader.ThrowIfTooLarge(m_SubMeshesSize * 12f);
m_SubMeshes = new List<SubMesh>();
for (var i = 0; i < m_SubMeshesSize; i++)
{
m_SubMeshes.Add(new SubMesh(reader));
}
}
if (version >= (4, 1)) //4.1 and up
{
m_Shapes = new BlendShapeData(reader);
}
if (version >= (4, 3)) //4.3 and up
{
m_BindPose = reader.ReadMatrixArray();
m_BoneNameHashes = reader.ReadUInt32Array();
var m_RootBoneNameHash = reader.ReadUInt32();
}
if (version >= (2, 6)) //2.6.0 and up
{
if (version >= 2019) //2019 and up
{
var m_BonesAABBSize = reader.ReadInt32();
for (var i = 0; i < m_BonesAABBSize; i++)
{
var m_BonesAABB = new MinMaxAABB(reader);
}
var m_VariableBoneCountWeightsSize = reader.ReadInt32();
reader.Position += m_VariableBoneCountWeightsSize * 4; //skip uint[] m_VariableBoneCountWeights
}
var m_MeshCompression = reader.ReadByte();
if (version >= 4)
{
if (version < 5)
{
var m_StreamCompression = reader.ReadByte();
}
var m_IsReadable = reader.ReadBoolean();
var m_KeepVertices = reader.ReadBoolean();
var m_KeepIndices = reader.ReadBoolean();
}
var tuanjieParsingMode = reader.assetsFile.assetsManager.Options.GameSpecific.Meshes.TuanjieMeshParsingMode;
var useSharedClusterData = tuanjieParsingMode == MeshParsingMode.Tuanjie;
if (tuanjieParsingMode == MeshParsingMode.Auto)
{
//SharedClusterData becomes optional from v1.6.1, but idk in what cases
useSharedClusterData = version < (2022, 3, 61, 2) || !serializedType.Match(6165448184371784201);
}
if (version.IsTuanjie && useSharedClusterData)
{
if (version < (2022, 3, 48, 3)) //2022.3.48t3(1.4.0) down
{
_ = new SharedClusterData(reader, rev: 1);
}
else if (version < (2022, 3, 61, 2)) //2022.3.48t3(1.4.0) - 2022.3.61t1(1.6.0)
{
_ = new SharedClusterData(reader, rev: 2);
}
else //2022.3.61t2(1.6.1) and up
{
reader.AlignStream();
_ = new SharedClusterData(reader, rev: 3);
}
}
reader.AlignStream();
//Unity fixed it in 2017.3.1p1 and later versions
if (version >= (2017, 4) //2017.4
|| version == (2017, 3, 1) && version.IsPatch //fixed after 2017.3.1px
|| version == (2017, 3) && m_MeshCompression == 0) //2017.3.xfx with no compression
{
var m_IndexFormat = reader.ReadInt32();
m_Use16BitIndices = m_IndexFormat == 0;
}
int m_IndexBufferSize = reader.ReadInt32();
if (m_Use16BitIndices)
{
var indexBufferList = new List<uint>();
for (var i = 0; i < m_IndexBufferSize / 2; i++)
{
indexBufferList.Add(reader.ReadUInt16());
}
reader.AlignStream();
m_IndexBuffer = indexBufferList.ToArray();
}
else
{
m_IndexBuffer = reader.ReadUInt32Array(m_IndexBufferSize / 4);
}
}
if (version < (3, 5)) //3.4.2 and earlier
{
m_VertexCount = reader.ReadInt32();
m_Vertices = reader.ReadSingleArray(m_VertexCount * 3); //Vector3
if (version >= (1, 5)) //1.5 - 3.5 down
{
var numSkin = reader.ReadInt32();
reader.ThrowIfTooLarge(numSkin * 32f);
m_Skin = new BoneWeights4[numSkin];
for (var s = 0; s < numSkin; s++)
{
m_Skin[s] = new BoneWeights4(reader);
}
if (version >= (2, 1)) //2.1 - 3.5 down
{
m_BindPose = reader.ReadMatrixArray();
}
}
m_UV0 = reader.ReadSingleArray(reader.ReadInt32() * 2); //Vector2
if (version >= (1, 5)) //1.5 - 3.5 down
{
m_UV1 = reader.ReadSingleArray(reader.ReadInt32() * 2); //Vector2
}
if (version < (2, 6)) //2.6 down
{
int m_TangentSpaceSize = reader.ReadInt32();
reader.ThrowIfTooLarge(m_TangentSpaceSize * 28f);
m_Normals = new float[m_TangentSpaceSize * 3];
m_Tangents = new float[m_TangentSpaceSize * 4];
for (var v = 0; v < m_TangentSpaceSize; v++)
{
m_Normals[v * 3] = reader.ReadSingle();
m_Normals[v * 3 + 1] = reader.ReadSingle();
m_Normals[v * 3 + 2] = reader.ReadSingle();
m_Tangents[v * 3] = reader.ReadSingle();
m_Tangents[v * 3 + 1] = reader.ReadSingle();
m_Tangents[v * 3 + 2] = reader.ReadSingle();
m_Tangents[v * 3 + 3] = reader.ReadSingle(); //handedness
}
}
else //2.6.0 and later
{
m_Tangents = reader.ReadSingleArray(reader.ReadInt32() * 4); //Vector4
m_Normals = reader.ReadSingleArray(reader.ReadInt32() * 3); //Vector3
}
}
else
{
if (version < (2018, 2)) //2018.2 down
{
var numSkin = reader.ReadInt32();
reader.ThrowIfTooLarge(numSkin * 32f);
m_Skin = new BoneWeights4[numSkin];
for (var s = 0; s < numSkin; s++)
{
m_Skin[s] = new BoneWeights4(reader);
}
}
if (version <= (4, 2)) //4.2 and down
{
m_BindPose = reader.ReadMatrixArray();
}
m_VertexData = new VertexData(reader);
}
if (version >= (2, 6)) //2.6.0 and later
{
m_CompressedMesh = new CompressedMesh(reader);
}
reader.Position += 24; //AABB m_LocalAABB
if (version <= (3, 4)) //3.4.2 and earlier
{
int m_ColorsSize = reader.ReadInt32();
var m_ColorsList = new List<float>();
for (var v = 0; v < m_ColorsSize * 4; v++)
{
m_ColorsList.Add((float)reader.ReadByte() / 0xFF);
}
m_Colors = m_ColorsList.ToArray();
if (version >= (1, 5)) //1.5 - 3.5 down
{
int m_CollisionTrianglesSize = reader.ReadInt32();
reader.Position += m_CollisionTrianglesSize * 4; //UInt32 indices
int m_CollisionVertexCount = reader.ReadInt32();
}
}
if (version >= (2, 5)) //2.5 and up
{
int m_MeshUsageFlags = reader.ReadInt32();
}
if (version >= (2022, 1)) //2022.1 and up
{
int m_CookingOptions = reader.ReadInt32();
}
if (version >= 5) //5.0 and up
{
var m_BakedConvexCollisionMeshSize = reader.ReadInt32();
reader.Position += m_BakedConvexCollisionMeshSize; //skip byte[] m_BakedConvexCollisionMesh
reader.AlignStream();
var m_BakedTriangleCollisionMeshSize = reader.ReadInt32();
reader.Position += m_BakedTriangleCollisionMeshSize; //skip byte[] m_BakedTriangleCollisionMesh
reader.AlignStream();
}
if (version >= (2018, 2)) //2018.2 and up
{
var m_MeshMetrics = new float[2];
m_MeshMetrics[0] = reader.ReadSingle();
m_MeshMetrics[1] = reader.ReadSingle();
}
if (version >= (2018, 3)) //2018.3 and up
{
reader.AlignStream();
m_StreamData = new StreamingInfo(reader);
}
if (version.IsTuanjie && version >= (2022, 3, 2, 13)) //2022.3.2t13(1.2.0) and up
{
var m_GenerateGeometryBuffer = reader.ReadBoolean();
m_HasVirtualGeometryMesh = reader.ReadBoolean();
}
//m_MeshLodInfo = new MeshLodInfo(reader) //6000.2 and up
if (assetsFile.assetsManager.Options.MeshPreProcessing)
ProcessData();
}
public void ProcessData()
{
if (isLoaded)
return;
var isStreamedDataSize = false;
try
{
if (!string.IsNullOrEmpty(m_StreamData?.path))
{
if (m_VertexData.m_VertexCount > 0)
{
m_VertexData.m_DataSize = BigArrayPool<byte>.Shared.Rent((int) m_StreamData.size);
var resourceReader = new ResourceReader(m_StreamData.path, assetsFile, m_StreamData.offset, m_StreamData.size);
resourceReader.GetData(m_VertexData.m_DataSize);
isStreamedDataSize = true;
}
}
if (version >= (3, 5)) //3.5 and up
{
ReadVertexData();
}
if (version >= (2, 6)) //2.6.0 and later
{
DecompressCompressedMesh();
}
if (m_IndexBuffer?.Length == 0)
{
var msg = m_HasVirtualGeometryMesh
? "Unsupported mesh type: Virtual Geometry"
: "Cannot process empty mesh";
Logger.Warning($"{msg} | PathID: {m_PathID} | Name: \"{m_Name}\"");
}
else
{
GetTriangles();
}
isLoaded = true;
}
finally
{
if (isStreamedDataSize)
BigArrayPool<byte>.Shared.Return(m_VertexData.m_DataSize, clearArray: true);
}
}
private void ReadVertexData()
{
m_VertexCount = (int)m_VertexData.m_VertexCount;
for (var chn = 0; chn < m_VertexData.m_Channels.Count; chn++)
{
var m_Channel = m_VertexData.m_Channels[chn];
if (m_Channel.dimension > 0)
{
var m_Stream = m_VertexData.m_Streams[m_Channel.stream];
var channelMask = new BitArray(new[] { (int)m_Stream.channelMask });
if (channelMask.Get(chn))
{
if (version < 2018 && chn == 2 && m_Channel.format == 2) //kShaderChannelColor && kChannelFormatColor
{
m_Channel.dimension = 4;
}
var vertexFormat = MeshHelper.ToVertexFormat(m_Channel.format, version);
var componentByteSize = (int)MeshHelper.GetFormatSize(vertexFormat);
var componentBytes = new byte[m_VertexCount * m_Channel.dimension * componentByteSize];
for (var v = 0; v < m_VertexCount; v++)
{
var vertexOffset = (int)m_Stream.offset + m_Channel.offset + (int)m_Stream.stride * v;
for (var d = 0; d < m_Channel.dimension; d++)
{
var componentOffset = vertexOffset + componentByteSize * d;
var dstOffset = componentByteSize * (v * m_Channel.dimension + d);
m_VertexData.m_DataSize.AsSpan(componentOffset, componentByteSize).CopyTo(componentBytes.AsSpan(dstOffset));
}
}
if (reader.Endian == EndianType.BigEndian && componentByteSize > 1) //swap bytes
{
for (var i = 0; i < componentBytes.Length / componentByteSize; i++)
{
componentBytes.AsSpan(i * componentByteSize, componentByteSize).Reverse();
}
}
int[] componentsIntArray = null;
float[] componentsFloatArray = null;
if (MeshHelper.IsIntFormat(vertexFormat))
componentsIntArray = MeshHelper.BytesToIntArray(componentBytes, vertexFormat);
else
componentsFloatArray = MeshHelper.BytesToFloatArray(componentBytes, vertexFormat);
if (version >= 2018)
{
switch (chn)
{
case 0: //kShaderChannelVertex
m_Vertices = componentsFloatArray;
break;
case 1: //kShaderChannelNormal
m_Normals = componentsFloatArray;
break;
case 2: //kShaderChannelTangent
m_Tangents = componentsFloatArray;
break;
case 3: //kShaderChannelColor
m_Colors = componentsFloatArray;
break;
case 4: //kShaderChannelTexCoord0
m_UV0 = componentsFloatArray;
break;
case 5: //kShaderChannelTexCoord1
m_UV1 = componentsFloatArray;
break;
case 6: //kShaderChannelTexCoord2
m_UV2 = componentsFloatArray;
break;
case 7: //kShaderChannelTexCoord3
m_UV3 = componentsFloatArray;
break;
case 8: //kShaderChannelTexCoord4
m_UV4 = componentsFloatArray;
break;
case 9: //kShaderChannelTexCoord5
m_UV5 = componentsFloatArray;
break;
case 10: //kShaderChannelTexCoord6
m_UV6 = componentsFloatArray;
break;
case 11: //kShaderChannelTexCoord7
m_UV7 = componentsFloatArray;
break;
//2018.2 and up
case 12: //kShaderChannelBlendWeight
if (m_Skin == null)
{
InitMSkin();
}
for (var i = 0; i < m_VertexCount; i++)
{
for (var j = 0; j < m_Channel.dimension; j++)
{
m_Skin[i].weight[j] = componentsFloatArray[i * m_Channel.dimension + j];
}
}
break;
case 13: //kShaderChannelBlendIndices
if (m_Skin == null)
{
InitMSkin();
if (m_Channel.dimension == 1)
{
for (var i = 0; i < m_VertexCount; i++)
{
m_Skin[i].weight[0] = 1f;
}
}
}
for (var i = 0; i < m_VertexCount; i++)
{
for (var j = 0; j < m_Channel.dimension; j++)
{
m_Skin[i].boneIndex[j] = componentsIntArray[i * m_Channel.dimension + j];
}
}
break;
default:
Logger.Warning($"Unknown vertex attribute: {chn}");
break;
}
}
else
{
switch (chn)
{
case 0: //kShaderChannelVertex
m_Vertices = componentsFloatArray;
break;
case 1: //kShaderChannelNormal
m_Normals = componentsFloatArray;
break;
case 2: //kShaderChannelColor
m_Colors = componentsFloatArray;
break;
case 3: //kShaderChannelTexCoord0
m_UV0 = componentsFloatArray;
break;
case 4: //kShaderChannelTexCoord1
m_UV1 = componentsFloatArray;
break;
case 5:
if (version >= 5) //kShaderChannelTexCoord2
{
m_UV2 = componentsFloatArray;
}
else //kShaderChannelTangent
{
m_Tangents = componentsFloatArray;
}
break;
case 6: //kShaderChannelTexCoord3
m_UV3 = componentsFloatArray;
break;
case 7: //kShaderChannelTangent
m_Tangents = componentsFloatArray;
break;
default:
Logger.Warning($"Unknown vertex attribute: {chn}");
break;
}
}
}
}
}
}
private void DecompressCompressedMesh()
{
//Vertex
if (m_CompressedMesh.m_Vertices.m_NumItems > 0)
{
m_VertexCount = (int)m_CompressedMesh.m_Vertices.m_NumItems / 3;
m_Vertices = m_CompressedMesh.m_Vertices.UnpackFloats(3, 3 * 4);
}
//UV
if (m_CompressedMesh.m_UV.m_NumItems > 0)
{
var m_UVInfo = m_CompressedMesh.m_UVInfo;
if (m_UVInfo != 0)
{
const int kInfoBitsPerUV = 4;
const int kUVDimensionMask = 3;
const int kUVChannelExists = 4;
const int kMaxTexCoordShaderChannels = 8;
int uvSrcOffset = 0;
for (var uv = 0; uv < kMaxTexCoordShaderChannels; uv++)
{
var texCoordBits = m_UVInfo >> (uv * kInfoBitsPerUV);
texCoordBits &= (1u << kInfoBitsPerUV) - 1u;
if ((texCoordBits & kUVChannelExists) != 0)
{
var uvDim = 1 + (int)(texCoordBits & kUVDimensionMask);
var m_UV = m_CompressedMesh.m_UV.UnpackFloats(uvDim, uvDim * 4, uvSrcOffset, m_VertexCount);
SetUV(uv, m_UV);
uvSrcOffset += uvDim * m_VertexCount;
}
}
}
else
{
m_UV0 = m_CompressedMesh.m_UV.UnpackFloats(2, 2 * 4, 0, m_VertexCount);
if (m_CompressedMesh.m_UV.m_NumItems >= m_VertexCount * 4)
{
m_UV1 = m_CompressedMesh.m_UV.UnpackFloats(2, 2 * 4, m_VertexCount * 2, m_VertexCount);
}
}
}
//BindPose
if (version < 5)
{
if (m_CompressedMesh.m_BindPoses.m_NumItems > 0)
{
m_BindPose = new Matrix4x4[m_CompressedMesh.m_BindPoses.m_NumItems / 16];
var m_BindPoses_Unpacked = m_CompressedMesh.m_BindPoses.UnpackFloats(16, 4 * 16);
for (var i = 0; i < m_BindPose.Length; i++)
{
m_BindPose[i] = new Matrix4x4(m_BindPoses_Unpacked.AsSpan(i * 16, 16));
}
}
}
//Normal
if (m_CompressedMesh.m_Normals.m_NumItems > 0)
{
var normalData = m_CompressedMesh.m_Normals.UnpackFloats(2, 4 * 2);
var signs = m_CompressedMesh.m_NormalSigns.UnpackInts();
m_Normals = new float[m_CompressedMesh.m_Normals.m_NumItems / 2 * 3];
for (var i = 0; i < m_CompressedMesh.m_Normals.m_NumItems / 2; ++i)
{
var x = normalData[i * 2 + 0];
var y = normalData[i * 2 + 1];
var zsqr = 1 - x * x - y * y;
float z;
if (zsqr >= 0f)
z = MathF.Sqrt(zsqr);
else
{
z = 0;
var normal = new Vector3(x, y, z);
normal.Normalize();
x = normal.X;
y = normal.Y;
z = normal.Z;
}
if (signs[i] == 0)
z = -z;
m_Normals[i * 3] = x;
m_Normals[i * 3 + 1] = y;
m_Normals[i * 3 + 2] = z;
}
}
//Tangent
if (m_CompressedMesh.m_Tangents.m_NumItems > 0)
{
var tangentData = m_CompressedMesh.m_Tangents.UnpackFloats(2, 4 * 2);
var signs = m_CompressedMesh.m_TangentSigns.UnpackInts();
m_Tangents = new float[m_CompressedMesh.m_Tangents.m_NumItems / 2 * 4];
for (var i = 0; i < m_CompressedMesh.m_Tangents.m_NumItems / 2; ++i)
{
var x = tangentData[i * 2 + 0];
var y = tangentData[i * 2 + 1];
var zsqr = 1 - x * x - y * y;
float z;
if (zsqr >= 0f)
z = MathF.Sqrt(zsqr);
else
{
z = 0;
var vector3f = new Vector3(x, y, z);
vector3f.Normalize();
x = vector3f.X;
y = vector3f.Y;
z = vector3f.Z;
}
if (signs[i * 2 + 0] == 0)
z = -z;
var w = signs[i * 2 + 1] > 0 ? 1.0f : -1.0f;
m_Tangents[i * 4] = x;
m_Tangents[i * 4 + 1] = y;
m_Tangents[i * 4 + 2] = z;
m_Tangents[i * 4 + 3] = w;
}
}
//FloatColor
if (version >= 5)
{
if (m_CompressedMesh.m_FloatColors.m_NumItems > 0)
{
m_Colors = m_CompressedMesh.m_FloatColors.UnpackFloats(1, 4);
}
}
//Skin
if (m_CompressedMesh.m_Weights.m_NumItems > 0)
{
var weights = m_CompressedMesh.m_Weights.UnpackInts();
var boneIndices = m_CompressedMesh.m_BoneIndices.UnpackInts();
InitMSkin();
int bonePos = 0;
int boneIndexPos = 0;
int j = 0;
int sum = 0;
for (var i = 0; i < m_CompressedMesh.m_Weights.m_NumItems; i++)
{
//read bone index and weight.
m_Skin[bonePos].weight[j] = weights[i] / 31.0f;
m_Skin[bonePos].boneIndex[j] = boneIndices[boneIndexPos++];
j++;
sum += weights[i];
//the weights add up to one. fill the rest for this vertex with zero, and continue with next one.
if (sum >= 31)
{
for (; j < 4; j++)
{
m_Skin[bonePos].weight[j] = 0;
m_Skin[bonePos].boneIndex[j] = 0;
}
bonePos++;
j = 0;
sum = 0;
}
//we read three weights, but they don't add up to one. calculate the fourth one, and read
//missing bone index. continue with next vertex.
else if (j == 3)
{
m_Skin[bonePos].weight[j] = (31 - sum) / 31.0f;
m_Skin[bonePos].boneIndex[j] = boneIndices[boneIndexPos++];
bonePos++;
j = 0;
sum = 0;
}
}
}
//IndexBuffer
if (m_CompressedMesh.m_Triangles.m_NumItems > 0)
{
m_IndexBuffer = Array.ConvertAll(m_CompressedMesh.m_Triangles.UnpackInts(), x => (uint)x);
}
//Color
if (m_CompressedMesh.m_Colors?.m_NumItems > 0)
{
m_CompressedMesh.m_Colors.m_NumItems *= 4;
m_CompressedMesh.m_Colors.m_BitSize /= 4;
var tempColors = m_CompressedMesh.m_Colors.UnpackInts();
m_Colors = new float[m_CompressedMesh.m_Colors.m_NumItems];
for (var v = 0; v < m_CompressedMesh.m_Colors.m_NumItems; v++)
{
m_Colors[v] = tempColors[v] / 255f;
}
}
}
private void GetTriangles()
{
foreach (var m_SubMesh in m_SubMeshes)
{
var firstIndex = m_SubMesh.firstByte / 2;
if (!m_Use16BitIndices)
{
firstIndex /= 2;
}
var indexCount = m_SubMesh.indexCount;
var topology = m_SubMesh.topology;
if (topology == GfxPrimitiveType.Triangles)
{
for (var i = 0; i < indexCount; i += 3)
{
m_Indices.Add(m_IndexBuffer[firstIndex + i]);
m_Indices.Add(m_IndexBuffer[firstIndex + i + 1]);
m_Indices.Add(m_IndexBuffer[firstIndex + i + 2]);
}
}
else if (version < 4 || topology == GfxPrimitiveType.TriangleStrip)
{
// de-stripify :
uint triIndex = 0;
for (var i = 0; i < indexCount - 2; i++)
{
var a = m_IndexBuffer[firstIndex + i];
var b = m_IndexBuffer[firstIndex + i + 1];
var c = m_IndexBuffer[firstIndex + i + 2];
// skip degenerates
if (a == b || a == c || b == c)
continue;
// do the winding flip-flop of strips :
if ((i & 1) == 1)
{
m_Indices.Add(b);
m_Indices.Add(a);
}
else
{
m_Indices.Add(a);
m_Indices.Add(b);
}
m_Indices.Add(c);
triIndex += 3;
}
//fix indexCount
m_SubMesh.indexCount = triIndex;
}
else if (topology == GfxPrimitiveType.Quads)
{
for (var q = 0; q < indexCount; q += 4)
{
m_Indices.Add(m_IndexBuffer[firstIndex + q]);
m_Indices.Add(m_IndexBuffer[firstIndex + q + 1]);
m_Indices.Add(m_IndexBuffer[firstIndex + q + 2]);
m_Indices.Add(m_IndexBuffer[firstIndex + q]);
m_Indices.Add(m_IndexBuffer[firstIndex + q + 2]);
m_Indices.Add(m_IndexBuffer[firstIndex + q + 3]);
}
//fix indexCount
m_SubMesh.indexCount = indexCount / 2 * 3;
}
else
{
throw new NotSupportedException("Failed getting triangles. Submesh topology is lines or points.");
}
}
}
private void InitMSkin()
{
m_Skin = new BoneWeights4[m_VertexCount];
for (var i = 0; i < m_VertexCount; i++)
{
m_Skin[i] = new BoneWeights4();
}
}
private void SetUV(int uv, float[] m_UV)
{
switch (uv)
{
case 0:
m_UV0 = m_UV;
break;
case 1:
m_UV1 = m_UV;
break;
case 2:
m_UV2 = m_UV;
break;
case 3:
m_UV3 = m_UV;
break;
case 4:
m_UV4 = m_UV;
break;
case 5:
m_UV5 = m_UV;
break;
case 6:
m_UV6 = m_UV;
break;
case 7:
m_UV7 = m_UV;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public float[] GetUV(int uv)
{
switch (uv)
{
case 0:
return m_UV0;
case 1:
return m_UV1;
case 2:
return m_UV2;
case 3:
return m_UV3;
case 4:
return m_UV4;
case 5:
return m_UV5;
case 6:
return m_UV6;
case 7:
return m_UV7;
default:
throw new ArgumentOutOfRangeException();
}
}
}
public static class MeshHelper
{
public enum VertexChannelFormat
{
Float,
Float16,
Color,
Byte,
UInt32
}
public enum VertexFormat2017
{
Float,
Float16,
Color,
UNorm8,
SNorm8,
UNorm16,
SNorm16,
UInt8,
SInt8,
UInt16,
SInt16,
UInt32,
SInt32
}
public enum VertexFormat
{
Float,
Float16,
UNorm8,
SNorm8,
UNorm16,
SNorm16,
UInt8,
SInt8,
UInt16,
SInt16,
UInt32,
SInt32
}
public static VertexFormat ToVertexFormat(int format, UnityVersion version)
{
if (version < 2017)
{
switch ((VertexChannelFormat)format)
{
case VertexChannelFormat.Float:
return VertexFormat.Float;
case VertexChannelFormat.Float16:
return VertexFormat.Float16;
case VertexChannelFormat.Color: //in 4.x is size 4
return VertexFormat.UNorm8;
case VertexChannelFormat.Byte:
return VertexFormat.UInt8;
case VertexChannelFormat.UInt32: //in 5.x
return VertexFormat.UInt32;
default:
throw new ArgumentOutOfRangeException(nameof(format), format, null);
}
}
else if (version < 2019)
{
switch ((VertexFormat2017)format)
{
case VertexFormat2017.Float:
return VertexFormat.Float;
case VertexFormat2017.Float16:
return VertexFormat.Float16;
case VertexFormat2017.Color:
case VertexFormat2017.UNorm8:
return VertexFormat.UNorm8;
case VertexFormat2017.SNorm8:
return VertexFormat.SNorm8;
case VertexFormat2017.UNorm16:
return VertexFormat.UNorm16;
case VertexFormat2017.SNorm16:
return VertexFormat.SNorm16;
case VertexFormat2017.UInt8:
return VertexFormat.UInt8;
case VertexFormat2017.SInt8:
return VertexFormat.SInt8;
case VertexFormat2017.UInt16:
return VertexFormat.UInt16;
case VertexFormat2017.SInt16:
return VertexFormat.SInt16;
case VertexFormat2017.UInt32:
return VertexFormat.UInt32;
case VertexFormat2017.SInt32:
return VertexFormat.SInt32;
default:
throw new ArgumentOutOfRangeException(nameof(format), format, null);
}
}
else
{
return (VertexFormat)format;
}
}
public static uint GetFormatSize(VertexFormat format)
{
switch (format)
{
case VertexFormat.Float:
case VertexFormat.UInt32:
case VertexFormat.SInt32:
return 4u;
case VertexFormat.Float16:
case VertexFormat.UNorm16:
case VertexFormat.SNorm16:
case VertexFormat.UInt16:
case VertexFormat.SInt16:
return 2u;
case VertexFormat.UNorm8:
case VertexFormat.SNorm8:
case VertexFormat.UInt8:
case VertexFormat.SInt8:
return 1u;
default:
throw new ArgumentOutOfRangeException(nameof(format), format, null);
}
}
public static bool IsIntFormat(VertexFormat format)
{
return format >= VertexFormat.UInt8;
}
public static float[] BytesToFloatArray(ReadOnlySpan<byte> inputBytes, VertexFormat format)
{
if (format == VertexFormat.Float)
{
return MemoryMarshal.Cast<byte, float>(inputBytes).ToArray();
}
var size = GetFormatSize(format);
var len = inputBytes.Length / size;
var result = new float[len];
for (var i = 0; i < len; i++)
{
switch (format)
{
case VertexFormat.Float16:
result[i] = (float)inputBytes.ReadHalf(i * 2);
break;
case VertexFormat.UNorm8:
result[i] = inputBytes[i] / 255f;
break;
case VertexFormat.SNorm8:
result[i] = Math.Max((sbyte)inputBytes[i] / 127f, -1f);
break;
case VertexFormat.UNorm16:
result[i] = inputBytes.ReadUInt16(i * 2) / 65535f;
break;
case VertexFormat.SNorm16:
result[i] = Math.Max(inputBytes.ReadInt16(i * 2) / 32767f, -1f);
break;
}
}
return result;
}
public static int[] BytesToIntArray(ReadOnlySpan<byte> inputBytes, VertexFormat format)
{
if (format == VertexFormat.SInt32)
{
return MemoryMarshal.Cast<byte, int>(inputBytes).ToArray();
}
var size = GetFormatSize(format);
var len = inputBytes.Length / size;
var result = new int[len];
for (var i = 0; i < len; i++)
{
switch (format)
{
case VertexFormat.UInt8:
case VertexFormat.SInt8:
result[i] = inputBytes[i];
break;
case VertexFormat.UInt16:
result[i] = inputBytes.ReadUInt16(i * 2);
break;
case VertexFormat.SInt16:
result[i] = inputBytes.ReadInt16(i * 2);
break;
case VertexFormat.UInt32:
result[i] = (int)inputBytes.ReadUInt32(i * 4);
break;
}
}
return result;
}
}
}