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 void ExpandReferences(DomainHeader header)
{
TypeReferenceNameIndex = header.GetObjectTableEntry(TypeReference)?.NameTableIndex;
ParentReferenceNameIndex = header.GetObjectTableEntry(ParentReference)?.NameTableIndex;
OwnerReferenceNameIndex = header.GetObjectTableEntry(OwnerReference)?.NameTableIndex;
ArchetypeReferenceNameIndex = header.GetObjectTableEntry(ArchetypeReference)?.NameTableIndex;
}
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 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;
}
bool done = false;
do
{
await ProcessCompressedBulkData(reader, async bulkChunk => {
byte[] ogg = (await bulkChunk.DecompressChunk(0))?.GetBytes();
if (ogg == null || ogg.Length == 0)
{
done = true;
return;
}
Sounds.Add(ogg);
});
} while (!done);
}
public virtual async Task ReadDomainObject(ByteArrayReader reader, DomainHeader header, DomainExportTableEntry export, bool skipProperties, bool skipParse) {
if (!skipProperties) await PropertyHeader.ReadPropertyHeader(reader, header);
AdditionalDataOffset = export.SerialDataOffset + reader.CurrentOffset;
AdditionalDataReader = await reader.Splice();
}
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);
}
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 async Task SaveUpkFile(DomainHeader Header, string Filename)
{
if (Header == null)
{
return;
}
foreach (DomainExportTableEntry export in Header.ExportTable.Where(export => export.DomainObject == null))
{
await export.ParseDomainObject(Header, false, false);
}
FileStream stream = new FileStream(Filename, FileMode.Create);
int headerSize = Header.GetBuilderSize();
ByteArrayWriter writer = ByteArrayWriter.CreateNew(headerSize);
await Header.WriteBuffer(writer, 0);
await stream.WriteAsync(writer.GetBytes(), 0, headerSize);
foreach (DomainExportTableEntry export in Header.ExportTable)
{
ByteArrayWriter objectWriter = await export.WriteObjectBuffer();
await stream.WriteAsync(objectWriter.GetBytes(), 0, objectWriter.Index);
}
await stream.FlushAsync();
stream.Close();
}
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 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 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();
}
private void onFileLoaded(FileLoadedMessage message)
{
header = message.File.Header;
imports = header.ImportTable.ToList();
exports = header.ExportTable.ToList();
Task.Run(() => buildObjectParents(resetToken())).FireAndForget();
}
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));
}
private void onFileLoaded(FileLoadedMessage message)
{
header = message.File.Header;
viewModel.ExportTableEntries = new ObservableCollection <ExportTableEntryViewEntity>(mapper.Map <IEnumerable <ExportTableEntryViewEntity> >(message.File.Header.ExportTable));
exportTableEntries.AddRange(message.File.Header.ExportTable);
viewModel.ExportTableEntries.ForEach(export => export.PropertyChanged += onExportTableEntryPropertyChanged);
}
public virtual async Task ReadDomainObject(ByteArrayReader reader, DomainHeader header, DomainExportTableEntry export, bool skipProperties, bool skipParse)
{
if (!skipProperties)
{
await PropertyHeader.ReadPropertyHeader(reader, header);
}
AdditionalDataOffset = export.SerialDataOffset + reader.CurrentOffset;
AdditionalDataReader = await reader.Splice();
}
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 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;
await ProcessCompressedBulkData(reader, async bulkChunk => {
byte[] bik = (await bulkChunk.DecompressChunk(0))?.GetBytes();
if (bik == null || bik.Length == 0) return;
Movie = bik;
});
}
private void onFileLoading(FileLoadingMessage message)
{
tokenSource?.Cancel();
viewModel.ObjectTree.Traverse(entity => entity.IsExport).ForEach(entity => entity.PropertyChanged -= onObjectTreeViewEntityPropertyChanged);
viewModel.ObjectTree.Clear();
header = null;
imports = null;
exports = null;
}
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();
}
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;
}
ObjectTableReference = reader.ReadInt32();
ObjectReferenceNameIndex = header.GetObjectTableEntry(ObjectTableReference)?.NameTableIndex;
}
public async Task <DomainHeader> LoadUpkFile(string Filename)
{
byte[] data = await Task.Run(() => File.ReadAllBytes(Filename));
ByteArrayReader reader = ByteArrayReader.CreateNew(data, 0);
DomainHeader header = new DomainHeader(reader)
{
FullFilename = Filename,
FileSize = data.LongLength
};
return(header);
}
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);
}
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);
}
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 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 ReadDomainObject(ByteArrayReader reader, DomainHeader header, DomainExportTableEntry export, bool skipProperties, bool skipParse)
{
await base.ReadDomainObject(reader, header, export, skipProperties, skipParse);
if (skipParse)
{
return;
}
FontBytes = (byte[])this.PropertyHeader.GetProperty("Buffer").FirstOrDefault().Value.PropertyValue;
FontLength = FontBytes.Take(4).ToArray();
Font = FontBytes.Skip(4).ToArray();
if (this.Modified)
{
Debug.WriteLine("hi1");
}
}
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;
}
await ProcessCompressedBulkData(reader, async bulkChunk => {
byte[] bik = (await bulkChunk.DecompressChunk(0))?.GetBytes();
if (bik == null || bik.Length == 0)
{
return;
}
Movie = bik;
});
}
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;
bool done = false;
do {
await ProcessCompressedBulkData(reader, async bulkChunk => {
byte[] ogg = (await bulkChunk.DecompressChunk(0))?.GetBytes();
if (ogg == null || ogg.Length == 0) {
done = true;
return;
}
Sounds.Add(ogg);
});
} while(!done);
}
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);
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header)
{
await stringValue.ReadString(reader);
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header) {
boolValue = await Task.Run(() => reader.ReadUInt32());
}
private async Task rebuildExports()
{
Dictionary <ExportedObjectViewEntity, List <ExportedObjectViewEntity> > filesToMod = viewModel.ExportsTree?.Traverse(e => Path.HasExtension(e.Filename) && e.IsChecked)
.GroupBy(e => e.Parent)
.ToDictionary(g => g.Key, g => g.ToList());
if (filesToMod == null || !filesToMod.Any())
{
return;
}
LoadProgressMessage message = new LoadProgressMessage {
Text = "Rebuilding...", Total = filesToMod.Count
};
foreach (KeyValuePair <ExportedObjectViewEntity, List <ExportedObjectViewEntity> > pair in filesToMod)
{
string gameFilename = $"{pair.Key.Filename.Replace(settings.ExportPath, null)}.upk";
DomainUpkFile file = allFiles.SingleOrDefault(f => f.GameFilename.Equals(gameFilename));
if (file == null)
{
continue;
}
DomainHeader header = await repository.LoadUpkFile(Path.Combine(settings.PathToGame, file.GameFilename));
await header.ReadHeaderAsync(null);
message.Current++;
foreach (ExportedObjectViewEntity entity in pair.Value)
{
DomainExportTableEntry export = header.ExportTable.SingleOrDefault(ex => ex.NameTableIndex.Name.Equals(Path.GetFileNameWithoutExtension(entity.Filename), StringComparison.CurrentCultureIgnoreCase));
if (export == null)
{
continue;
}
await export.ParseDomainObject(header, false, false);
int compressor = menuViewModel.IsCompressorClusterFit ? 0 : menuViewModel.IsCompressorRangeFit ? 1 : 2;
int errorMetric = menuViewModel.IsErrorMetricPerceptual ? 0 : 1;
FileFormat fileFormat = menuViewModel.IsDdsDefault ? FileFormat.Unknown :
menuViewModel.IsDdsFormat1 ? FileFormat.DXT1 :
menuViewModel.IsDdsFormat5 ? FileFormat.DXT5 : FileFormat.A8R8G8B8;
DdsSaveConfig config = new DdsSaveConfig(fileFormat, compressor, errorMetric, menuViewModel.IsWeightColorByAlpha, false);
await export.DomainObject.SetObject(entity.Filename, header.NameTable, config);
message.StatusText = entity.Filename;
messenger.Send(message);
}
string directory = Path.Combine(settings.PathToGame, Path.GetDirectoryName(file.GameFilename), "mod");
string filename = Path.Combine(directory, Path.GetFileName(file.GameFilename));
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
await repository.SaveUpkFile(header, filename);
DomainUpkFile upkFile = new DomainUpkFile {
GameFilename = filename.Replace(settings.PathToGame, null), FileSize = new FileInfo(filename).Length, Package = GetFileNameWithoutExtension(filename).ToLowerInvariant()
};
messenger.Send(new ModFileBuiltMessage {
UpkFile = upkFile
});
}
message.IsComplete = true;
message.StatusText = null;
messenger.Send(message);
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header) {
floatValue = await Task.Run(() => reader.ReadSingle());
}
public async Task ParseDomainObject(DomainHeader header, bool skipProperties, bool skipParse) {
DomainObject = objectTypeFactory();
await DomainObject.ReadDomainObject(DomainObjectReader, header, this, skipProperties, skipParse);
}
internal void ExpandReferences(DomainHeader header) {
TypeReferenceNameIndex = header.GetObjectTableEntry(TypeReference)?.NameTableIndex;
ParentReferenceNameIndex = header.GetObjectTableEntry(ParentReference)?.NameTableIndex;
OwnerReferenceNameIndex = header.GetObjectTableEntry(OwnerReference)?.NameTableIndex;
ArchetypeReferenceNameIndex = header.GetObjectTableEntry(ArchetypeReference)?.NameTableIndex;
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header)
{
boolValue = await Task.Run(() => reader.ReadUInt32());
}
public void ExpandReferences(DomainHeader header) {
OwnerReferenceNameIndex = header.GetObjectTableEntry(OwnerReference)?.NameTableIndex;
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header) {
await base.ReadPropertyValue(reader, size, header);
ObjectIndexName = header.GetObjectTableEntry(IntValue)?.NameTableIndex;
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header)
{
if (size == 8)
{
await base.ReadPropertyValue(reader, size, header);
}
else
{
byteValue = reader.ReadByte();
}
}
public virtual async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header)
{
DataReader = await reader.ReadByteArray(size);
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header) {
await stringValue.ReadString(reader);
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header)
{
floatValue = await Task.Run(() => reader.ReadSingle());
}
public virtual async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header) {
DataReader = await reader.ReadByteArray(size);
}
public void ExpandReferences(DomainHeader header)
{
OwnerReferenceNameIndex = header.GetObjectTableEntry(OwnerReference)?.NameTableIndex;
}
public async Task ParseDomainObject(DomainHeader header, bool skipProperties, bool skipParse)
{
DomainObject = objectTypeFactory();
await DomainObject.ReadDomainObject(DomainObjectReader, header, this, skipProperties, skipParse);
}
private async Task exportFileObjects(List <DomainUpkFile> files)
{
LoadProgressMessage message = new LoadProgressMessage {
Text = "Exporting...", Total = files.Count
};
int compressor = menuViewModel.IsCompressorClusterFit ? 0 : menuViewModel.IsCompressorRangeFit ? 1 : 2;
int errorMetric = menuViewModel.IsErrorMetricPerceptual ? 0 : 1;
DdsSaveConfig config = new DdsSaveConfig(FileFormat.Unknown, compressor, errorMetric, menuViewModel.IsWeightColorByAlpha, false);
foreach (DomainUpkFile file in files)
{
FileViewEntity fileEntity = viewModel.Files.Single(fe => fe.Id == file.Id);
string directory = Path.Combine(settings.ExportPath, Path.GetDirectoryName(file.GameFilename), Path.GetFileNameWithoutExtension(file.GameFilename));
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
DomainHeader header = file.Header;
if (header == null)
{
try {
header = await repository.LoadUpkFile(Path.Combine(settings.PathToGame, file.GameFilename));
await Task.Run(() => header.ReadHeaderAsync(null));
}
catch (Exception ex) {
messenger.Send(new ApplicationErrorMessage {
HeaderText = "Error Loading UPK File", ErrorMessage = $"Filename: {file.GameFilename}", Exception = ex
});
fileEntity.IsErrored = true;
continue;
}
}
message.Current++;
foreach (DomainExportTableEntry export in header.ExportTable)
{
if (export.DomainObject == null)
{
try {
await export.ParseDomainObject(header, false, false);
}
catch (Exception ex) {
messenger.Send(new ApplicationErrorMessage {
HeaderText = "Error Parsing Object", ErrorMessage = $"Filename: {header.Filename}\nExport Name: {export.NameTableIndex.Name}\nType: {export.TypeReferenceNameIndex.Name}", Exception = ex
});
fileEntity.IsErrored = true;
continue;
}
}
if (!export.DomainObject.IsExportable)
{
continue;
}
string filename = Path.Combine(directory, $"{export.NameTableIndex.Name}{export.DomainObject.FileExtension}");
message.StatusText = filename;
messenger.Send(message);
await export.DomainObject.SaveObject(filename, config);
}
file.Header = null;
}
message.IsComplete = true;
message.StatusText = null;
messenger.Send(message);
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header) {
await Task.Run(() => NameIndexValue.ReadNameTableIndex(reader, header));
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header)
{
await base.ReadPropertyValue(reader, size, header);
ObjectIndexName = header.GetObjectTableEntry(IntValue)?.NameTableIndex;
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header)
{
await Task.Run(() => NameIndexValue.ReadNameTableIndex(reader, header));
}
public override async Task ReadPropertyValue(ByteArrayReader reader, int size, DomainHeader header) {
if (size == 8) await base.ReadPropertyValue(reader, size, header);
else byteValue = reader.ReadByte();
}
