public void Write(IMetaValue value, string fileName)
{
using (var fileStream = new FileStream(fileName, FileMode.Create))
{
Write(value, fileStream);
}
}
public void Export(IMetaValue value, string xmlFileName)
{
using (var xmlFileStream = new FileStream(xmlFileName, FileMode.Create))
{
Export(value, xmlFileStream);
}
}
public void Write(IMetaValue value, Stream fileStream)
{
var resource = new ResourceFile_GTA5_pc <Meta_GTA5_pc>();
resource.Version = 2;
resource.ResourceData = Build(value);
resource.Save(fileStream);
}
public void Export(IMetaValue value, Stream xmlFileStream)
{
var strctureValue = (MetaStructure)value;
var writer = new XmlTextWriter(xmlFileStream, Encoding.UTF8);
writer.Formatting = Formatting.Indented;
writer.WriteStartDocument();
writer.WriteStartElement(GetNameForHash(strctureValue.info.StructureNameHash));
WriteStructureContentXml(strctureValue, writer);
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
}
public void Export(IMetaValue value, Stream xmlFileStream)
{
var strctureValue = (MetaStructure)value;
var writer = XmlWriter.Create(xmlFileStream, new XmlWriterSettings()
{
Indent = true, Encoding = Encoding.UTF8
});
writer.WriteStartDocument();
writer.WriteStartElement(GetNameForHash(strctureValue.info.StructureNameHash));
WriteStructureContentXml(strctureValue, writer);
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
}
public static void Serialize(this IMetaValue metaValue, Utf8JsonWriter jsonWriter)
{
if (jsonWriter == null)
{
throw new ArgumentNullException(nameof(jsonWriter));
}
if (metaValue == null)
{
jsonWriter.WriteNullValue();
return;
}
// metadata ?
switch (metaValue.Kind)
{
case MetaValueKind.MObject:
MetaObject metaObject = (MetaObject)metaValue;
metaObject.Serialize(jsonWriter);
break;
case MetaValueKind.MArray:
MetaArray metaArray = (MetaArray)metaValue;
metaArray.Serialize(jsonWriter);
break;
case MetaValueKind.MString:
MetaString metaString = (MetaString)metaValue;
jsonWriter.WriteStringValue(metaString.Value);
break;
case MetaValueKind.MBoolean:
MetaBoolean metaBoolean = (MetaBoolean)metaValue;
jsonWriter.WriteBooleanValue(metaBoolean.Value);
break;
case MetaValueKind.MInt32:
MetaInt32 metaInt32 = (MetaInt32)metaValue;
jsonWriter.WriteNumberValue(metaInt32.Value);
break;
}
}
public static string SerializeWithContextUri(this IMetaValue metaValue)
{
if (metaValue == null)
{
throw new ArgumentNullException(nameof(metaValue));
}
var options = new JsonWriterOptions
{
Indented = true
};
using (var stream = new MemoryStream())
{
using (var writer = new Utf8JsonWriter(stream, options))
{
metaValue.Serialize(writer);
}
return(Encoding.UTF8.GetString(stream.ToArray()));
}
}
public Meta_GTA5_pc Build(IMetaValue value)
{
MetaInitialize();
MetaBuildStructuresAndEnums();
var writer = new MetaDataWriter();
writer.SelectBlockByNameHash(((MetaStructure)value).info.StructureNameHash);
WriteStructure(writer, (MetaStructure)value);
for (int k = meta.StructureInfos.Count - 1; k >= 0; k--)
{
if (!usedStructureKeys.Contains(meta.StructureInfos[k].StructureKey))
{
meta.StructureInfos.RemoveAt(k);
}
}
meta.DataBlocks = new ResourceSimpleArray <DataBlock_GTA5_pc>();
foreach (var block in writer.Blocks)
{
var metaDataBlock = new DataBlock_GTA5_pc();
metaDataBlock.StructureNameHash = block.NameHash;
metaDataBlock.Data = StreamToResourceBytes(block.Stream);
meta.DataBlocks.Add(metaDataBlock);
}
for (int i = 0; i < meta.DataBlocks.Count; i++)
{
if (meta.DataBlocks[i].StructureNameHash == ((MetaStructure)value).info.StructureNameHash)
{
meta.RootBlockIndex = i + 1;
}
}
return(meta);
}
public void AssertValue(IMetaValue expectedValue, IMetaValue actualValue)
{
Assert.AreEqual(expectedValue.GetType(), actualValue.GetType());
if (expectedValue is MetaArray)
{
AssertArray((MetaArray)expectedValue, (MetaArray)actualValue);
}
else if (expectedValue is MetaArrayOfBytes)
{
AssertArrayOfBytes((MetaArrayOfBytes)expectedValue, (MetaArrayOfBytes)actualValue);
}
else if (expectedValue is MetaArrayOfChars)
{
AssertArrayOfChars((MetaArrayOfChars)expectedValue, (MetaArrayOfChars)actualValue);
}
else if (expectedValue is MetaBoolean)
{
AssertBoolean((MetaBoolean)expectedValue, (MetaBoolean)actualValue);
}
else if (expectedValue is MetaByte_A)
{
AssertByte((MetaByte_A)expectedValue, (MetaByte_A)actualValue);
}
else if (expectedValue is MetaByte_B)
{
AssertByte((MetaByte_B)expectedValue, (MetaByte_B)actualValue);
}
else if (expectedValue is MetaByte_Enum)
{
AssertByte((MetaByte_Enum)expectedValue, (MetaByte_Enum)actualValue);
}
else if (expectedValue is MetaCharPointer)
{
AssertCharPointer((MetaCharPointer)expectedValue, (MetaCharPointer)actualValue);
}
else if (expectedValue is MetaDataBlockPointer)
{
AssertDataBlockPointer((MetaDataBlockPointer)expectedValue, (MetaDataBlockPointer)actualValue);
}
else if (expectedValue is MetaFloat)
{
AssertFloat((MetaFloat)expectedValue, (MetaFloat)actualValue);
}
else if (expectedValue is MetaFloat4_XYZ)
{
AssertFloatVector((MetaFloat4_XYZ)expectedValue, (MetaFloat4_XYZ)actualValue);
}
else if (expectedValue is MetaFloat4_XYZW)
{
AssertFloatVector((MetaFloat4_XYZW)expectedValue, (MetaFloat4_XYZW)actualValue);
}
else if (expectedValue is MetaInt16_A)
{
AssertInt16((MetaInt16_A)expectedValue, (MetaInt16_A)actualValue);
}
else if (expectedValue is MetaInt16_B)
{
AssertInt16((MetaInt16_B)expectedValue, (MetaInt16_B)actualValue);
}
else if (expectedValue is MetaInt16_Enum)
{
AssertInt16((MetaInt16_Enum)expectedValue, (MetaInt16_Enum)actualValue);
}
else if (expectedValue is MetaInt32_A)
{
AssertInt32((MetaInt32_A)expectedValue, (MetaInt32_A)actualValue);
}
else if (expectedValue is MetaInt32_B)
{
AssertInt32((MetaInt32_B)expectedValue, (MetaInt32_B)actualValue);
}
else if (expectedValue is MetaInt32_Enum1)
{
AssertInt32((MetaInt32_Enum1)expectedValue, (MetaInt32_Enum1)actualValue);
}
else if (expectedValue is MetaInt32_Enum2)
{
AssertInt32((MetaInt32_Enum2)expectedValue, (MetaInt32_Enum2)actualValue);
}
else if (expectedValue is MetaInt32_Enum3)
{
AssertInt32((MetaInt32_Enum3)expectedValue, (MetaInt32_Enum3)actualValue);
}
else if (expectedValue is MetaInt32_Hash)
{
AssertInt32((MetaInt32_Hash)expectedValue, (MetaInt32_Hash)actualValue);
}
else if (expectedValue is MetaGeneric)
{
AssertPointer((MetaGeneric)expectedValue, (MetaGeneric)actualValue);
}
else if (expectedValue is MetaStructure)
{
AssertStructure((MetaStructure)expectedValue, (MetaStructure)actualValue);
}
else
{
Assert.Fail("Illegal values type.");
}
}
private void WriteStructureElementContentXml(IMetaValue value, XmlWriter writer)
{
switch (value)
{
case MetaArray:
{
var arrayValue = value as MetaArray;
if (arrayValue.Entries != null)
{
switch (arrayValue.info.DataType)
{
case StructureEntryDataType.UnsignedByte:
WriteByteArrayContent(writer, arrayValue);
break;
case StructureEntryDataType.UnsignedShort:
WriteShortArrayContent(writer, arrayValue);
break;
case StructureEntryDataType.UnsignedInt:
WriteIntArrayContent(writer, arrayValue);
break;
case StructureEntryDataType.Float:
WriteFloatArrayContent(writer, arrayValue);
break;
case StructureEntryDataType.Float_XYZ:
WriteFloatVectorArrayContent(writer, arrayValue);
break;
case StructureEntryDataType.Hash:
WriteHashArrayContent(writer, arrayValue);
break;
default:
WriteStructureArrayContent(writer, arrayValue);
break;
}
}
break;
}
case MetaBoolean:
writer.WriteAttributeValue(((MetaBoolean)value).Value);
break;
case MetaByte_A:
writer.WriteAttributeValue(((MetaByte_A)value).Value);
break;
case MetaByte_B:
writer.WriteAttributeValue(((MetaByte_B)value).Value);
break;
case MetaInt16_A:
writer.WriteAttributeValue(((MetaInt16_A)value).Value);
break;
case MetaInt16_B:
writer.WriteAttributeValue(((MetaInt16_B)value).Value);
break;
case MetaInt32_A:
writer.WriteAttributeValue(((MetaInt32_A)value).Value);
break;
case MetaInt32_B:
writer.WriteAttributeValue(((MetaInt32_B)value).Value);
break;
case MetaFloat:
writer.WriteAttributeValue(((MetaFloat)value).Value);
break;
case MetaFloat4_XYZ:
WriteFloatXYZContent(writer, (MetaFloat4_XYZ)value);
break;
case MetaFloat4_XYZW:
WriteFloatXYZWContent(writer, (MetaFloat4_XYZW)value);
break;
case MetaByte_Enum:
WriteByteEnumContent(writer, (MetaByte_Enum)value);
break;
case MetaInt32_Enum1:
WriteIntEnumContent(writer, (MetaInt32_Enum1)value);
break;
case MetaInt16_Enum:
WriteShortFlagsContent(writer, (MetaInt16_Enum)value);
break;
case MetaInt32_Enum2:
WriteIntFlags1Content(writer, (MetaInt32_Enum2)value);
break;
case MetaInt32_Enum3:
WriteIntFlags2Content(writer, (MetaInt32_Enum3)value);
break;
case MetaArrayOfChars:
{
var stringValue = value as MetaArrayOfChars;
writer.WriteString(stringValue.Value);
break;
}
case MetaCharPointer:
{
var stringValue = value as MetaCharPointer;
writer.WriteString(stringValue.Value);
break;
}
case MetaGeneric:
{
var genericValue = value as MetaGeneric;
var val = (MetaStructure)genericValue.Value;
if (val != null)
{
var vbstrdata = val;
writer.WriteAttributeString("type", GetNameForHash(vbstrdata.info.StructureNameHash));
WriteStructureContentXml(vbstrdata, writer);
}
else
{
writer.WriteAttributeString("type", "NULL");
}
break;
}
case MetaArrayOfBytes:
{
var intValue = value as MetaArrayOfBytes;
var sb = new StringBuilder();
for (int i = 0; i < intValue.Value.Length; i++)
{
sb.Append(intValue.Value[i]);
if (i != intValue.Value.Length - 1)
{
sb.Append(' ');
}
}
writer.WriteString(sb.ToString());
break;
}
case MetaInt32_Hash:
{
var intValue = value as MetaInt32_Hash;
if (intValue.Value != 0)
{
writer.WriteString(GetNameForHash(intValue.Value));
}
break;
}
case MetaDataBlockPointer:
{
var longValue = value as MetaDataBlockPointer;
if (longValue.Data != null)
{
writer.WriteString(ByteArrayToString(longValue.Data));
}
break;
}
case MetaStructure:
{
var structureValue = value as MetaStructure;
WriteStructureContentXml(structureValue, writer);
break;
}
default:
break;
}
}
private void WriteStructureElementContentXml(IMetaValue value, XmlTextWriter writer)
{
if (value is MetaArray)
{
var arrayValue = value as MetaArray;
if (arrayValue.Entries != null)
{
if (arrayValue.info.DataType == StructureEntryDataType.UnsignedByte)
{
WriteByteArrayContent(writer, arrayValue);
}
else if (arrayValue.info.DataType == StructureEntryDataType.UnsignedShort)
{
WriteShortArrayContent(writer, arrayValue);
}
else if (arrayValue.info.DataType == StructureEntryDataType.UnsignedInt)
{
WriteIntArrayContent(writer, arrayValue);
}
else if (arrayValue.info.DataType == StructureEntryDataType.Float)
{
WriteFloatArrayContent(writer, arrayValue);
}
else if (arrayValue.info.DataType == StructureEntryDataType.Float_XYZ)
{
WriteFloatVectorArrayContent(writer, arrayValue);
}
else if (arrayValue.info.DataType == StructureEntryDataType.Hash)
{
WriteHashArrayContent(writer, arrayValue);
}
else
{
foreach (var k in arrayValue.Entries)
{
writer.WriteStartElement("Item");
if (k is MetaStructure)
{
WriteStructureContentXml(k as MetaStructure, writer);
}
else
{
WriteStructureElementContentXml(k, writer);
}
writer.WriteEndElement();
}
}
}
}
if (value is MetaBoolean)
{
var booleanValue = value as MetaBoolean;
WriteBooleanContent(writer, booleanValue);
}
if (value is MetaByte_A)
{
var byteValue = value as MetaByte_A;
WriteSignedByteContent(writer, byteValue);
}
if (value is MetaByte_B)
{
var byteValue = value as MetaByte_B;
WriteUnsignedByteContent(writer, byteValue);
}
if (value is MetaInt16_A)
{
var shortValue = value as MetaInt16_A;
WriteSignedShortContent(writer, shortValue);
}
if (value is MetaInt16_B)
{
var shortValue = value as MetaInt16_B;
WriteUnsignedShortContent(writer, shortValue);
}
if (value is MetaInt32_A)
{
var intValue = value as MetaInt32_A;
WriteSignedIntContent(writer, intValue);
}
if (value is MetaInt32_B)
{
var intValue = value as MetaInt32_B;
WriteUnsignedIntContent(writer, intValue);
}
if (value is MetaFloat)
{
var floatValue = value as MetaFloat;
WriteFloatContent(writer, floatValue);
}
if (value is MetaFloat4_XYZ)
{
var floatVectorValue = value as MetaFloat4_XYZ;
WriteFloatXYZContent(writer, floatVectorValue);
}
if (value is MetaFloat4_XYZW)
{
var floatVectorValue = value as MetaFloat4_XYZW;
WriteFloatXYZWContent(writer, floatVectorValue);
}
if (value is MetaByte_Enum)
{
WriteByteEnumContent(writer, (MetaByte_Enum)value);
}
if (value is MetaInt32_Enum1)
{
WriteIntEnumContent(writer, (MetaInt32_Enum1)value);
}
if (value is MetaInt16_Enum)
{
WriteShortFlagsContent(writer, (MetaInt16_Enum)value);
}
if (value is MetaInt32_Enum2)
{
WriteIntFlags1Content(writer, (MetaInt32_Enum2)value);
}
if (value is MetaInt32_Enum3)
{
WriteIntFlags2Content(writer, (MetaInt32_Enum3)value);
}
if (value is MetaArrayOfChars)
{
var stringValue = value as MetaArrayOfChars;
writer.WriteString(stringValue.Value);
}
if (value is MetaCharPointer)
{
var stringValue = value as MetaCharPointer;
writer.WriteString(stringValue.Value);
}
if (value is MetaGeneric)
{
var genericValue = value as MetaGeneric;
var val = (MetaStructure)genericValue.Value;
if (val != null)
{
var vbstrdata = val;
writer.WriteAttributeString("type", GetNameForHash(vbstrdata.info.StructureNameHash));
WriteStructureContentXml(vbstrdata, writer);
}
else
{
writer.WriteAttributeString("type", "NULL");
}
}
if (value is MetaArrayOfBytes)
{
var intValue = value as MetaArrayOfBytes;
var sb = new StringBuilder();
for (int i = 0; i < intValue.Value.Length; i++)
{
sb.Append(intValue.Value[i].ToString());
if (i != intValue.Value.Length - 1)
{
sb.Append(" ");
}
}
writer.WriteString(sb.ToString());
}
if (value is MetaInt32_Hash)
{
var intValue = value as MetaInt32_Hash;
if (intValue.Value != 0)
{
writer.WriteString(GetNameForHash(intValue.Value));
}
}
if (value is MetaDataBlockPointer)
{
var longValue = value as MetaDataBlockPointer;
if (longValue.Data != null)
{
writer.WriteString(ByteArrayToString(longValue.Data));
}
}
if (value is MetaStructure)
{
var structureValue = value as MetaStructure;
WriteStructureContentXml(structureValue, writer);
}
}
public MetaFile Build(IMetaValue value)
{
MetaInitialize();
MetaBuildStructuresAndEnums();
var writer = new MetaDataWriter();
writer.SelectBlockByNameHash(((MetaStructure)value).info.StructureNameHash);
WriteStructure(writer, (MetaStructure)value);
for (int k = meta.StructureInfos.Count - 1; k >= 0; k--)
{
if (!usedStructureKeys.Contains(meta.StructureInfos[k].StructureKey))
{
meta.StructureInfos.RemoveAt(k);
}
}
// TODO: refactor this hacky way to remove unused EnumInfos
for (int e = meta.EnumInfos.Count - 1; e >= 0; e--)
{
bool required = false;
for (int s = 0; s < meta.StructureInfos.Count; s++)
{
var entries = meta.StructureInfos[s].Entries;
foreach (var entry in entries)
{
if (entry.ReferenceKey == meta.EnumInfos[e].EnumNameHash)
{
required = true;
break;
}
}
if (required)
{
break;
}
}
if (!required)
{
meta.EnumInfos.RemoveAt(e);
}
}
meta.DataBlocks = new ResourceSimpleArray <DataBlock>();
foreach (var block in writer.Blocks)
{
var metaDataBlock = new DataBlock();
metaDataBlock.StructureNameHash = block.NameHash;
metaDataBlock.Data = StreamToResourceBytes(block.Stream);
meta.DataBlocks.Add(metaDataBlock);
}
for (int i = 0; i < meta.DataBlocks.Count; i++)
{
if (meta.DataBlocks[i].StructureNameHash == ((MetaStructure)value).info.StructureNameHash)
{
meta.RootBlockIndex = i + 1;
}
}
return(meta);
}
