private static XmlNode GetEntryNode(XmlNodeList nodes, StructureEntryInfo entry)
{
foreach (XmlNode node in nodes)
{
if (GetHash(node.Name) == (MetaName)entry.EntryNameHash)
{
return(node);
}
}
return(null);
}
private static MetaStructure MakeStructureWithSimpleData()
{
var structureWithSimpleTypesInfo = new StructureInfo();
var structureWithSimpleTypes = new MetaStructure(null, structureWithSimpleTypesInfo);
structureWithSimpleTypes.Values = new Dictionary <int, IMetaValue>();
structureWithSimpleTypes.Values.Add(unchecked ((int)0x36C55540), new MetaBoolean(false));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x707975FF), new MetaBoolean(true));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x96142337), new MetaByte_A(-128));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xD4D9059D), new MetaByte_A(-127));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x710D0955), new MetaByte_A(126));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x860ACDD8), new MetaByte_A(127));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xCDFD7789), new MetaByte_B(0));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x7DCCF225), new MetaByte_B(1));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xA0AB9B78), new MetaByte_B(254));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x3A223898), new MetaByte_B(255));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x2F07F270), new MetaInt16_A(-32768));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x83E5053E), new MetaInt16_A(-32767));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x86F3BC1E), new MetaInt16_A(32766));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x2C916F02), new MetaInt16_A(32767));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x1972DD39), new MetaInt16_B(0));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x1433E9A2), new MetaInt16_B(1));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xABF22E97), new MetaInt16_B(65534));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xCAD920FA), new MetaInt16_B(65535));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x96AA9C22), new MetaInt32_A(-2147483648));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xBE498F77), new MetaInt32_A(-2147483647));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xDEA66123), new MetaInt32_A(2147483646));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xA7A347FE), new MetaInt32_A(2147483647));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x5940A2C4), new MetaInt32_B(0));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x7AE8E34B), new MetaInt32_B(1));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x48758F24), new MetaInt32_B(4294967294));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x2DCCF53B), new MetaInt32_B(4294967295));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x7C6BAA24), new MetaFloat(1.2f));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xC81C39E6), new MetaFloat(12.0f));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xC599B2B0), new MetaFloat4_XYZ(1.2f, 3.4f, 5.6f));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xA2B4F045), new MetaFloat4_XYZ(12.0f, 34.0f, 56.0f));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xE0B18333), new MetaFloat4_XYZW(1.2f, 3.4f, 5.6f, 7.8f));
structureWithSimpleTypes.Values.Add(unchecked ((int)0xA7E3D660), new MetaFloat4_XYZW(12.0f, 34.0f, 56.0f, 78.0f));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x3B8AF0C2), new MetaArrayOfBytes(new byte[] { 0, 1, 254, 255 }));
var charinfo = new StructureEntryInfo();
charinfo.ReferenceKey = 64;
structureWithSimpleTypes.Values.Add(unchecked ((int)0x8FF34AB5), new MetaArrayOfChars(charinfo, "A String"));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x17525AB1), new MetaInt32_Hash(unchecked ((int)0xF63A8BC0)));
structureWithSimpleTypes.Values.Add(unchecked ((int)0x10D59C62), new MetaInt32_Hash(0));
return(structureWithSimpleTypes);
}
private static string GetEnumString(MetaCont cont, StructureEntryInfo entry, int value)
{
var eName = (MetaName)entry.ReferenceKey;
var eInfo = cont.GetEnumInfo(eName);
if ((eInfo == null) || (eInfo.Entries == null))
{
return(value.ToString());
}
bool isFlags = (entry.DataType == StructureEntryDataType.IntFlags1) ||
(entry.DataType == StructureEntryDataType.IntFlags2);// ||
//(entry.DataType == StructureEntryDataType.ShortFlags);
if (isFlags)
{
StringBuilder sb = new StringBuilder();
foreach (var ev in eInfo.Entries)
{
var v = ev.EntryValue;
var m = 1 << v;
if ((value & m) > 0)
{
if (sb.Length > 0)
{
sb.Append(", ");
}
sb.Append(HashString((MetaName)ev.EntryNameHash));
}
}
return(sb.ToString());
}
else
{
foreach (var ev in eInfo.Entries)
{
if (ev.EntryValue == value)
{
return(HashString((MetaName)ev.EntryNameHash));
}
}
return(value.ToString()); //if we got here, there was no match...
}
}
private static void WriteNode(StringBuilder sb, int indent, MetaCont cont, int blockId, int offset, XmlTagMode tagMode = XmlTagMode.None, MetaName structName = 0, string metaName = "")
{
var block = cont.Meta.GetBlock(blockId);
if (block == null)
{
ErrorXml(sb, indent, "Couldn't find block " + blockId + "!");
return;
}
if (structName == 0)
{
structName = (MetaName)block.StructureNameHash;
}
var name = HashString(structName);
var data = Array.ConvertAll(block.Data.Data.ToArray(), e => (byte)e);
var structInfo = cont.GetStructureInfo(structName);
if (structInfo == null)
{
ErrorXml(sb, indent, "Couldn't find structure info " + name + "!");
return;
}
if (structInfo.Entries == null)
{
ErrorXml(sb, indent, "Couldn't find structure info entries for " + name + "!");
return;
}
switch (tagMode)
{
case XmlTagMode.Structure:
OpenTag(sb, indent, name, true, metaName);
break;
case XmlTagMode.Item:
OpenTag(sb, indent, "Item", true, metaName);
break;
case XmlTagMode.ItemAndType:
OpenTag(sb, indent, "Item type=\"" + name + "\"", true, metaName);
break;
}
var cind = indent + 1;
StructureEntryInfo arrEntry = new StructureEntryInfo();
for (int i = 0; i < structInfo.Entries.Count; i++)
{
var entry = structInfo.Entries[i];
if ((MetaName)entry.EntryNameHash == MetaName.ARRAYINFO)
{
arrEntry = entry;
continue;
}
var ename = HashString((MetaName)entry.EntryNameHash);
var eoffset = offset + entry.DataOffset;
switch (entry.DataType)
{
default:
ErrorXml(sb, cind, ename + ": Unexpected entry DataType: " + entry.DataType.ToString());
break;
case StructureEntryDataType.Array:
WriteArrayNode(sb, cind, cont, data, arrEntry, ename, eoffset);
break;
case StructureEntryDataType.ArrayOfBytes:
WriteParsedArrayOfBytesNode(sb, cind, data, ename, eoffset, entry, arrEntry);
break;
case StructureEntryDataType.ArrayOfChars:
OpenTag(sb, cind, ename, false);
uint charArrLen = (uint)entry.ReferenceKey;
for (int n = 0; n < charArrLen; n++)
{
var bidx = eoffset + n;
if ((bidx >= 0) && (bidx < data.Length))
{
byte b = data[bidx];
if (b == 0)
{
break;
}
sb.Append((char)b);
}
}
CloseTag(sb, 0, ename);
break;
case StructureEntryDataType.Boolean:
var boolVal = BitConverter.ToBoolean(data, eoffset);
ValueTag(sb, cind, ename, boolVal?"true":"false");
break;
case StructureEntryDataType.ByteEnum:
var byteEnumVal = data[eoffset];
ValueTag(sb, cind, ename, byteEnumVal.ToString());
break;
case StructureEntryDataType.CharPointer:
var charPtr = MetaUtils.ConvertData <CharPointer>(data, eoffset);
string charStr = MetaUtils.GetString(cont.Meta, charPtr);
OneLineTag(sb, cind, ename, charStr);
break;
case StructureEntryDataType.DataBlockPointer:
OpenTag(sb, cind, ename);
var dataPtr = MetaUtils.ConvertData <DataBlockPointer>(data, eoffset);
ErrorXml(sb, cind + 1, "DataBlockPointer not currently supported here!"); //TODO! ymap occludeModels vertices data is this type!
CloseTag(sb, cind, ename);
break;
case StructureEntryDataType.Float:
var floatVal = BitConverter.ToSingle(data, eoffset);
ValueTag(sb, cind, ename, floatVal.ToString(CultureInfo.InvariantCulture));
break;
case StructureEntryDataType.Float_XYZ:
var v3 = MetaUtils.ConvertData <Vector3>(data, eoffset);
SelfClosingTag(sb, cind, ename + " x=\"" + v3.X.ToString(CultureInfo.InvariantCulture) + "\" y=\"" + v3.Y.ToString(CultureInfo.InvariantCulture) + "\" z=\"" + v3.Z.ToString(CultureInfo.InvariantCulture) + "\"");
break;
case StructureEntryDataType.Float_XYZW:
var v4 = MetaUtils.ConvertData <Vector4>(data, eoffset);
SelfClosingTag(sb, cind, ename + " x=\"" + v4.X.ToString(CultureInfo.InvariantCulture) + "\" y=\"" + v4.Y.ToString(CultureInfo.InvariantCulture) + "\" z=\"" + v4.Z.ToString(CultureInfo.InvariantCulture) + "\" w=\"" + v4.W.ToString(CultureInfo.InvariantCulture) + "\"");
break;
case StructureEntryDataType.Hash:
var hashVal = (MetaName)MetaUtils.ConvertData <uint>(data, eoffset);
var hashStr = HashString(hashVal);
StringTag(sb, cind, ename, hashStr);
break;
case StructureEntryDataType.IntEnum:
var intEnumVal = BitConverter.ToInt32(data, eoffset);
var intEnumStr = GetEnumString(cont, entry, intEnumVal);
StringTag(sb, cind, ename, intEnumStr);
break;
case StructureEntryDataType.IntFlags1:
var intFlags1Val = BitConverter.ToInt32(data, eoffset);
var intFlags1Str = GetEnumString(cont, entry, intFlags1Val);
StringTag(sb, cind, ename, intFlags1Str);
break;
case StructureEntryDataType.IntFlags2:
var intFlags2Val = BitConverter.ToInt32(data, eoffset);
var intFlags2Str = GetEnumString(cont, entry, intFlags2Val);
StringTag(sb, cind, ename, intFlags2Str);
break;
case StructureEntryDataType.ShortFlags:
var shortFlagsVal = BitConverter.ToInt16(data, eoffset);
var shortFlagsStr = shortFlagsVal.ToString(); // GetEnumString(cont, entry, shortFlagsVal);
StringTag(sb, cind, ename, shortFlagsStr);
break;
case StructureEntryDataType.SignedByte:
sbyte sbyteVal = (sbyte)data[eoffset];
ValueTag(sb, cind, ename, sbyteVal.ToString());
break;
case StructureEntryDataType.SignedInt:
var intVal = BitConverter.ToInt32(data, eoffset);
ValueTag(sb, cind, ename, intVal.ToString());
break;
case StructureEntryDataType.SignedShort:
var shortVal = BitConverter.ToInt16(data, eoffset);
ValueTag(sb, cind, ename, shortVal.ToString());
break;
case StructureEntryDataType.Structure:
OpenTag(sb, cind, ename);
WriteNode(sb, cind, cont, blockId, eoffset, XmlTagMode.None, (MetaName)entry.ReferenceKey);
CloseTag(sb, cind, ename);
break;
case StructureEntryDataType.StructurePointer:
OpenTag(sb, cind, ename);
ErrorXml(sb, cind + 1, "StructurePointer not supported here! Tell dexy!");
CloseTag(sb, cind, ename);
break;
case StructureEntryDataType.UnsignedByte:
var byteVal = data[eoffset];
ValueTag(sb, cind, ename, byteVal.ToString());
//ValueTag(sb, cind, ename, "0x" + byteVal.ToString("X").PadLeft(2, '0'));
break;
case StructureEntryDataType.UnsignedInt:
var uintVal = BitConverter.ToUInt32(data, eoffset);
switch ((MetaName)entry.EntryNameHash)
{
default:
ValueTag(sb, cind, ename, uintVal.ToString());
break;
case MetaName.color:
ValueTag(sb, cind, ename, "0x" + uintVal.ToString("X").PadLeft(8, '0'));
break;
}
break;
case StructureEntryDataType.UnsignedShort:
var ushortVal = BitConverter.ToUInt16(data, eoffset);
ValueTag(sb, cind, ename, ushortVal.ToString()); // "0x" + ushortVal.ToString("X").PadLeft(4, '0'));
break;
}
}
switch (tagMode)
{
case XmlTagMode.Structure:
CloseTag(sb, indent, name);
break;
case XmlTagMode.Item:
case XmlTagMode.ItemAndType:
CloseTag(sb, indent, "Item");
break;
}
}
private static void WriteParsedArrayOfBytesNode(StringBuilder sb, int indent, byte[] data, string ename, int eoffset, StructureEntryInfo entry, StructureEntryInfo arrEntry)
{
OpenTag(sb, indent, ename, false);
var byteArrLen = ((int)entry.ReferenceKey);
switch (arrEntry.DataType)
{
default:
for (int n = 0; n < byteArrLen; n++)
{
var bidx = eoffset + n;
byte b = ((bidx >= 0) && (bidx < data.Length)) ? data[bidx] : (byte)0;
sb.Append(b.ToString("X").PadLeft(2, '0'));
}
break;
case StructureEntryDataType.SignedByte:
for (int n = 0; n < byteArrLen; n++)
{
var bidx = eoffset + n;
sbyte b = ((bidx >= 0) && (bidx < data.Length)) ? (sbyte)data[bidx] : (sbyte)0;
sb.Append(b.ToString()); //sb.Append(b.ToString("X").PadLeft(2, '0')); to show HEX values
if (n < byteArrLen - 1)
{
sb.Append(" ");
}
}
break;
case StructureEntryDataType.UnsignedByte:
for (int n = 0; n < byteArrLen; n++)
{
var bidx = eoffset + n;
byte b = ((bidx >= 0) && (bidx < data.Length)) ? data[bidx] : (byte)0;
sb.Append(b.ToString());
if (n < byteArrLen - 1)
{
sb.Append(" ");
}
}
break;
case StructureEntryDataType.SignedShort:
for (int n = 0; n < byteArrLen; n++)
{
var bidx = eoffset + n * 2;
short b = ((bidx >= 0) && (bidx < data.Length)) ? BitConverter.ToInt16(data, bidx) : (short)0;
sb.Append(b.ToString());
if (n < byteArrLen - 1)
{
sb.Append(" ");
}
}
break;
case StructureEntryDataType.UnsignedShort:
for (int n = 0; n < byteArrLen; n++)
{
var bidx = eoffset + n * 2;
ushort b = ((bidx >= 0) && (bidx < data.Length)) ? BitConverter.ToUInt16(data, bidx) : (ushort)0;
sb.Append(b.ToString());
if (n < byteArrLen - 1)
{
sb.Append(" ");
}
}
break;
case StructureEntryDataType.SignedInt:
for (int n = 0; n < byteArrLen; n++)
{
var bidx = eoffset + n * 4;
int b = ((bidx >= 0) && (bidx < data.Length)) ? BitConverter.ToInt32(data, bidx) : (int)0;
sb.Append(b.ToString());
if (n < byteArrLen - 1)
{
sb.Append(" ");
}
}
break;
case StructureEntryDataType.UnsignedInt:
for (int n = 0; n < byteArrLen; n++)
{
var bidx = eoffset + n * 4;
uint b = ((bidx >= 0) && (bidx < data.Length)) ? BitConverter.ToUInt32(data, bidx) : (uint)0;
sb.Append(b.ToString());
if (n < byteArrLen - 1)
{
sb.Append(" ");
}
}
break;
case StructureEntryDataType.Float:
for (int n = 0; n < byteArrLen; n++)
{
var bidx = eoffset + n * 4;
float b = ((bidx >= 0) && (bidx < data.Length)) ? BitConverter.ToSingle(data, bidx) : (float)0;
sb.Append(FloatUtil.ToString(b));
if (n < byteArrLen - 1)
{
sb.Append(" ");
}
}
break;
}
CloseTag(sb, 0, ename);
}
private static void WriteArrayNode(StringBuilder sb, int indent, MetaCont cont, byte[] data, StructureEntryInfo arrEntry, string ename, int eoffset)
{
int aCount = 0;
var aind = indent + 1;
string arrTag = ename;
switch (arrEntry.DataType)
{
default:
ErrorXml(sb, indent, ename + ": Unexpected array entry DataType: " + arrEntry.DataType.ToString());
break;
case StructureEntryDataType.Structure:
var arrStruc = MetaUtils.ConvertData <Array_Structure>(data, eoffset);
var aBlockId = (int)arrStruc.PointerDataId;
var aOffset = (int)arrStruc.PointerDataOffset;
aCount = arrStruc.Count1;
arrTag += " itemType=\"" + HashString((MetaName)arrEntry.ReferenceKey) + "\"";
if (aCount > 0)
{
OpenTag(sb, indent, arrTag);
var atyp = cont.GetStructureInfo((MetaName)arrEntry.ReferenceKey);
var aBlock = cont.Meta.GetBlock(aBlockId);
for (int n = 0; n < aCount; n++)
{
WriteNode(sb, aind, cont, aBlockId, aOffset, XmlTagMode.Item, (MetaName)arrEntry.ReferenceKey);
aOffset += atyp.StructureLength;
if ((n < (aCount - 1)) && (aBlock != null) && (aOffset >= aBlock.DataLength))
{
aOffset = 0;
aBlockId++;
aBlock = cont.Meta.GetBlock(aBlockId);
}
}
CloseTag(sb, indent, ename);
}
else
{
SelfClosingTag(sb, indent, arrTag);
}
break;
case StructureEntryDataType.StructurePointer:
var arrStrucP = MetaUtils.ConvertData <Array_StructurePointer>(data, eoffset);
var ptrArr = MetaUtils.GetPointerArray(cont.Meta, arrStrucP);
aCount = ptrArr?.Length ?? 0;
if (aCount > 0)
{
OpenTag(sb, indent, arrTag);
for (int n = 0; n < aCount; n++)
{
var ptr = ptrArr[n];
var offset = ptr.Offset;
WriteNode(sb, aind, cont, ptr.BlockID, offset, XmlTagMode.ItemAndType);
}
CloseTag(sb, indent, ename);
}
else
{
SelfClosingTag(sb, indent, arrTag);
}
break;
case StructureEntryDataType.UnsignedInt:
var arrUint = MetaUtils.ConvertData <Array_uint>(data, eoffset);
var uintArr = MetaUtils.ConvertDataArray <uint>(cont.Meta, arrUint.Pointer, arrUint.Count1);;
WriteRawArray(sb, uintArr, indent, ename, "uint");
break;
case StructureEntryDataType.UnsignedShort:
var arrUshort = MetaUtils.ConvertData <Array_ushort>(data, eoffset);
var ushortArr = MetaUtils.ConvertDataArray <ushort>(cont.Meta, arrUshort.Pointer, arrUshort.Count1);;
WriteRawArray(sb, ushortArr, indent, ename, "ushort");
break;
case StructureEntryDataType.UnsignedByte:
var arrUbyte = MetaUtils.ConvertData <Array_byte>(data, eoffset);
var byteArr = MetaUtils.ConvertDataArray <byte>(cont.Meta, arrUbyte.Pointer, arrUbyte.Count1);;
WriteRawArray(sb, byteArr, indent, ename, "byte");
break;
case StructureEntryDataType.Float:
var arrFloat = MetaUtils.ConvertData <Array_float>(data, eoffset);
var floatArr = MetaUtils.ConvertDataArray <float>(cont.Meta, arrFloat.Pointer, arrFloat.Count1);;
WriteRawArray(sb, floatArr, indent, ename, "float");
break;
case StructureEntryDataType.Float_XYZ:
var arrV3 = MetaUtils.ConvertData <Array_Vector3>(data, eoffset);
var v4Arr = MetaUtils.ConvertDataArray <Vector4>(cont.Meta, arrV3.Pointer, arrV3.Count1);
WriteItemArray(sb, v4Arr, indent, ename, "Vector3/4", FormatVector4);
break;
case StructureEntryDataType.CharPointer:
ErrorXml(sb, indent, "CharPointer ARRAY not supported here!");
break;
case StructureEntryDataType.DataBlockPointer:
ErrorXml(sb, indent, "DataBlockPointer ARRAY not supported here!");
break;
case StructureEntryDataType.Hash:
var arrHash = MetaUtils.ConvertData <Array_uint>(data, eoffset);
var uintArr2 = MetaUtils.ConvertDataArray <uint>(cont.Meta, arrHash.Pointer, arrHash.Count1);
var hashArr = Array.ConvertAll(uintArr2, e => (MetaName)e);
WriteItemArray(sb, hashArr, indent, ename, "Hash", FormatHash);
break;
}
}
static string GenerateStructureDefiniton(StructureInfo def)
{
var sb = new StringBuilder();
var childStructures = new List <int>();
var structureName = GetSafeName(def.StructureNameHash, def.StructureKey);
var structureKeyName = GetString(def.StructureKey);
int unusedCount = 0;
long offset = 0;
StructureEntryInfo prevEntry = null;
var sbc = new StringBuilder();
var sbcp = new StringBuilder();
var sbcb = new StringBuilder();
sbc.AppendLine("using System.Collections.Generic;");
sbc.AppendLine("using System.Linq;");
sbc.AppendLine("using SharpDX;");
sbc.AppendLine("using RageLib.Resources.GTA5.PC.Meta;\n");
sbc.AppendLine("namespace RageLib.GTA5.ResourceWrappers.PC.Meta.Structures");
sbc.AppendLine("{");
sbc.AppendFormat("\tpublic class M{0} : MetaStructureWrapper<{0}>\n", structureName);
sbc.AppendLine("\t{");
sbc.AppendFormat("\t\tpublic static MetaName _MetaName = {0};\n", GetMetaNameString(def.StructureNameHash));
sbc.AppendLine("\t\tpublic MetaFile Meta;");
sb.AppendFormat("\t[StructLayout(LayoutKind.Sequential)] public struct {0} // {1} bytes, Key:{2}\n", structureName, def.StructureLength, structureKeyName);
sb.AppendLine("\t{");
for (int i = 0; i < def.Entries.Count; i++)
{
var entry = def.Entries[i];
var entryName = GetSafeName(entry.EntryNameHash, entry.ReferenceKey);
var entryNameUpper = char.ToUpper(entryName[0]) + entryName.Substring(1);
EnumInfo matchingEnum = null;
foreach (var ei in EnumInfos)
{
if (entry.ReferenceKey == ei.EnumNameHash)
{
matchingEnum = ei;
StructureEnums[def].Add(matchingEnum);
break;
}
}
var sc = StructureChildren[def];
if (prevEntry == null || entry.DataOffset > offset)
{
long remaining = entry.DataOffset - offset;
while (remaining > 0)
{
if (remaining % 4 == 0)
{
sb.AppendFormat("\t\tpublic {0} {1}; // {2}\n", "uint", "Unused" + (unusedCount++), offset, 4);
offset += 4;
remaining -= 4;
}
else if (remaining % 2 == 0)
{
sb.AppendFormat("\t\tpublic {0} {1}; // {2}\n", "short", "Unused" + (unusedCount++), offset, 2);
offset += 2;
remaining -= 2;
}
else
{
sb.AppendFormat("\t\tpublic {0} {1}; // {2}\n", "byte", "Unused" + (unusedCount++), offset, 1);
offset += 1;
remaining -= 1;
}
}
}
if (entry.DataType == StructureEntryDataType.Array)
{
var structEntry = def.Entries[entry.ReferenceTypeIndex];
var entryTypeString = (matchingEnum == null) ? GetCSharpTypeName(structEntry.DataType) : GetSafeName(matchingEnum.EnumNameHash, matchingEnum.EnumKey);
var CSharpTypeName = GetCSharpTypeName(structEntry.DataType);
long structureSize = GetStructureSize(structEntry.ReferenceKey);
if (structEntry.ReferenceKey != 0 && !sc.Contains(structEntry.ReferenceKey))
{
sc.Add(structEntry.ReferenceKey);
}
sb.AppendFormat("\t\tpublic Array_{0} {1}; // {2} Key: {3}\n", GetCSharpTypeName(structEntry.DataType), entryName, entry.DataOffset, GetString(structEntry.ReferenceKey));
if (CSharpTypeName == "Structure" && structureSize != -1)
{
childStructures.Add(structEntry.ReferenceKey);
sbc.AppendFormat("\t\tpublic List<M{0}> {1};\n", GetSafeName(structEntry.ReferenceKey, structEntry.ReferenceKey), entryNameUpper);
sbcp.AppendFormat("\t\t\tvar {0} = MetaUtils.ConvertDataArray<{1}>(meta, {2}.{0});\n", entryName, GetSafeName(structEntry.ReferenceKey, structEntry.ReferenceKey), structureName);
sbcp.AppendFormat("\t\t\tthis.{0} = {3}?.Select(e => {{ var msw = new M{1}(); msw.Parse(meta, e); return msw; }}).ToList();\n\n", entryNameUpper, GetSafeName(structEntry.ReferenceKey, structEntry.ReferenceKey), structureName, entryName);
sbcb.AppendFormat("\t\t\tif(this.{0} != null)\n", entryNameUpper);
sbcb.AppendFormat("\t\t\t\tthis.MetaStructure.{0} = mb.AddItemArrayPtr({1}, this.{2}.Select(e => {{ e.Build(mb); return e.MetaStructure; }}).ToArray());\n", entryName, GetMetaNameString(structEntry.ReferenceKey), entryNameUpper);
sbcb.AppendFormat("\t\t\tM{0}.AddEnumAndStructureInfo(mb); \n\n", GetSafeName(structEntry.ReferenceKey, structEntry.ReferenceKey));
}
else
{
sbc.AppendFormat("\t\tpublic Array_{0} {1};\n", GetCSharpTypeName(structEntry.DataType), entryNameUpper);
sbcp.AppendFormat("\t\t\t// this.{0} = {1}.{2};\n", entryNameUpper, structureName, entryName);
sbcb.AppendFormat("\t\t\t// this.MetaStructure.{0} = this.{1};\n", entryName, entryNameUpper);
}
offset += GetCSharpTypeSize(entry.DataType, entry.Length);
}
else
{
if (entry.DataType == StructureEntryDataType.Structure)
{
if (entry.EntryNameHash == 256)
{
}
else
{
long structureSize = GetStructureSize(entry.ReferenceKey);
var entryTypeString = (matchingEnum == null) ? GetCSharpTypeName(entry.DataType) : GetSafeName(matchingEnum.EnumNameHash, matchingEnum.EnumKey);
if (structureSize == -1)
{
var structEntry = def.Entries[entry.ReferenceTypeIndex];
var CSharpTypeName = GetCSharpTypeName(entry.DataType);
if (!sc.Contains(structEntry.ReferenceKey))
{
sc.Add(structEntry.ReferenceKey);
}
if (CSharpTypeName == "Structure")
{
childStructures.Add(entry.ReferenceKey);
}
sb.AppendFormat("\t\tpublic Array_{0} {1}; // {2} Key: {3}\n", CSharpTypeName, entryName, entry.DataOffset, GetString(entry.ReferenceKey));
sbc.AppendFormat("\t\tpublic Array_{0};\n", entryTypeString, entryNameUpper);
sbcp.AppendFormat("\t\t\t// this.{0} = {1}.{2};\n", entryNameUpper, structureName, entryName);
sbcb.AppendFormat("\t\t\t// this._{0}.{1} = this.{2};\n\n", structureName, entryName, entryNameUpper);
offset += GetCSharpTypeSize(entry.DataType, entry.Length);
}
else
{
if (!sc.Contains(entry.ReferenceKey))
{
sc.Add(entry.ReferenceKey);
}
childStructures.Add(entry.ReferenceKey);
sb.AppendFormat("\t\tpublic {0} {1}; // {2} Key: {3}\n", GetSafeName(entry.ReferenceKey, entry.ReferenceTypeIndex), entryName, entry.DataOffset, GetString(entry.ReferenceKey));
sbc.AppendFormat("\t\tpublic M{0} {1};\n", GetSafeName(entry.ReferenceKey, entry.ReferenceKey), entryNameUpper);
sbcp.AppendFormat("\t\t\tthis.{0} = new {1}();\n", entryNameUpper, GetSafeName(entry.ReferenceKey, entry.ReferenceKey));
sbcp.AppendFormat("\t\t\tthis.{0}.Parse(meta, {1}.{2});\n", entryNameUpper, structureName, entryName);
sbcb.AppendFormat("\t\t\tthis.{0}.Build(mb);\n", entryNameUpper);
sbcb.AppendFormat("\t\t\tthis.MetaStructure.{0} = this.{1}.MetaStructure;\n", entryName, entryNameUpper);
sbcb.AppendFormat("\t\t\tM{0}.AddEnumAndStructureInfo(mb); \n\n", GetSafeName(entry.ReferenceKey, entry.ReferenceKey));
offset += structureSize;
}
}
}
else if (entry.DataType == StructureEntryDataType.StructurePointer)
{
}
else
{
if (entry.EntryNameHash != 256)
{
var CSharpType = GetCSharpTypeName(entry.DataType);
if (CSharpType == "ArrayOfBytes")
{
CSharpType += Convert.ToString(entry.ReferenceKey);
}
if (matchingEnum != null)
{
CSharpType = GetSafeName(matchingEnum.EnumNameHash, matchingEnum.EnumKey);
}
sb.AppendFormat("\t\tpublic {0} {1}; // {2} Key: {3}\n", CSharpType, entryName, entry.DataOffset, GetString(entry.ReferenceKey));
if (CSharpType == "CharPointer")
{
sbc.AppendFormat("\t\tpublic string {1} = \"\";\n", CSharpType, entryNameUpper);
sbcp.AppendFormat("\t\t\tthis.{0} = MetaUtils.GetString(Meta, {1}.{2});\n", entryNameUpper, structureName, entryName);
sbcb.AppendFormat("\t\t\tthis.MetaStructure.{0} = mb.AddStringPtr(this.{1});\n", entryName, entryNameUpper);
}
else
{
sbc.AppendFormat("\t\tpublic {0} {1};\n", CSharpType, entryNameUpper);
sbcp.AppendFormat("\t\t\tthis.{0} = {1}.{2};\n", entryNameUpper, structureName, entryName);
sbcb.AppendFormat("\t\t\tthis.MetaStructure.{0} = this.{1};\n", entryName, entryNameUpper);
}
}
offset += GetCSharpTypeSize(entry.DataType, entry.Length);
}
}
prevEntry = entry;
}
long remaining2 = def.Length - offset;
while (remaining2 > 0)
{
if (remaining2 % 4 == 0)
{
sb.AppendFormat("\t\tpublic {0} {1}; // {2}\n", "uint", "Unused" + (unusedCount++), offset, 4);
offset += 4;
remaining2 -= 4;
}
else if (remaining2 % 2 == 0)
{
sb.AppendFormat("\t\tpublic {0} {1}; // {2}\n", "short", "Unused" + (unusedCount++), offset, 2);
offset += 2;
remaining2 -= 2;
}
else
{
sb.AppendFormat("\t\tpublic {0} {1}; // {2}\n", "byte", "Unused" + (unusedCount++), offset, 1);
offset += 1;
remaining2 -= 1;
}
}
sb.AppendLine("\t}\n\n");
sbc.AppendFormat("\n\t\tpublic M{0}()\n", structureName);
sbc.AppendLine("\t\t{");
sbc.AppendFormat("\t\t\tthis.MetaName = {0};\n", GetMetaNameString(def.StructureNameHash));
sbc.AppendFormat("\t\t\tthis.MetaStructure = new RageLib.Resources.GTA5.PC.Meta.{0}();\n", structureName);
sbc.AppendLine("\t\t}");
sbc.AppendLine();
sbc.AppendFormat("\t\tpublic static void AddEnumAndStructureInfo(MetaBuilder mb)\n", structureName);
sbc.AppendLine("\t\t{");
sbc.AppendFormat("\t\t\tvar enumInfos = MetaInfo.GetStructureEnumInfo(M{0}._MetaName);\n", structureName);
sbc.AppendLine();
sbc.AppendLine("\t\t\tfor (int i = 0; i < enumInfos.Length; i++)");
sbc.AppendLine("\t\t\t\tmb.AddEnumInfo((MetaName) enumInfos[i].EnumNameHash);");
sbc.AppendLine();
sbc.AppendFormat("\t\t\tmb.AddStructureInfo(M{0}._MetaName);\n", structureName);
for (int i = 0; i < childStructures.Count; i++)
{
sbc.AppendFormat("\t\t\tmb.AddStructureInfo({0});\n", GetMetaNameString(childStructures[i]));
}
sbc.AppendLine("\t\t}\n");
sbc.AppendLine();
sbc.AppendFormat("\t\tpublic override void Parse(MetaFile meta, RageLib.Resources.GTA5.PC.Meta.{0} {0})\n", structureName);
sbc.AppendLine("\t\t{");
sbc.AppendLine("\t\t\tthis.Meta = meta;");
sbc.AppendFormat("\t\t\tthis.MetaStructure = {0};\n", structureName);
sbc.AppendLine();
sbc.Append(sbcp);
sbc.AppendLine("\t\t}\n");
sbc.AppendLine("\t\tpublic override void Build(MetaBuilder mb, bool isRoot = false)");
sbc.AppendLine("\t\t{");
sbc.Append(sbcb);
sbc.AppendLine();
sbc.AppendFormat("\t\t\tM{0}.AddEnumAndStructureInfo(mb); \n\n", structureName);
sbc.AppendLine("\t\t\tif(isRoot)");
sbc.AppendLine("\t\t\t{");
sbc.AppendLine("\t\t\t\tmb.AddItem(this.MetaName, this.MetaStructure);\n");
sbc.AppendLine("\t\t\t\tthis.Meta = mb.GetMeta();");
sbc.AppendLine("\t\t\t}");
sbc.AppendLine("\t\t}");
sbc.AppendLine("\t}");
sbc.AppendLine("}");
File.WriteAllText(@".\MetaStructures\" + structureName + ".cs", sbc.ToString());
return(sb.ToString());
}
public MetaDataBlockPointer(StructureEntryInfo info, byte[] data)
{
this.info = info;
this.Data = data;
}
public MetaDataBlockPointer(StructureEntryInfo info)
{
this.info = info;
}
private static byte[] Traverse(XmlNode node, MetaBuilder mb, MetaName type = 0, bool isRoot = false)
{
if (type == 0)
{
type = (MetaName)(uint)GetHash(node.Name);
}
var infos = MetaInfo.GetStructureInfo(type);
if (infos != null)
{
byte[] data = new byte[infos.StructureLength];
var arrayResults = new ArrayResults();
arrayResults.Structures = new Dictionary <int, Array_Structure>();
arrayResults.StructurePointers = new Dictionary <int, Array_StructurePointer>();
arrayResults.UInts = new Dictionary <int, Array_uint>();
arrayResults.UShorts = new Dictionary <int, Array_ushort>();
arrayResults.UBytes = new Dictionary <int, Array_byte>();
arrayResults.Floats = new Dictionary <int, Array_float>();
arrayResults.Float_XYZs = new Dictionary <int, Array_Vector3>();
arrayResults.Hashes = new Dictionary <int, Array_uint>();
Array.Clear(data, 0, infos.StructureLength);
StructureEntryInfo arrEntry = new StructureEntryInfo();
if (isRoot)
{
mb.EnsureBlock(type);
}
for (int i = 0; i < infos.Entries.Count; i++)
{
var entry = infos.Entries[i];
var cnode = GetEntryNode(node.ChildNodes, entry);
if ((MetaName)entry.EntryNameHash == MetaName.ARRAYINFO)
{
arrEntry = entry;
continue;
}
if (cnode == null)
{
continue;
}
switch (entry.DataType)
{
case StructureEntryDataType.Array:
{
TraverseArray(cnode, mb, arrEntry, entry.DataOffset, arrayResults);
break;
}
case StructureEntryDataType.ArrayOfBytes:
{
GetParsedArrayOfBytes(cnode, data, entry, arrEntry);
break;
}
case StructureEntryDataType.ArrayOfChars:
{
int offset = entry.DataOffset;
var split = Split(cnode.InnerText, 2);
for (int j = 0; j < split.Length; j++)
{
byte val = Convert.ToByte(split[j], 16);
data[offset] = val;
offset += sizeof(byte);
}
break;
}
case StructureEntryDataType.Boolean:
{
byte val = (cnode.Attributes["value"].Value == "false") ? (byte)0 : (byte)1;
data[entry.DataOffset] = val;
break;
}
case StructureEntryDataType.ByteEnum:
{
byte val = Convert.ToByte(cnode.Attributes["value"].Value);
data[entry.DataOffset] = val;
break;
}
case StructureEntryDataType.CharPointer:
{
if (!string.IsNullOrEmpty(cnode.InnerText))
{
var ptr = mb.AddStringPtr(cnode.InnerText);
var val = MetaUtils.ConvertToBytes(ptr);
Buffer.BlockCopy(val, 0, data, entry.DataOffset, val.Length);
}
break;
}
case StructureEntryDataType.DataBlockPointer:
{
// TODO
break;
}
case StructureEntryDataType.Float:
{
float val = FloatUtil.Parse(cnode.Attributes["value"].Value);
Write(val, data, entry.DataOffset);
break;
}
case StructureEntryDataType.Float_XYZ:
{
float x = FloatUtil.Parse(cnode.Attributes["x"].Value);
float y = FloatUtil.Parse(cnode.Attributes["y"].Value);
float z = FloatUtil.Parse(cnode.Attributes["z"].Value);
Write(x, data, entry.DataOffset);
Write(y, data, entry.DataOffset + sizeof(float));
Write(z, data, entry.DataOffset + sizeof(float) * 2);
break;
}
case StructureEntryDataType.Float_XYZW:
{
float x = FloatUtil.Parse(cnode.Attributes["x"].Value);
float y = FloatUtil.Parse(cnode.Attributes["y"].Value);
float z = FloatUtil.Parse(cnode.Attributes["z"].Value);
float w = FloatUtil.Parse(cnode.Attributes["w"].Value);
Write(x, data, entry.DataOffset);
Write(y, data, entry.DataOffset + sizeof(float));
Write(z, data, entry.DataOffset + sizeof(float) * 2);
Write(w, data, entry.DataOffset + sizeof(float) * 3);
break;
}
case StructureEntryDataType.Hash:
{
var hash = GetHash(cnode.InnerText);
Write((uint)hash, data, entry.DataOffset);
break;
}
case StructureEntryDataType.IntEnum:
case StructureEntryDataType.IntFlags1:
case StructureEntryDataType.IntFlags2:
{
var _infos = MetaInfo.GetEnumInfo((MetaName)entry.ReferenceKey);
if (_infos != null)
{
mb.AddEnumInfo((MetaName)_infos.EnumNameHash);
}
int val = GetEnumInt((MetaName)entry.ReferenceKey, cnode.InnerText, entry.DataType);
Write(val, data, entry.DataOffset);
break;
}
case StructureEntryDataType.ShortFlags:
{
var _infos = MetaInfo.GetEnumInfo((MetaName)entry.ReferenceKey);
if (_infos != null)
{
mb.AddEnumInfo((MetaName)_infos.EnumNameHash);
}
// int val = GetEnumInt((MetaName)entry.ReferenceKey, cnode.InnerText, entry.DataType);
if (short.TryParse(cnode.InnerText, out short val))
{
Write(val, data, entry.DataOffset);
}
break;
}
case StructureEntryDataType.SignedByte:
{
var val = Convert.ToSByte(cnode.Attributes["value"].Value);
data[entry.DataOffset] = (byte)val;
break;
}
case StructureEntryDataType.SignedInt:
{
var val = Convert.ToInt32(cnode.Attributes["value"].Value);
Write(val, data, entry.DataOffset);
break;
}
case StructureEntryDataType.SignedShort:
{
var val = Convert.ToInt16(cnode.Attributes["value"].Value);
Write(val, data, entry.DataOffset);
break;
}
case StructureEntryDataType.Structure:
{
var struc = Traverse(cnode, mb, (MetaName)entry.ReferenceKey);
if (struc != null)
{
Buffer.BlockCopy(struc, 0, data, entry.DataOffset, struc.Length);
}
break;
}
case StructureEntryDataType.StructurePointer:
{
// TODO
break;
}
case StructureEntryDataType.UnsignedByte:
{
var val = Convert.ToByte(cnode.Attributes["value"].Value);
data[entry.DataOffset] = val;
break;
}
case StructureEntryDataType.UnsignedInt:
{
switch ((MetaName)entry.EntryNameHash)
{
case MetaName.color:
{
var val = Convert.ToUInt32(cnode.Attributes["value"].Value, 16);
Write(val, data, entry.DataOffset);
break;
}
default:
{
var val = Convert.ToUInt32(cnode.Attributes["value"].Value);
Write(val, data, entry.DataOffset);
break;
}
}
break;
}
case StructureEntryDataType.UnsignedShort:
{
var val = Convert.ToUInt16(cnode.Attributes["value"].Value);
Write(val, data, entry.DataOffset);
break;
}
default: break;
}
}
arrayResults.WriteArrays(data);
mb.AddStructureInfo((MetaName)infos.StructureNameHash);
if (isRoot)
{
mb.AddItem(type, data);
}
return(data);
}
return(null);
}
private static void TraverseArray(XmlNode node, MetaBuilder mb, StructureEntryInfo arrEntry, int offset, ArrayResults results)
{
switch (arrEntry.DataType)
{
case StructureEntryDataType.Structure:
{
results.Structures[offset] = TraverseArrayStructure(node, mb, (MetaName)arrEntry.ReferenceKey);
break;
}
case StructureEntryDataType.StructurePointer:
{
results.StructurePointers[offset] = TraverseArrayStructurePointer(node, mb);
break;
}
case StructureEntryDataType.UnsignedInt:
{
results.UInts[offset] = TraverseRawUIntArray(node, mb);
break;
}
case StructureEntryDataType.UnsignedShort:
{
results.UShorts[offset] = TraverseRawUShortArray(node, mb);
break;
}
case StructureEntryDataType.UnsignedByte:
{
results.UBytes[offset] = TraverseRawUByteArray(node, mb);
break;
}
case StructureEntryDataType.Float:
{
results.Floats[offset] = TraverseRawFloatArray(node, mb);
break;
}
case StructureEntryDataType.Float_XYZ:
{
results.Float_XYZs[offset] = TraverseRawVector3Array(node, mb);
break;
}
case StructureEntryDataType.Hash:
{
results.Hashes[offset] = TraverseHashArray(node, mb);
break;
}
case StructureEntryDataType.CharPointer:
{
// TODO
break;
}
case StructureEntryDataType.DataBlockPointer:
{
// TODO
break;
}
default: break;
}
}
private static void GetParsedArrayOfBytes(XmlNode node, byte[] data, StructureEntryInfo entry, StructureEntryInfo arrEntry)
{
int offset = entry.DataOffset;
var ns = NumberStyles.Any;
var ic = CultureInfo.InvariantCulture;
var sa = new[] { ' ' };
var so = StringSplitOptions.RemoveEmptyEntries;
var split = node.InnerText.Trim().Split(sa, so); //split = Split(node.InnerText, 2); to read as unsplitted HEX
switch (arrEntry.DataType)
{
default: //expecting hex string.
split = Split(node.InnerText, 2);
for (int j = 0; j < split.Length; j++)
{
byte val = Convert.ToByte(split[j], 16);
data[offset] = val;
offset += sizeof(byte);
}
break;
case StructureEntryDataType.SignedByte: //expecting space-separated array.
for (int j = 0; j < split.Length; j++)
{
sbyte val; // = Convert.ToSByte(split[j], 10);
if (sbyte.TryParse(split[j].Trim(), ns, ic, out val))
{
data[offset] = (byte)val;
offset += sizeof(sbyte);
}
}
break;
case StructureEntryDataType.UnsignedByte: //expecting space-separated array.
for (int j = 0; j < split.Length; j++)
{
byte val; // = Convert.ToByte(split[j], 10);
if (byte.TryParse(split[j].Trim(), ns, ic, out val))
{
data[offset] = val;
offset += sizeof(byte);
}
}
break;
case StructureEntryDataType.SignedShort: //expecting space-separated array.
for (int j = 0; j < split.Length; j++)
{
short val; // = Convert.ToInt16(split[j], 10);
if (short.TryParse(split[j].Trim(), ns, ic, out val))
{
Write(val, data, offset);
offset += sizeof(short);
}
}
break;
case StructureEntryDataType.UnsignedShort: //expecting space-separated array.
for (int j = 0; j < split.Length; j++)
{
ushort val; // = Convert.ToUInt16(split[j], 10);
if (ushort.TryParse(split[j].Trim(), ns, ic, out val))
{
Write(val, data, offset);
offset += sizeof(ushort);
}
}
break;
case StructureEntryDataType.SignedInt: //expecting space-separated array.
for (int j = 0; j < split.Length; j++)
{
int val; // = Convert.ToInt32(split[j], 10);
if (int.TryParse(split[j].Trim(), ns, ic, out val))
{
Write(val, data, offset);
offset += sizeof(int);
}
}
break;
case StructureEntryDataType.UnsignedInt: //expecting space-separated array.
for (int j = 0; j < split.Length; j++)
{
uint val; // = Convert.ToUInt32(split[j], 10);
if (uint.TryParse(split[j].Trim(), ns, ic, out val))
{
Write(val, data, offset);
offset += sizeof(uint);
}
}
break;
case StructureEntryDataType.Float: //expecting space-separated array.
for (int j = 0; j < split.Length; j++)
{
float val; // = FloatUtil.Parse(split[j]);
if (FloatUtil.TryParse(split[j].Trim(), out val))
{
Write(val, data, offset);
offset += sizeof(float);
}
}
break;
}
}
public MetaArrayOfChars(StructureEntryInfo inf, string value)
{
this.info = inf;
this.Value = value;
}
public MetaArrayOfChars(StructureEntryInfo info)
{
this.info = info;
}
private void MetaBuildStructureInfos(MetaInformationXml xmlInfo)
{
meta.StructureInfos = new ResourceSimpleArray <StructureInfo>();
foreach (var xmlStructureInfo in xmlInfo.Structures)
{
var structureInfo = new StructureInfo();
structureInfo.StructureNameHash = xmlStructureInfo.NameHash;
structureInfo.StructureKey = xmlStructureInfo.Key;
structureInfo.Unknown_8h = xmlStructureInfo.Unknown;
structureInfo.StructureLength = xmlStructureInfo.Length;
structureInfo.Entries = new ResourceSimpleArray <StructureEntryInfo>();
foreach (var xmlStructureEntryInfo in xmlStructureInfo.Entries)
{
var xmlArrayTypeStack = new Stack <MetaStructureArrayTypeXml>();
var xmlArrayType = xmlStructureEntryInfo.ArrayType;
while (xmlArrayType != null)
{
xmlArrayTypeStack.Push(xmlArrayType);
xmlArrayType = xmlArrayType.ArrayType;
}
while (xmlArrayTypeStack.Count > 0)
{
xmlArrayType = xmlArrayTypeStack.Pop();
var arrayStructureEntryInfo = new StructureEntryInfo();
arrayStructureEntryInfo.EntryNameHash = 0x100;
arrayStructureEntryInfo.DataOffset = 0;
arrayStructureEntryInfo.DataType = (StructureEntryDataType)xmlArrayType.Type;
arrayStructureEntryInfo.Unknown_9h = 0;
if (arrayStructureEntryInfo.DataType == StructureEntryDataType.Array)
{
arrayStructureEntryInfo.ReferenceTypeIndex = (short)(structureInfo.Entries.Count - 1);
}
else
{
arrayStructureEntryInfo.ReferenceTypeIndex = 0;
}
arrayStructureEntryInfo.ReferenceKey = xmlArrayType.TypeHash;
structureInfo.Entries.Add(arrayStructureEntryInfo);
}
var structureEntryInfo = new StructureEntryInfo();
structureEntryInfo.EntryNameHash = xmlStructureEntryInfo.NameHash;
structureEntryInfo.DataOffset = xmlStructureEntryInfo.Offset;
structureEntryInfo.DataType = (StructureEntryDataType)xmlStructureEntryInfo.Type;
structureEntryInfo.Unknown_9h = (byte)xmlStructureEntryInfo.Unknown;
if (structureEntryInfo.DataType == StructureEntryDataType.Array)
{
structureEntryInfo.ReferenceTypeIndex = (short)(structureInfo.Entries.Count - 1);
}
else
{
structureEntryInfo.ReferenceTypeIndex = 0;
}
structureEntryInfo.ReferenceKey = xmlStructureEntryInfo.TypeHash;
structureInfo.Entries.Add(structureEntryInfo);
}
meta.StructureInfos.Add(structureInfo);
}
}
public MetaStructure ParseStructure(XmlNode node, MetaStructureXml info)
{
MetaStructure resultStructure = null;
foreach (var x in strList)
{
if (x.StructureKey == info.Key)
{
resultStructure = new MetaStructure(null, x);
}
}
resultStructure.Values = new Dictionary <int, IMetaValue>();
foreach (var xmlEntry in info.Entries)
{
XmlNode xmlNode = null;
foreach (XmlNode x in node.ChildNodes)
{
var hash = GetHashForName(x.Name);
if (hash == xmlEntry.NameHash)
{
xmlNode = x;
}
}
StructureEntryInfo entryInfo = null;
foreach (var x in resultStructure.info.Entries)
{
if (x.EntryNameHash == xmlEntry.NameHash)
{
entryInfo = x;
}
}
var type = (StructureEntryDataType)xmlEntry.Type;
if (type == StructureEntryDataType.Array)
{
var arrayType = (StructureEntryDataType)xmlEntry.ArrayType.Type;
if (arrayType == StructureEntryDataType.StructurePointer)
{
MetaArray arrayValue = ReadPointerArray(xmlNode);
arrayValue.info = resultStructure.info.Entries[entryInfo.ReferenceTypeIndex];
resultStructure.Values.Add(xmlEntry.NameHash, arrayValue);
}
if (arrayType == StructureEntryDataType.Structure)
{
MetaArray arryVal = ReadStructureArray(xmlNode, xmlEntry.ArrayType.TypeHash);
arryVal.info = resultStructure.info.Entries[entryInfo.ReferenceTypeIndex];
resultStructure.Values.Add(xmlEntry.NameHash, arryVal);
}
if (arrayType == StructureEntryDataType.UnsignedByte)
{
MetaArray arryVal = ReadByteArray(xmlNode);
arryVal.info = resultStructure.info.Entries[entryInfo.ReferenceTypeIndex];
resultStructure.Values.Add(xmlEntry.NameHash, arryVal);
}
if (arrayType == StructureEntryDataType.UnsignedShort)
{
MetaArray arryVal = ReadShortArray(xmlNode);
arryVal.info = resultStructure.info.Entries[entryInfo.ReferenceTypeIndex];
resultStructure.Values.Add(xmlEntry.NameHash, arryVal);
}
if (arrayType == StructureEntryDataType.UnsignedInt)
{
MetaArray arryVal = ReadIntArray(xmlNode);
arryVal.info = resultStructure.info.Entries[entryInfo.ReferenceTypeIndex];
resultStructure.Values.Add(xmlEntry.NameHash, arryVal);
}
if (arrayType == StructureEntryDataType.Float)
{
MetaArray arryVal = ReadFloatArray(xmlNode);
arryVal.info = resultStructure.info.Entries[entryInfo.ReferenceTypeIndex];
resultStructure.Values.Add(xmlEntry.NameHash, arryVal);
}
if (arrayType == StructureEntryDataType.Float_XYZ)
{
MetaArray arryVal = ReadFloatVectorArray(xmlNode);
arryVal.info = resultStructure.info.Entries[entryInfo.ReferenceTypeIndex];
resultStructure.Values.Add(xmlEntry.NameHash, arryVal);
}
if (arrayType == StructureEntryDataType.Hash)
{
MetaArray arryVal = ReadHashArray(xmlNode);
arryVal.info = resultStructure.info.Entries[entryInfo.ReferenceTypeIndex];
resultStructure.Values.Add(xmlEntry.NameHash, arryVal);
}
}
if (type == StructureEntryDataType.Boolean)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadBoolean(xmlNode));
}
if (type == StructureEntryDataType.SignedByte)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadSignedByte(xmlNode));
}
if (type == StructureEntryDataType.UnsignedByte)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadUnsignedByte(xmlNode));
}
if (type == StructureEntryDataType.SignedShort)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadSignedShort(xmlNode));
}
if (type == StructureEntryDataType.UnsignedShort)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadUnsignedShort(xmlNode));
}
if (type == StructureEntryDataType.SignedInt)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadSignedInt(xmlNode));
}
if (type == StructureEntryDataType.UnsignedInt)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadUnsignedInt(xmlNode));
}
if (type == StructureEntryDataType.Float)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadFloat(xmlNode));
}
if (type == StructureEntryDataType.Float_XYZ)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadFloatXYZ(xmlNode));
}
if (type == StructureEntryDataType.Float_XYZW)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadFloatXYZW(xmlNode));
}
if (type == StructureEntryDataType.ByteEnum)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadByteEnum(xmlNode, entryInfo.ReferenceKey));
}
if (type == StructureEntryDataType.IntEnum)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadIntEnum(xmlNode, entryInfo.ReferenceKey));
}
if (type == StructureEntryDataType.ShortFlags)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadShortFlags(xmlNode, entryInfo.ReferenceKey));
}
if (type == StructureEntryDataType.IntFlags1)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadIntFlags1(xmlNode, entryInfo.ReferenceKey));
}
if (type == StructureEntryDataType.IntFlags2)
{
resultStructure.Values.Add(xmlEntry.NameHash, ReadIntFlags2(xmlNode, entryInfo.ReferenceKey));
}
if (type == StructureEntryDataType.ArrayOfBytes)
{
var byteArrayValue = new MetaArrayOfBytes();
byteArrayValue.Value = ByteFromString(xmlNode.InnerText);
resultStructure.Values.Add(xmlEntry.NameHash, byteArrayValue);
}
if (type == StructureEntryDataType.ArrayOfChars)
{
var charArrayValue = new MetaArrayOfChars(entryInfo);
charArrayValue.Value = xmlNode.InnerText;
resultStructure.Values.Add(xmlEntry.NameHash, charArrayValue);
}
if (type == StructureEntryDataType.Hash)
{
var hashValue = new MetaInt32_Hash();
if (xmlNode.InnerText.Trim().Length > 0)
{
hashValue.Value = GetHashForName(xmlNode.InnerText);
}
resultStructure.Values.Add(xmlEntry.NameHash, hashValue);
}
if (type == StructureEntryDataType.CharPointer)
{
var charPointerValue = new MetaCharPointer();
charPointerValue.Value = xmlNode.InnerText;
if (charPointerValue.Value.Equals(""))
{
charPointerValue.Value = null;
}
resultStructure.Values.Add(xmlEntry.NameHash, charPointerValue);
}
if (type == StructureEntryDataType.DataBlockPointer)
{
var dataBlockValue = new MetaDataBlockPointer(entryInfo);
dataBlockValue.Data = ByteFromString(xmlNode.InnerText);
if (dataBlockValue.Data.Length == 0)
{
dataBlockValue.Data = null;
}
resultStructure.Values.Add(xmlEntry.NameHash, dataBlockValue);
}
if (type == StructureEntryDataType.Structure)
{
var xmlInfo = FindAndCheckStructure(xmlEntry.TypeHash, xmlNode);
var structureValue = ParseStructure(xmlNode, xmlInfo);
resultStructure.Values.Add(xmlEntry.NameHash, structureValue);
}
}
return(resultStructure);
}
