private static DB2.wdc1_db2_header ReadHeader(MemoryStream ms)
{
StreamTools s = new StreamTools();
DB2.wdc1_db2_header header = new DB2.wdc1_db2_header();
header.magic = s.ReadUint32(ms); // 'WDC1'
header.record_count = s.ReadUint32(ms);
header.field_count = s.ReadUint32(ms);
header.record_size = s.ReadUint32(ms);
header.string_table_size = s.ReadUint32(ms);
header.table_hash = s.ReadUint32(ms); // hash of the table name
header.layout_hash = s.ReadUint32(ms); // this is a hash field that changes only when the structure of the data changes
header.min_id = s.ReadUint32(ms);
header.max_id = s.ReadUint32(ms);
header.locale = s.ReadUint32(ms); // as seen in TextWowEnum
header.copy_table_size = s.ReadUint32(ms);
header.flags = (DB2.DB2Flags)s.ReadUint16(ms); // possible values are listed in Known Flag Meanings
header.id_index = s.ReadUint16(ms); // this is the index of the field containing ID values; this is ignored if flags & 0x04 != 0
header.total_field_count = s.ReadUint32(ms); // from WDC1 onwards, this value seems to always be the same as the 'field_count' value
header.bitpacked_data_offset = s.ReadUint32(ms); // relative position in record where bitpacked data begins; not important for parsing the file
header.lookup_column_count = s.ReadUint32(ms);
header.offset_map_offset = s.ReadUint32(ms); // Offset to array of struct {header.offset; uint16_t size;}[max_id - min_id + 1];
header.id_list_size = s.ReadUint32(ms); // List of ids present in the DB file
header.field_storage_info_size = s.ReadUint32(ms); // 24 * NumFields bytes, describes column bit packing, {ushort recordOffset, ushort size, uint additionalDataSize, uint compressionType, uint packedDataOffset or commonvalue, uint cellSize, uint cardinality}[NumFields], sizeof(DBC2CommonValue) == 8
header.common_data_size = s.ReadUint32(ms);
header.pallet_data_size = s.ReadUint32(ms); // in bytes, sizeof(DBC2PalletValue) == 4
header.relationship_data_size = s.ReadUint32(ms); // referenceDataSize - uint NumRecords, uint minId, uint maxId, {uint id, uint index}[NumRecords]
return(header);
}
public static void ParseSkin(MemoryStream ms, M2Data m2Data)
{
StreamTools s = new StreamTools();
string magic = s.ReadFourCC(ms); // 'SKIN'
M2Array indices = s.ReadM2Array(ms);
M2Array triangles = s.ReadM2Array(ms);
M2Array bones = s.ReadM2Array(ms);
M2Array submeshes = s.ReadM2Array(ms);
M2Array batches = s.ReadM2Array(ms); // nTexture_units
int boneCountMax = s.ReadLong(ms); // WoW takes this and divides it by the number of bones in each submesh, then stores the biggest one.
// Maximum number of bones per drawcall for each view. Related to (old) GPU numbers of registers.
// Values seen : 256, 64, 53, 21
M2Array shadow_batches = s.ReadM2Array(ms);
/// Read Batches ///
ms.Seek(batches.offset, SeekOrigin.Begin);
for (var batch = 0; batch < batches.size; batch++)
{
M2BatchIndices m2BatchIndices = new M2BatchIndices();
m2BatchIndices.M2Batch_flags = s.ReadShort(ms); // probably two uint8_t? -- Usually 16 for static textures, and 0 for animated textures. &0x1: materials invert something; &0x2: transform &0x4: projected texture; &0x10: something batch compatible; &0x20: projected texture?; &0x40: transparency something
m2BatchIndices.M2Batch_shader_id = s.ReadShort(ms); // See below.
m2BatchIndices.M2Batch_submesh_index = s.ReadShort(ms); // A duplicate entry of a submesh from the list above.
m2BatchIndices.M2Batch_submesh_index2 = s.ReadShort(ms); // See below.
m2BatchIndices.M2Batch_color_index = s.ReadShort(ms); // A Color out of the Colors-Block or -1 if none.
m2BatchIndices.M2Batch_render_flags = s.ReadShort(ms); // The renderflags used on this texture-unit.
m2BatchIndices.M2Batch_layer = s.ReadShort(ms); //
m2BatchIndices.M2Batch_op_count = s.ReadShort(ms); // 1 to 4. See below. Also seems to be the number of textures to load, starting at the texture lookup in the next field (0x10).
m2BatchIndices.M2Batch_texture = s.ReadShort(ms); // Index into Texture lookup table
m2BatchIndices.M2Batch_tex_unit_number2 = s.ReadShort(ms); // Index into the texture unit lookup table.
m2BatchIndices.M2Batch_transparency = s.ReadShort(ms); // Index into transparency lookup table.
m2BatchIndices.M2Batch_texture_anim = s.ReadShort(ms); // Index into uvanimation lookup table.
m2Data.m2BatchIndices.Add(m2BatchIndices);
}
// Read SubMesh Data //
int[] Indices = new int[indices.size];
int[] Triangles = new int[triangles.size];
int[] skinSectionId = new int[submeshes.size]; // Mesh part ID, see below.
int[] submesh_StartVertex = new int[submeshes.size]; // Starting vertex number.
int[] submesh_NbrVerts = new int[submeshes.size]; // Number of vertices.
int[] submesh_StartTriangle = new int[submeshes.size]; // Starting triangle index (that's 3* the number of triangles drawn so far).
int[] submesh_NbrTris = new int[submeshes.size]; // Number of triangle indices.
int[] submesh_boneCount = new int[submeshes.size]; // Number of elements in the bone lookup table. Max seems to be 256 in Wrath. Shall be ≠ 0.
int[] submesh_boneComboIndex = new int[submeshes.size]; // Starting index in the bone lookup table.
int[] submesh_boneInfluences = new int[submeshes.size]; // <= 4
// from <=BC documentation: Highest number of bones needed at one time in this Submesh --Tinyn (wowdev.org)
// In 2.x this is the amount of of bones up the parent-chain affecting the submesh --NaK
// Highest number of bones referenced by a vertex of this submesh. 3.3.5a and suspectedly all other client revisions. -- Skarn
int[] submesh_centerBoneIndex = new int[submeshes.size];
Vector3[] submesh_centerPosition = new Vector3[submeshes.size]; // Average position of all the vertices in the sub mesh.
Vector3[] submesh_sortCenterPosition = new Vector3[submeshes.size]; // The center of the box when an axis aligned box is built around the vertices in the submesh.
float[] submesh_sortRadius = new float[submeshes.size]; // Distance of the vertex farthest from CenterBoundingBox.
/// Indices ///
ms.Seek(indices.offset, SeekOrigin.Begin);
for (var ind = 0; ind < indices.size; ind++)
{
Indices[ind] = s.ReadShort(ms);
}
/// triangles ///
ms.Seek(triangles.offset, SeekOrigin.Begin);
for (var tri = 0; tri < triangles.size; tri++)
{
Triangles[tri] = s.ReadShort(ms);
}
/// submeshes ///
ms.Seek(submeshes.offset, SeekOrigin.Begin);
for (var sub = 0; sub < submeshes.size; sub++)
{
skinSectionId[sub] = s.ReadUint16(ms);
int Level = s.ReadUint16(ms); // (level << 16) is added (|ed) to startTriangle and alike to avoid having to increase those fields to uint32s.
submesh_StartVertex[sub] = s.ReadUint16(ms) + (Level << 16);
submesh_NbrVerts[sub] = s.ReadUint16(ms);
submesh_StartTriangle[sub] = s.ReadUint16(ms) + (Level << 16);
submesh_NbrTris[sub] = s.ReadUint16(ms);
submesh_boneCount[sub] = s.ReadUint16(ms);
submesh_boneComboIndex[sub] = s.ReadUint16(ms);
submesh_boneInfluences[sub] = s.ReadUint16(ms);
submesh_centerBoneIndex[sub] = s.ReadUint16(ms);
Vector3 raw_centerPosition = new Vector3(s.ReadFloat(ms) / Settings.worldScale, s.ReadFloat(ms) / Settings.worldScale, s.ReadFloat(ms) / Settings.worldScale);
submesh_centerPosition[sub] = new Vector3(-raw_centerPosition.x, raw_centerPosition.z, -raw_centerPosition.y);
Vector3 raw_sortCenterPosition = new Vector3(s.ReadFloat(ms) / Settings.worldScale, s.ReadFloat(ms) / Settings.worldScale, s.ReadFloat(ms) / Settings.worldScale);
submesh_sortCenterPosition[sub] = new Vector3(-raw_sortCenterPosition.x, raw_sortCenterPosition.z, -raw_sortCenterPosition.y);
submesh_sortRadius[sub] = s.ReadFloat(ms);
}
/// Assemble Submeshes ///
m2Data.submeshData = new List <SubmeshData>();
for (int sm = 0; sm < submeshes.size; sm++)
{
Vector3[] vertList = new Vector3[submesh_NbrVerts[sm]];
Vector3[] normsList = new Vector3[submesh_NbrVerts[sm]];
Vector2[] uvsList = new Vector2[submesh_NbrVerts[sm]];
Vector2[] uvs2List = new Vector2[submesh_NbrVerts[sm]];
BoneWeights[] boneWeights = new BoneWeights[submesh_NbrVerts[sm]];
for (int vn = 0; vn < submesh_NbrVerts[sm]; vn++)
{
vertList[vn] = m2Data.meshData.pos[vn + submesh_StartVertex[sm]];
normsList[vn] = m2Data.meshData.normal[vn + submesh_StartVertex[sm]];
uvsList[vn] = m2Data.meshData.tex_coords[vn + submesh_StartVertex[sm]];
uvs2List[vn] = m2Data.meshData.tex_coords2[vn + submesh_StartVertex[sm]];
BoneWeights boneWeightVert = new BoneWeights();
int[] boneIndex = new int[4];
float[] boneWeight = new float[4];
for (int bn = 0; bn < 4; bn++)
{
boneIndex[bn] = m2Data.meshData.bone_indices[vn + submesh_boneComboIndex[sm]][bn];
boneWeight[bn] = m2Data.meshData.bone_weights[vn + submesh_boneComboIndex[sm]][bn];
}
boneWeightVert.boneIndex = boneIndex;
boneWeightVert.boneWeight = boneWeight;
boneWeights[vn] = boneWeightVert;
}
int[] triList = new int[submesh_NbrTris[sm]];
for (var t = 0; t < submesh_NbrTris[sm]; t++)
{
//triList[t] = Triangles[t + submesh_StartTriangle[sm]] - submesh_StartVertex[sm]; // using Separate Meshes, reset first triangle to index 0;
triList[t] = Triangles[t + submesh_StartTriangle[sm]]; // using Unity Submeshes, don't reset first triangle to index 0;
}
SubmeshData submeshData = new SubmeshData();
submeshData.ID = skinSectionId[sm];
submeshData.vertList = vertList;
submeshData.normsList = normsList;
submeshData.uvsList = uvsList;
submeshData.uvs2List = uvs2List;
Array.Reverse(triList);
submeshData.triList = triList;
submeshData.submesh_StartVertex = submesh_StartVertex[sm];
submeshData.boneWeights = boneWeights;
submeshData.submesh_boneCount = submesh_boneCount[sm];
submeshData.submesh_boneInfluences = submesh_boneInfluences[sm];
m2Data.submeshData.Add(submeshData);
}
/// Assemble Bone Data ///
///
}
public static void Read(string fileName, byte[] fileData)
{
using (MemoryStream ms = new MemoryStream(fileData))
{
// Header //
StreamTools s = new StreamTools();
DB2.wdc1_db2_header header = ReadHeader(ms);
// Field Meta Data //
fields = new DB2.field_structure[header.total_field_count];
for (int f = 0; f < header.total_field_count; f++)
{
DB2.field_structure field = new DB2.field_structure();
field.size = s.ReadShort(ms);
field.offset = s.ReadShort(ms);
fields[f] = field;
}
if (!header.flags.HasFlag(DB2.DB2Flags.Sparse))
{
/// Normal records ///
// Read Records Data //
recordsData = new byte[header.record_count * header.record_size];
ms.Read(recordsData, 0, header.record_count * header.record_size);
Array.Resize(ref recordsData, recordsData.Length + 8);
// Read String Data //
//Debug.Log("header.string_table_size " + header.string_table_size);
m_stringsTable = new Dictionary <long, string>();
for (int i = 0; i < header.string_table_size;)
{
long oldPos = ms.Position;
m_stringsTable[i] = s.ReadCString(ms, Encoding.UTF8);
//Debug.Log(m_stringsTable[i]);
i += (int)(ms.Position - oldPos);
}
}
else
{
/// Offset map records /// -- these records have null-terminated strings inlined, and
// since they are variable-length, they are pointed to by an array of 6-byte
// offset+size pairs.
ms.Read(recordsData, 0, header.offset_map_offset - headerSize - Marshal.SizeOf <DB2.field_structure>() * header.total_field_count);
if (ms.Position != header.offset_map_offset)
{
Debug.LogError("Error: r.BaseStream.Position != sparseTableOffset");
}
Dictionary <uint, int> offSetKeyMap = new Dictionary <uint, int>();
List <DB2.offset_map_entry> tempSparseEntries = new List <DB2.offset_map_entry>();
for (int i = 0; i < (header.max_id - header.min_id + 1); i++)
{
DB2.offset_map_entry sparse = s.Read <DB2.offset_map_entry>(ms);
if (sparse.offset == 0 || sparse.size == 0)
{
continue;
}
// special case, may contain duplicates in the offset map that we don't want
if (header.copy_table_size == 0)
{
if (offSetKeyMap.ContainsKey(sparse.offset))
{
continue;
}
}
tempSparseEntries.Add(sparse);
offSetKeyMap.Add(sparse.offset, 0);
}
sparseEntries = tempSparseEntries.ToArray();
}
// Index Data //
m_indexData = new int[header.id_list_size / 4];
for (int iD = 0; iD < header.id_list_size / 4; iD++)
{
m_indexData[iD] = s.ReadLong(ms);
}
// Duplicate Rows Data //
Dictionary <int, int> copyData = new Dictionary <int, int>();
for (int i = 0; i < header.copy_table_size / 8; i++)
{
copyData[s.ReadLong(ms)] = s.ReadLong(ms);
}
for (int t = 0; t < header.record_count; t++)
{
if (copyData.ContainsKey(t))
{
Debug.Log("copy " + t + " to " + copyData[t]);
}
}
// Column Meta Data //
m_columnMeta = new DB2.ColumnMetaData[header.total_field_count];
//Debug.Log("header.total_field_count " + header.total_field_count);
for (int cmd = 0; cmd < header.total_field_count; cmd++)
{
DB2.ColumnMetaData columnData = new DB2.ColumnMetaData();
columnData.RecordOffset = s.ReadUint16(ms);
columnData.Size = s.ReadUint16(ms);
columnData.AdditionalDataSize = s.ReadUint32(ms);
columnData.CompressionType = (DB2.CompressionType)s.ReadLong(ms);
switch (columnData.CompressionType)
{
case DB2.CompressionType.Immediate:
{
DB2.ColumnCompressionData_Immediate Immediate = new DB2.ColumnCompressionData_Immediate();
Immediate.BitOffset = s.ReadUint32(ms);
Immediate.BitWidth = s.ReadUint32(ms);
Immediate.Flags = s.ReadUint32(ms);
columnData.Immediate = Immediate;
break;
}
case DB2.CompressionType.Pallet:
{
DB2.ColumnCompressionData_Pallet Pallet = new DB2.ColumnCompressionData_Pallet();
Pallet.BitOffset = s.ReadUint32(ms);
Pallet.BitWidth = s.ReadUint32(ms);
Pallet.Cardinality = s.ReadUint32(ms);
columnData.Pallet = Pallet;
break;
}
case DB2.CompressionType.Common:
{
DB2.ColumnCompressionData_Common Common = new DB2.ColumnCompressionData_Common();
Common.DefaultValue = s.ReadValue32(ms, 32);
Common.B = s.ReadUint32(ms);
Common.C = s.ReadUint32(ms);
columnData.Common = Common;
break;
}
default:
{
s.ReadUint32(ms);
s.ReadUint32(ms);
s.ReadUint32(ms);
break;
}
}
m_columnMeta[cmd] = columnData;
}
// Pallet Data //
m_palletData = new DB2.Value32[m_columnMeta.Length][];
for (int i = 0; i < m_columnMeta.Length; i++)
{
if (m_columnMeta[i].CompressionType == DB2.CompressionType.Pallet || m_columnMeta[i].CompressionType == DB2.CompressionType.PalletArray)
{
m_palletData[i] = s.ReadArray <DB2.Value32>(ms, (int)m_columnMeta[i].AdditionalDataSize / 4);
}
}
// Common Data //
m_commonData = new Dictionary <int, DB2.Value32> [m_columnMeta.Length];
for (int i = 0; i < m_columnMeta.Length; i++)
{
//Debug.Log(m_columnMeta[i].CompressionType);
if (m_columnMeta[i].CompressionType == DB2.CompressionType.Common)
{
Dictionary <int, DB2.Value32> commonValues = new Dictionary <int, DB2.Value32>();
m_commonData[i] = commonValues;
for (int j = 0; j < m_columnMeta[i].AdditionalDataSize / 8; j++)
{
commonValues[s.ReadLong(ms)] = s.Read <DB2.Value32>(ms);
}
}
}
// Reference Data //
DB2.ReferenceData refData = null;
if (header.relationship_data_size > 0)
{
refData = new DB2.ReferenceData
{
NumRecords = s.ReadLong(ms),
MinId = s.ReadLong(ms),
MaxId = s.ReadLong(ms)
};
refData.Entries = s.ReadArray <DB2.ReferenceEntry>(ms, refData.NumRecords);
}
//DB2.BitReader bitReader = new DB2.BitReader(recordsData);
//int position = 0;
using (MemoryStream rs = new MemoryStream(recordsData))
{
for (int i = 0; i < header.record_count; ++i)
{
int[] values = new int[m_columnMeta.Length];
values[0] = s.ReadUint32(rs);
values[1] = s.ReadUint16(rs);
values[2] = s.ReadUint16(rs);
values[3] = s.ReadUint32(rs);
//Debug.Log(i + " " + values[0] + " " + values[1] + " " + values[2] + " " + values[3]);
}
}
for (int i = 0; i < header.record_count; ++i)
{
int[] values = new int[m_columnMeta.Length];
//values[0] = s.ReadUint32(ms);
//values[1] = s.ReadUint16(ms);
//values[2] = s.ReadUint16(ms);
//values[3] = ms.ReadByte();
//values[0] = new recordsData[position]
//Debug.Log(recordsData[])
//Debug.Log(i + " " + values[0] + " " + values[1] + " " + values[2] + " " + values[3]);
for (int j = 0; j < m_columnMeta.Length; j++)
{
/*
* if (m_columnMeta[j].CompressionType == DB2.CompressionType.Common)
* values[j] = m_commonData[j][i].GetValue<int>();
* if (m_columnMeta[j].CompressionType == DB2.CompressionType.Pallet)
* values[j] = m_palletData[j][i].GetValue<int>();
*/
}
/*
* bitReader.Position = 0;
* bitReader.Offset = i * header.record_size;
*
* DB2.IDB2Row rec = new WDC1Row(this, bitReader, indexDataSize != 0 ? m_indexData[i] : -1, refData?.Entries[i]);
* rec.RecordIndex = i;
*
* if (indexDataSize != 0)
* _Records.Add(m_indexData[i], rec);
* else
* _Records.Add(rec.Id, rec);
*/
}
}
}
public static void ReadMD21(MemoryStream ms, M2Data m2Data, M2Texture m2Tex)
{
long md20position = ms.Position;
StreamTools s = new StreamTools();
int MD20 = s.ReadLong(ms); // "MD20". Legion uses a chunked file format starting with MD21.
int version = s.ReadLong(ms);
M2Array name = s.ReadM2Array(ms); // should be globally unique, used to reload by name in internal clients
var flags = s.ReadLong(ms);
M2Array global_loops = s.ReadM2Array(ms); // Timestamps used in global looping animations.
M2Array sequences = s.ReadM2Array(ms); // Information about the animations in the model.
M2Array sequences_lookups = s.ReadM2Array(ms); // Mapping of sequence IDs to the entries in the Animation sequences block.
M2Array bones = s.ReadM2Array(ms); // MAX_BONES = 0x100 => Creature\SlimeGiant\GiantSlime.M2 has 312 bones(Wrath)
M2Array key_bone_lookup = s.ReadM2Array(ms); // Lookup table for key skeletal bones.
M2Array vertices = s.ReadM2Array(ms);
int num_skin_profiles = s.ReadLong(ms);
M2Array colors = s.ReadM2Array(ms); // Color and alpha animations definitions.
M2Array textures = s.ReadM2Array(ms);
M2Array texture_weights = s.ReadM2Array(ms); // Transparency of textures.
M2Array texture_transforms = s.ReadM2Array(ms);
M2Array replaceable_texture_lookup = s.ReadM2Array(ms);
M2Array materials = s.ReadM2Array(ms); // Blending modes / render flags.
M2Array bone_lookup_table = s.ReadM2Array(ms);
M2Array texture_lookup_table = s.ReadM2Array(ms);
M2Array tex_unit_lookup_table = s.ReadM2Array(ms); // ≥ Cata: unused
M2Array transparency_lookup_table = s.ReadM2Array(ms);
M2Array texture_transforms_lookup_table = s.ReadM2Array(ms);
m2Data.bounding_box = s.ReadBoundingBox(ms); // min/max( [1].z, 2.0277779f ) - 0.16f seems to be the maximum camera height
float bounding_sphere_radius = s.ReadFloat(ms); // detail doodad draw dist = clamp (bounding_sphere_radius * detailDoodadDensityFade * detailDoodadDist, …)
BoundingBox collision_box = s.ReadBoundingBox(ms);
float collision_sphere_radius = s.ReadFloat(ms);
M2Array collision_triangles = s.ReadM2Array(ms);
M2Array collision_vertices = s.ReadM2Array(ms);
M2Array collision_normals = s.ReadM2Array(ms);
M2Array attachments = s.ReadM2Array(ms); // position of equipped weapons or effects
M2Array attachment_lookup_table = s.ReadM2Array(ms);
M2Array events = s.ReadM2Array(ms); // Used for playing sounds when dying and a lot else.
M2Array lights = s.ReadM2Array(ms); // Lights are mainly used in loginscreens but in wands and some doodads too.
M2Array cameras = s.ReadM2Array(ms); // The cameras are present in most models for having a model in the character tab.
M2Array camera_lookup_table = s.ReadM2Array(ms);
M2Array ribbon_emitters = s.ReadM2Array(ms); // Things swirling around. See the CoT-entrance for light-trails.
M2Array particle_emitters = s.ReadM2Array(ms);
// Name //
ms.Position = name.offset + md20position;
for (int n = 0; n < name.size; n++)
{
m2Data.name += Convert.ToChar(ms.ReadByte());
}
// Bones //
ms.Position = bones.offset + md20position;
M2TrackBase[] translationM2track = new M2TrackBase[bones.size];
M2TrackBase[] rotationM22track = new M2TrackBase[bones.size];
M2TrackBase[] scaleM22track = new M2TrackBase[bones.size];
for (int cb = 0; cb < bones.size; cb++)
{
M2CompBone m2CompBone = new M2CompBone();
m2CompBone.key_bone_id = s.ReadLong(ms); // Back-reference to the key bone lookup table. -1 if this is no key bone.
m2CompBone.flags = s.ReadUint32(ms);
m2CompBone.parent_bone = s.ReadShort(ms);
m2CompBone.submesh_id = s.ReadUint16(ms);
m2CompBone.uDistToFurthDesc = s.ReadUint16(ms);
m2CompBone.uZRatioOfChain = s.ReadUint16(ms);
translationM2track[cb] = s.ReadM2Track(ms);
rotationM22track[cb] = s.ReadM2Track(ms);
scaleM22track[cb] = s.ReadM2Track(ms);
Vector3 pivotRaw = new Vector3(s.ReadFloat(ms) / Settings.worldScale, s.ReadFloat(ms) / Settings.worldScale, s.ReadFloat(ms) / Settings.worldScale);
m2CompBone.pivot = new Vector3(-pivotRaw.x, pivotRaw.z, -pivotRaw.y);
m2Data.m2CompBone.Add(m2CompBone);
}
// Animations //
int numberOfAnimations = 0;
for (int ab = 0; ab < bones.size; ab++)
{
List <Animation_Vector3> bone_position_animations = new List <Animation_Vector3>();
List <Animation_Quaternion> bone_rotation_animations = new List <Animation_Quaternion>();
List <Animation_Vector3> bone_scale_animations = new List <Animation_Vector3>();
// Position //
int numberOfPositionAnimations = translationM2track[ab].Timestamps.size;
if (numberOfAnimations < numberOfPositionAnimations)
{
numberOfAnimations = numberOfPositionAnimations;
}
for (int at = 0; at < numberOfPositionAnimations; at++)
{
Animation bone_animation = new Animation();
Animation_Vector3 positions = new Animation_Vector3();
// Timestamps //
List <int> timeStamps = new List <int>();
ms.Position = translationM2track[ab].Timestamps.offset + md20position;
M2Array m2AnimationOffset = s.ReadM2Array(ms);
ms.Position = m2AnimationOffset.offset;
for (int t = 0; t < m2AnimationOffset.size; t++)
{
timeStamps.Add(s.ReadLong(ms));
}
positions.timeStamps = timeStamps;
// Values //
List <Vector3> values = new List <Vector3>();
ms.Position = translationM2track[ab].Values.offset + md20position;
M2Array m2AnimationValues = s.ReadM2Array(ms);
ms.Position = m2AnimationValues.offset;
for (int t = 0; t < m2AnimationValues.size; t++)
{
Vector3 rawPosition = new Vector3(s.ReadFloat(ms) / Settings.worldScale, s.ReadFloat(ms) / Settings.worldScale, s.ReadFloat(ms) / Settings.worldScale);
values.Add(new Vector3(-rawPosition.x, rawPosition.z, -rawPosition.y));
}
positions.values = values;
bone_position_animations.Add(positions);
}
// Rotation //
int numberOfRotationAnimations = rotationM22track[ab].Timestamps.size;
if (numberOfAnimations < numberOfRotationAnimations)
{
numberOfAnimations = numberOfRotationAnimations;
}
for (int ar = 0; ar < numberOfRotationAnimations; ar++)
{
Animation_Quaternion rotations = new Animation_Quaternion();
// Timestamps //
List <int> timeStamps = new List <int>();
ms.Position = rotationM22track[ab].Timestamps.offset + md20position;
M2Array m2AnimationOffset = s.ReadM2Array(ms);
ms.Position = m2AnimationOffset.offset;
for (int t = 0; t < m2AnimationOffset.size; t++)
{
timeStamps.Add(s.ReadLong(ms));
}
rotations.timeStamps = timeStamps;
// Values //
List <Quaternion> values = new List <Quaternion>();
ms.Position = rotationM22track[ab].Values.offset + md20position;
M2Array m2AnimationValues = s.ReadM2Array(ms);
ms.Position = m2AnimationValues.offset;
for (int t = 0; t < m2AnimationValues.size; t++)
{
Quaternion rawRotation = s.ReadQuaternion16(ms);
values.Add(new Quaternion(rawRotation.x, rawRotation.y, rawRotation.z, rawRotation.w));
}
rotations.values = values;
bone_rotation_animations.Add(rotations);
}
// Scale //
int numberOfScaleAnimations = scaleM22track[ab].Timestamps.size;
if (numberOfAnimations < numberOfScaleAnimations)
{
numberOfAnimations = numberOfScaleAnimations;
}
for (int aS = 0; aS < numberOfScaleAnimations; aS++)
{
Animation_Vector3 scales = new Animation_Vector3();
// Timestamps //
List <int> timeStamps = new List <int>();
ms.Position = scaleM22track[ab].Timestamps.offset + md20position;
M2Array m2AnimationOffset = s.ReadM2Array(ms);
ms.Position = m2AnimationOffset.offset;
for (int t = 0; t < m2AnimationOffset.size; t++)
{
timeStamps.Add(s.ReadLong(ms));
}
scales.timeStamps = timeStamps;
// Values //
List <Vector3> values = new List <Vector3>();
ms.Position = scaleM22track[ab].Values.offset + md20position;
M2Array m2AnimationValues = s.ReadM2Array(ms);
ms.Position = m2AnimationValues.offset;
for (int t = 0; t < m2AnimationValues.size; t++)
{
Vector3 rawScale = new Vector3(s.ReadFloat(ms) / Settings.worldScale, s.ReadFloat(ms) / Settings.worldScale, s.ReadFloat(ms) / Settings.worldScale);
values.Add(new Vector3(-rawScale.x, rawScale.z, -rawScale.y));
}
scales.values = values;
bone_scale_animations.Add(scales);
}
//Debug.Log(numberOfPositionAnimations + " " + numberOfRotationAnimations + " " + numberOfScaleAnimations);
m2Data.position_animations.Add(bone_position_animations);
m2Data.rotation_animations.Add(bone_rotation_animations);
m2Data.scale_animations.Add(bone_scale_animations);
}
m2Data.numberOfAnimations = numberOfAnimations;
// Bone Lookup Table //
ms.Position = bone_lookup_table.offset + md20position;
for (int blt = 0; blt < key_bone_lookup.size; blt++)
{
m2Data.bone_lookup_table.Add(s.ReadUint16(ms));
}
// Key-Bone Lookup //
ms.Position = key_bone_lookup.offset + md20position;
for (int kbl = 0; kbl < key_bone_lookup.size; kbl++)
{
m2Data.key_bone_lookup.Add(s.ReadShort(ms));
}
// Vertices //
ms.Position = vertices.offset + md20position;
m2Data.meshData = new MeshData();
for (int v = 0; v < vertices.size; v++)
{
Vector3 rawPosition = new Vector3(s.ReadFloat(ms) / Settings.worldScale, s.ReadFloat(ms) / Settings.worldScale, s.ReadFloat(ms) / Settings.worldScale);
m2Data.meshData.pos.Add(new Vector3(-rawPosition.x, rawPosition.z, -rawPosition.y));
m2Data.meshData.bone_weights.Add(new float[] { ms.ReadByte() / 255.0f, ms.ReadByte() / 255.0f, ms.ReadByte() / 255.0f, ms.ReadByte() / 255.0f });
m2Data.meshData.bone_indices.Add(new int[] { ms.ReadByte(), ms.ReadByte(), ms.ReadByte(), ms.ReadByte() });
//Debug.Log(m2Data.meshData.bone_indices[v][0] + " " + m2Data.meshData.bone_indices[v][1] + " " + m2Data.meshData.bone_indices[v][2] + " " + m2Data.meshData.bone_indices[v][3]);
Vector3 rawnormal = new Vector3(s.ReadFloat(ms) * Settings.worldScale, s.ReadFloat(ms) * Settings.worldScale, s.ReadFloat(ms) * Settings.worldScale);
m2Data.meshData.normal.Add(new Vector3(-rawnormal.x, rawnormal.z, -rawnormal.y));
m2Data.meshData.tex_coords.Add(new Vector2(s.ReadFloat(ms), s.ReadFloat(ms)));
m2Data.meshData.tex_coords2.Add(new Vector2(s.ReadFloat(ms), s.ReadFloat(ms)));
}
// Textures //
ms.Position = textures.offset + md20position;
for (int t = 0; t < textures.size; t++)
{
M2Texture m2Texture = new M2Texture();
m2Texture.type = s.ReadLong(ms);
m2Texture.flags = s.ReadLong(ms);
M2Array filename = s.ReadM2Array(ms);
// seek to filename and read //
long savePosition = ms.Position;
ms.Position = filename.offset + md20position;
string fileNameString = "";
for (int n = 0; n < filename.size; n++)
{
fileNameString += Convert.ToChar(ms.ReadByte());
}
ms.Position = savePosition;
string fileNameStringFix = fileNameString.TrimEnd(fileNameString[fileNameString.Length - 1]);
m2Texture.filename = fileNameStringFix;
Texture2Ddata texture2Ddata = new Texture2Ddata();
if (fileNameStringFix.Length > 1)
{
if (!LoadedBLPs.Contains(fileNameStringFix))
{
string extractedPath = Casc.GetFile(fileNameStringFix);
Stream stream = File.Open(extractedPath, FileMode.Open);
BLP blp = new BLP();
byte[] data = blp.GetUncompressed(stream, true);
BLPinfo info = blp.Info();
texture2Ddata.hasMipmaps = info.hasMipmaps;
texture2Ddata.width = info.width;
texture2Ddata.height = info.height;
texture2Ddata.textureFormat = info.textureFormat;
texture2Ddata.TextureData = data;
m2Texture.texture2Ddata = texture2Ddata;
stream.Close();
stream.Dispose();
stream = null;
LoadedBLPs.Add(fileNameString);
}
}
m2Data.m2Tex.Add(m2Texture);
}
// texture_lookup_table //
ms.Position = texture_lookup_table.offset + md20position;
for (int tl = 0; tl < texture_lookup_table.size; tl++)
{
m2Data.textureLookupTable.Add(s.ReadUint16(ms));
}
}