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