public async Task ReadCompressedChunkHeader(ByteArrayReader reader, uint flags, int uncompressedSize, int compressedSize) {
if (flags > 0) {
Signature = reader.ReadUInt32();
if (Signature != Signatures.Signature) throw new Exception("Compressed Header Signature not found.");
BlockSize = reader.ReadInt32();
CompressedSize = reader.ReadInt32();
UncompressedSize = reader.ReadInt32();
Blocks.Clear();
int blockCount = (UncompressedSize + BlockSize - 1) / BlockSize;
for(int i = 0; i < blockCount; ++i) {
DomainCompressedChunkBlock block = new DomainCompressedChunkBlock();
block.ReadCompressedChunkBlock(reader);
Blocks.Add(block);
}
}
else {
Blocks = new List<DomainCompressedChunkBlock> {
new DomainCompressedChunkBlock {
UncompressedSize = uncompressedSize,
CompressedSize = compressedSize
}
};
}
foreach(DomainCompressedChunkBlock block in Blocks) await block.ReadCompressedChunkBlockData(reader);
}
public void ReadNameTableIndex(ByteArrayReader reader, DomainHeader header) {
Index = reader.ReadInt32();
Numeric = reader.ReadInt32();
if (Index < 0 || Index > header.NameTable.Count) throw new ArgumentOutOfRangeException(nameof(Index), $"Index ({Index:X8}) is out of range of the NameTable size.");
Name = Numeric > 0 ? $"{header.NameTable[Index].Name.String}_{Numeric - 1}" : $"{header.NameTable[Index].Name.String}";
}
public virtual async Task ReadCompressedChunk(ByteArrayReader reader) {
UncompressedOffset = reader.ReadInt32();
UncompressedSize = reader.ReadInt32();
CompressedOffset = reader.ReadInt32();
CompressedSize = reader.ReadInt32();
Header = new DomainCompressedChunkHeader();
await Header.ReadCompressedChunkHeader(reader.Branch(CompressedOffset), 1, UncompressedSize, CompressedSize);
}
public async Task ReadProperty(ByteArrayReader reader, DomainHeader header) {
await Task.Run(() => NameIndex.ReadNameTableIndex(reader, header));
if (NameIndex.Name == ObjectTypes.None.ToString()) return;
await Task.Run(() => TypeNameIndex.ReadNameTableIndex(reader, header));
Size = reader.ReadInt32();
ArrayIndex = reader.ReadInt32();
Value = propertyValueFactory();
await Value.ReadPropertyValue(reader, Size, header);
}
public override async Task ReadCompressedChunk(ByteArrayReader reader) {
BulkDataFlags = reader.ReadUInt32();
UncompressedSize = reader.ReadInt32();
CompressedSize = reader.ReadInt32();
CompressedOffset = reader.ReadInt32();
if (((BulkDataCompressionTypes)BulkDataFlags & NothingToDo) > 0) return;
Header = new DomainCompressedChunkHeader();
await Header.ReadCompressedChunkHeader(reader, BulkDataFlags, UncompressedSize, CompressedSize);
}
public override async Task ReadDomainObject(ByteArrayReader reader, DomainHeader header, DomainExportTableEntry export, bool skipProperties, bool skipParse) {
ArchetypeObjectReference = reader.ReadInt32();
ArchetypeObjectNameIndex = header.GetObjectTableEntry(ArchetypeObjectReference)?.NameTableIndex;
await base.ReadDomainObject(reader, header, export, skipProperties, skipParse);
}
public async Task ReadImportTableEntry(ByteArrayReader reader, DomainHeader header) {
await Task.Run(() => PackageNameIndex.ReadNameTableIndex(reader, header));
await Task.Run(() => TypeNameIndex.ReadNameTableIndex(reader, header));
OwnerReference = reader.ReadInt32();
await Task.Run(() => NameTableIndex.ReadNameTableIndex(reader, header));
}
public override async Task ReadDomainObject(ByteArrayReader reader, DomainHeader header, DomainExportTableEntry export, bool skipProperties, bool skipParse) {
await base.ReadDomainObject(reader, header, export, skipProperties, skipParse);
if (skipParse) return;
Unknown1 = await reader.ReadBytes(sizeof(uint) * 3);
CompressedChunkOffset = reader.ReadInt32();
}
internal async Task ReadExportTableEntry(ByteArrayReader reader, DomainHeader header) {
TypeReference = reader.ReadInt32();
ParentReference = reader.ReadInt32();
OwnerReference = reader.ReadInt32();
NameTableIndex.ReadNameTableIndex(reader, header);
ArchetypeReference = reader.ReadInt32();
FlagsHigh = reader.ReadUInt32();
FlagsLow = reader.ReadUInt32();
SerialDataSize = reader.ReadInt32();
SerialDataOffset = reader.ReadInt32();
ExportFlags = reader.ReadUInt32();
NetObjectCount = reader.ReadInt32();
Guid = await reader.ReadBytes(16);
Unknown1 = reader.ReadUInt32();
Unknown2 = await reader.ReadBytes(sizeof(uint) * NetObjectCount);
}
public override async Task ReadDomainObject(ByteArrayReader reader, DomainHeader header, DomainExportTableEntry export, bool skipProperties, bool skipParse) {
await base.ReadDomainObject(reader, header, export, skipProperties, skipParse);
if (skipParse) return;
MipMapsCount = reader.ReadInt32();
for(int i = 0; i < MipMapsCount; ++i) {
await ProcessCompressedBulkData(reader, async bulkChunk => {
DomainMipMap mip = new DomainMipMap {
Width = reader.ReadInt32(),
Height = reader.ReadInt32()
};
if (mip.Width >= 4 || mip.Height >= 4) mip.ImageData = (await bulkChunk.DecompressChunk(0))?.GetBytes();
MipMaps.Add(mip);
});
}
Guid = await reader.ReadBytes(16);
}
internal async Task ReadPropertyHeader(ByteArrayReader reader, DomainHeader header) {
TypeIndex = reader.ReadInt32();
do {
DomainProperty property = new DomainProperty();
await property.ReadProperty(reader, header);
Properties.Add(property);
if (property.NameIndex.Name == ObjectTypes.None.ToString()) break;
}
while(true);
}
public async Task ReadString(ByteArrayReader reader) {
Size = reader.ReadInt32();
if (Size == 0) {
String = String.Empty;
return;
}
if (Size < 0) {
int size = -Size * 2;
byte[] str = await reader.ReadBytes(size);
String = Encoding.Unicode.GetString(str);
}
else {
byte[] str = await reader.ReadBytes(Size - 1);
reader.Skip(1); // NULL Terminator
String = Encoding.ASCII.GetString(str);
}
}
public void ReadCompressedChunkBlock(ByteArrayReader reader) {
CompressedSize = reader.ReadInt32();
UncompressedSize = reader.ReadInt32();
}
public void ReadGenerationTableEntry(ByteArrayReader data) {
ExportTableCount = data.ReadInt32();
NameTableCount = data.ReadInt32();
NetObjectCount = data.ReadInt32();
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header) {
IntValue = await Task.Run(() => reader.ReadInt32());
}
