static public byte[] decompressData(Stream stream, long compressedSize)
{
uint compressedChunkSize = stream.ReadUInt32();
uint uncompressedChunkSize = stream.ReadUInt32();
byte[] data = new byte[uncompressedChunkSize];
uint blocksCount = (uncompressedChunkSize + maxBlockSize - 1) / maxBlockSize;
if ((compressedChunkSize + SizeOfChunk + SizeOfChunkBlock * blocksCount) != compressedSize)
{
throw new Exception("not match");
}
List <Package.ChunkBlock> blocks = new List <Package.ChunkBlock>();
for (uint b = 0; b < blocksCount; b++)
{
Package.ChunkBlock block = new Package.ChunkBlock();
block.comprSize = stream.ReadUInt32();
block.uncomprSize = stream.ReadUInt32();
blocks.Add(block);
}
for (int b = 0; b < blocks.Count; b++)
{
Package.ChunkBlock block = blocks[b];
block.compressedBuffer = stream.ReadToBuffer(blocks[b].comprSize);
block.uncompressedBuffer = new byte[maxBlockSize * 2];
blocks[b] = block;
}
Parallel.For(0, blocks.Count, b =>
{
uint dstLen = 0;
Package.ChunkBlock block = blocks[b];
dstLen = new ZlibHelper.Zlib().Decompress(block.compressedBuffer, block.comprSize, block.uncompressedBuffer);
if (dstLen != block.uncomprSize)
{
throw new Exception("Decompressed data size not expected!");
}
});
int dstPos = 0;
for (int b = 0; b < blocks.Count; b++)
{
Buffer.BlockCopy(blocks[b].uncompressedBuffer, 0, data, dstPos, (int)blocks[b].uncomprSize);
dstPos += (int)blocks[b].uncomprSize;
}
return(data);
}
public void PrepareListOfTextures(MeType gameId, bool ipc)
{
treeScan = null;
Misc.MD5FileEntry[] md5Entries;
if (gameId == MeType.ME1_TYPE)
{
pkgs = Program.tablePkgsME1;
md5Entries = Program.entriesME1;
}
else if (gameId == MeType.ME2_TYPE)
{
pkgs = Program.tablePkgsME2;
md5Entries = Program.entriesME2;
}
else
{
pkgs = Program.tablePkgsME3;
md5Entries = Program.entriesME3;
}
List <FoundTexture> textures = new List <FoundTexture>();
string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
Program.MAINEXENAME);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string filename = Path.Combine(path, "me" + (int)gameId + "map.bin");
if (ipc)
{
Console.WriteLine("[IPC]STAGE_CONTEXT STAGE_PRESCAN");
Console.Out.Flush();
}
if (!GameData.FullScanME1Game)
{
int count = GameData.packageFiles.Count;
for (int i = 0; i < count; i++)
{
if (GameData.packageFiles[i].Contains("_IT.") ||
GameData.packageFiles[i].Contains("_FR.") ||
GameData.packageFiles[i].Contains("_ES.") ||
GameData.packageFiles[i].Contains("_DE.") ||
GameData.packageFiles[i].Contains("_RA.") ||
GameData.packageFiles[i].Contains("_RU.") ||
GameData.packageFiles[i].Contains("_PLPC.") ||
GameData.packageFiles[i].Contains("_DEU.") ||
GameData.packageFiles[i].Contains("_FRA.") ||
GameData.packageFiles[i].Contains("_ITA.") ||
GameData.packageFiles[i].Contains("_POL."))
{
GameData.packageFiles.Add(GameData.packageFiles[i]);
GameData.packageFiles.RemoveAt(i--);
count--;
}
}
}
if (!generateBuiltinMapFiles && !GameData.FullScanME1Game)
{
List <string> addedFiles = new List <string>();
List <string> modifiedFiles = new List <string>();
loadTexturesMap(gameId, textures);
List <string> sortedFiles = new List <string>();
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
sortedFiles.Add(GameData.packageFiles[i].ToLowerInvariant());
}
sortedFiles.Sort();
for (int k = 0; k < textures.Count; k++)
{
for (int t = 0; t < textures[k].list.Count; t++)
{
string pkgPath = textures[k].list[t].path.ToLowerInvariant();
if (sortedFiles.BinarySearch(pkgPath) >= 0)
{
continue;
}
MatchedTexture f = textures[k].list[t];
f.path = "";
textures[k].list[t] = f;
}
}
if (ipc)
{
Console.WriteLine("[IPC]STAGE_CONTEXT STAGE_SCAN");
Console.Out.Flush();
}
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
int index = -1;
bool modified = true;
bool foundPkg = false;
string package = GameData.packageFiles[i].ToLowerInvariant();
long packageSize = new FileInfo(GameData.GamePath + GameData.packageFiles[i]).Length;
for (int p = 0; p < md5Entries.Length; p++)
{
if (package == md5Entries[p].path.ToLowerInvariant())
{
foundPkg = true;
if (packageSize == md5Entries[p].size)
{
modified = false;
break;
}
index = p;
}
}
if (foundPkg && modified)
{
modifiedFiles.Add(md5Entries[index].path);
}
else if (!foundPkg)
{
addedFiles.Add(GameData.packageFiles[i]);
}
}
int lastProgress = -1;
int totalPackages = modifiedFiles.Count + addedFiles.Count;
int currentPackage = 0;
if (ipc)
{
Console.WriteLine("[IPC]STAGE_WEIGHT STAGE_SCAN " +
string.Format("{0:0.000000}", ((float)totalPackages / GameData.packageFiles.Count)));
Console.Out.Flush();
}
for (int i = 0; i < modifiedFiles.Count; i++, currentPackage++)
{
if (ipc)
{
Console.WriteLine("[IPC]PROCESSING_FILE " + modifiedFiles[i]);
int newProgress = currentPackage * 100 / totalPackages;
if (lastProgress != newProgress)
{
Console.WriteLine("[IPC]TASK_PROGRESS " + newProgress);
lastProgress = newProgress;
}
Console.Out.Flush();
}
FindTextures(gameId, textures, modifiedFiles[i], true, ipc);
}
for (int i = 0; i < addedFiles.Count; i++, currentPackage++)
{
if (ipc)
{
Console.WriteLine("[IPC]PROCESSING_FILE " + addedFiles[i]);
int newProgress = currentPackage * 100 / totalPackages;
if (lastProgress != newProgress)
{
Console.WriteLine("[IPC]TASK_PROGRESS " + newProgress);
lastProgress = newProgress;
}
Console.Out.Flush();
}
FindTextures(gameId, textures, addedFiles[i], false, ipc);
}
for (int k = 0; k < textures.Count; k++)
{
bool found = false;
for (int t = 0; t < textures[k].list.Count; t++)
{
if (textures[k].list[t].path != "")
{
found = true;
break;
}
}
if (!found)
{
textures[k].list.Clear();
textures.Remove(textures[k]);
k--;
}
}
}
else
{
int lastProgress = -1;
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
if (ipc)
{
Console.WriteLine("[IPC]PROCESSING_FILE " + GameData.packageFiles[i]);
int newProgress = i * 100 / GameData.packageFiles.Count;
if (lastProgress != newProgress)
{
Console.WriteLine("[IPC]TASK_PROGRESS " + newProgress);
lastProgress = newProgress;
}
Console.Out.Flush();
}
FindTextures(gameId, textures, GameData.packageFiles[i], false, ipc);
}
}
if (gameId == MeType.ME1_TYPE)
{
for (int k = 0; k < textures.Count; k++)
{
for (int t = 0; t < textures[k].list.Count; t++)
{
uint mipmapOffset = textures[k].list[t].mipmapOffset;
if (textures[k].list[t].slave)
{
MatchedTexture slaveTexture = textures[k].list[t];
string basePkgName = slaveTexture.basePackageName;
if (basePkgName == Path.GetFileNameWithoutExtension(slaveTexture.path).ToUpperInvariant())
{
throw new Exception();
}
for (int j = 0; j < textures[k].list.Count; j++)
{
if (!textures[k].list[j].slave &&
textures[k].list[j].mipmapOffset == mipmapOffset &&
textures[k].list[j].packageName == basePkgName)
{
slaveTexture.linkToMaster = j;
textures[k].list[t] = slaveTexture;
break;
}
}
}
}
bool foundSlave = false;
for (int s = 0; s < textures[k].list.Count; s++)
{
if (textures[k].list[s].slave)
{
foundSlave = true;
break;
}
}
bool foundWeakSlave = false;
if (!foundSlave)
{
for (int w = 0; w < textures[k].list.Count; w++)
{
if (textures[k].list[w].weakSlave)
{
foundWeakSlave = true;
break;
}
}
}
if (foundWeakSlave)
{
List <MatchedTexture> texList = new List <MatchedTexture>();
for (int t = 0; t < textures[k].list.Count; t++)
{
MatchedTexture tex = textures[k].list[t];
if (tex.weakSlave)
{
texList.Add(tex);
}
else
{
texList.Insert(0, tex);
}
}
FoundTexture f = textures[k];
f.list = texList;
textures[k] = f;
if (textures[k].list[0].weakSlave)
{
continue;
}
for (int t = 0; t < textures[k].list.Count; t++)
{
if (textures[k].list[t].weakSlave)
{
MatchedTexture slaveTexture = textures[k].list[t];
string basePkgName = slaveTexture.basePackageName;
if (basePkgName == Path.GetFileNameWithoutExtension(slaveTexture.path).ToUpperInvariant())
{
throw new Exception();
}
for (int j = 0; j < textures[k].list.Count; j++)
{
if (!textures[k].list[j].weakSlave &&
textures[k].list[j].packageName == basePkgName)
{
slaveTexture.linkToMaster = j;
slaveTexture.slave = true;
textures[k].list[t] = slaveTexture;
break;
}
}
}
}
}
}
}
if (!GameData.FullScanME1Game)
{
GameData.packageFiles.Sort(new AsciiStringComparer());
}
if (File.Exists(filename))
{
File.Delete(filename);
}
using (FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write))
{
MemoryStream mem = new MemoryStream();
mem.WriteUInt32(textureMapBinTag);
mem.WriteUInt32(textureMapBinVersion);
mem.WriteInt32(textures.Count);
for (int i = 0; i < textures.Count; i++)
{
if (generateBuiltinMapFiles)
{
mem.WriteByte((byte)textures[i].name.Length);
}
else
{
mem.WriteInt32(textures[i].name.Length);
}
mem.WriteStringASCII(textures[i].name);
mem.WriteUInt32(textures[i].crc);
if (generateBuiltinMapFiles)
{
mem.WriteInt16((short)textures[i].width);
mem.WriteInt16((short)textures[i].height);
mem.WriteByte((byte)textures[i].pixfmt);
mem.WriteByte((byte)textures[i].flags);
mem.WriteInt16((short)textures[i].list.Count);
}
else
{
mem.WriteInt32(textures[i].list.Count);
}
for (int k = 0; k < textures[i].list.Count; k++)
{
mem.WriteInt32(textures[i].list[k].exportID);
if (generateBuiltinMapFiles)
{
if (GameData.gameType == MeType.ME1_TYPE)
{
mem.WriteInt16((short)textures[i].list[k].linkToMaster);
if (textures[i].list[k].linkToMaster != -1)
{
mem.WriteStringASCIINull(textures[i].list[k].basePackageName);
}
}
mem.WriteByte(textures[i].list[k].removeEmptyMips ? (byte)1 : (byte)0);
mem.WriteByte((byte)textures[i].list[k].numMips);
mem.WriteInt16((short)pkgs.IndexOf(textures[i].list[k].path));
}
else
{
mem.WriteInt32(textures[i].list[k].linkToMaster);
mem.WriteInt32(textures[i].list[k].path.Length);
mem.WriteStringASCII(textures[i].list[k].path);
}
}
}
if (!generateBuiltinMapFiles)
{
mem.WriteInt32(GameData.packageFiles.Count);
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
mem.WriteInt32(GameData.packageFiles[i].Length);
mem.WriteStringASCII(GameData.packageFiles[i]);
}
}
mem.SeekBegin();
if (generateBuiltinMapFiles)
{
fs.WriteUInt32(0x504D5443);
fs.WriteUInt32((uint)mem.Length);
byte[] compressed = new ZlibHelper.Zlib().Compress(mem.ToArray(), 9);
fs.WriteUInt32((uint)compressed.Length);
fs.WriteFromBuffer(compressed);
}
else
{
fs.WriteFromStream(mem, mem.Length);
}
}
treeScan = textures;
}
private bool generateBuiltinMapFiles = false; // change to true to enable map files generation
public string PrepareListOfTextures(TexExplorer texEplorer, CachePackageMgr cachePackageMgr,
MainWindow mainWindow, Installer installer, ref string log, bool force = false)
{
string errors = "";
treeScan = null;
List <FoundTexture> textures = new List <FoundTexture>();
string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
Assembly.GetExecutingAssembly().GetName().Name);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string filename = Path.Combine(path, "me" + (int)GameData.gameType + "map.bin");
if (force && File.Exists(filename))
{
File.Delete(filename);
}
if (File.Exists(filename))
{
using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.ReadWrite))
{
uint tag = fs.ReadUInt32();
uint version = fs.ReadUInt32();
if (tag != TexExplorer.textureMapBinTag || version != TexExplorer.textureMapBinVersion)
{
if (mainWindow != null)
{
MessageBox.Show("Detected wrong or old version of textures scan file!" +
"\n\nYou need to restore the game to vanilla state then reinstall optional DLC/PCC mods." +
"\n\nThen from the main menu, select 'Remove Textures Scan File' and start Texture Manager again.");
mainWindow.updateStatusLabel("");
mainWindow.updateStatusLabel2("");
texEplorer.Close();
}
fs.Close();
log += "Detected wrong or old version of textures scan file!" + Environment.NewLine;
log += "You need to restore the game to vanilla state then reinstall optional DLC/PCC mods." + Environment.NewLine;
log += "Then from the main menu, select 'Remove Textures Scan File' and start Texture Manager again." + Environment.NewLine;
return("Detected wrong or old version of textures scan file!" + Environment.NewLine +
"You need to restore the game to vanilla state then reinstall optional DLC/PCC mods." + Environment.NewLine +
"Then from the main menu, select 'Remove Textures Scan File' and start Texture Manager again." + Environment.NewLine);
}
uint countTexture = fs.ReadUInt32();
for (int i = 0; i < countTexture; i++)
{
FoundTexture texture = new FoundTexture();
int len = fs.ReadInt32();
texture.name = fs.ReadStringASCII(len);
texture.crc = fs.ReadUInt32();
uint countPackages = fs.ReadUInt32();
texture.list = new List <MatchedTexture>();
for (int k = 0; k < countPackages; k++)
{
MatchedTexture matched = new MatchedTexture();
matched.exportID = fs.ReadInt32();
matched.linkToMaster = fs.ReadInt32();
len = fs.ReadInt32();
matched.path = fs.ReadStringASCII(len);
texture.list.Add(matched);
}
textures.Add(texture);
}
List <string> packages = new List <string>();
int numPackages = fs.ReadInt32();
for (int i = 0; i < numPackages; i++)
{
int len = fs.ReadInt32();
string pkgPath = fs.ReadStringASCII(len);
pkgPath = GameData.GamePath + pkgPath;
packages.Add(pkgPath);
}
for (int i = 0; i < packages.Count; i++)
{
if (GameData.packageFiles.Find(s => s.Equals(packages[i], StringComparison.OrdinalIgnoreCase)) == null)
{
if (mainWindow != null)
{
MessageBox.Show("Detected removal of game files since last game data scan." +
"\n\nYou need to restore the game to vanilla state then reinstall optional DLC/PCC mods." +
"\n\nThen from the main menu, select 'Remove Textures Scan File' and start Texture Manager again.");
return("");
}
else if (!force)
{
errors += "Detected removal of game files since last game data scan." + Environment.NewLine + Environment.NewLine +
"You need to restore the game to vanilla state then reinstall optional DLC/PCC mods.";
return("");
}
}
}
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
if (packages.Find(s => s.Equals(GameData.packageFiles[i], StringComparison.OrdinalIgnoreCase)) == null)
{
if (mainWindow != null)
{
MessageBox.Show("Detected additional game files not present in latest game data scan." +
"\n\nYou need to restore the game to vanilla state then reinstall optional DLC/PCC mods." +
"\n\nThen from the main menu, select 'Remove Textures Scan File' and start Texture Manager again.");
return("");
}
else if (!force)
{
errors += "Detected additional game files not present in latest game data scan." + Environment.NewLine + Environment.NewLine +
"You need to restore the game to vanilla state then reinstall optional DLC/PCC mods.";
return("");
}
}
}
treeScan = textures;
if (mainWindow != null)
{
mainWindow.updateStatusLabel("");
mainWindow.updateStatusLabel2("");
}
return(errors);
}
}
if (File.Exists(filename))
{
File.Delete(filename);
}
if (mainWindow != null)
{
List <string> badMods = Misc.detectBrokenMod(GameData.gameType);
if (badMods.Count != 0)
{
errors = "";
for (int l = 0; l < badMods.Count; l++)
{
errors += badMods[l] + Environment.NewLine;
}
MessageBox.Show("Detected not compatible mods: \n\n" + errors);
return("");
}
}
if (MipMaps.checkGameDataModded(cachePackageMgr))
{
if (mainWindow != null)
{
MessageBox.Show("Detected modded game. Can not continue." +
"\n\nYou need to restore the game to vanilla state then reinstall optional DLC/PCC mods." +
"\n\nThen start Texture Manager again.");
return("");
}
else if (!force)
{
errors += "Detected modded game. Can not continue." + Environment.NewLine + Environment.NewLine +
"You need to restore the game to vanilla state then reinstall optional DLC/PCC mods.";
return("");
}
}
if (mainWindow != null)
{
DialogResult result = MessageBox.Show("Replacing textures and creating mods requires generating a map of the game's textures.\n" +
"You only need to do it once.\n\n" +
"IMPORTANT! Your game needs to be in vanilla state and have optional DLC/PCC mods installed.\n\n" +
"Are you sure you want to proceed?", "Textures mapping", MessageBoxButtons.YesNo);
if (result == DialogResult.No)
{
texEplorer.Close();
return("");
}
}
GameData.packageFiles.Sort();
if (mainWindow != null)
{
Misc.startTimer();
}
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
if (mainWindow != null)
{
mainWindow.updateStatusLabel("Finding textures in package " + (i + 1) + " of " + GameData.packageFiles.Count + " - " + GameData.packageFiles[i]);
}
if (installer != null)
{
installer.updateStatusScan("Scanning textures " + (i * 100 / GameData.packageFiles.Count) + "% ");
}
errors += FindTextures(textures, GameData.packageFiles[i], cachePackageMgr, ref log);
}
if (GameData.gameType == MeType.ME1_TYPE)
{
for (int k = 0; k < textures.Count; k++)
{
for (int t = 0; t < textures[k].list.Count; t++)
{
uint mipmapOffset = textures[k].list[t].mipmapOffset;
if (textures[k].list[t].slave)
{
MatchedTexture slaveTexture = textures[k].list[t];
string basePkgName = slaveTexture.basePackageName;
if (basePkgName == Path.GetFileNameWithoutExtension(slaveTexture.path).ToUpperInvariant())
{
throw new Exception();
}
bool found = false;
for (int j = 0; j < textures[k].list.Count; j++)
{
if (!textures[k].list[j].slave &&
textures[k].list[j].mipmapOffset == mipmapOffset &&
textures[k].list[j].packageName == basePkgName)
{
slaveTexture.linkToMaster = j;
textures[k].list[t] = slaveTexture;
found = true;
break;
}
}
if (!found)
{
log += "Error: not able match 'slave' texture: + " + textures[k].name + " to 'master'.";
}
}
}
if (!textures[k].list.Exists(s => s.slave) &&
textures[k].list.Exists(s => s.weakSlave))
{
List <MatchedTexture> texList = new List <MatchedTexture>();
for (int t = 0; t < textures[k].list.Count; t++)
{
MatchedTexture tex = textures[k].list[t];
if (tex.weakSlave)
{
texList.Add(tex);
}
else
{
texList.Insert(0, tex);
}
}
FoundTexture f = textures[k];
f.list = texList;
textures[k] = f;
if (textures[k].list[0].weakSlave)
{
continue;
}
for (int t = 0; t < textures[k].list.Count; t++)
{
if (textures[k].list[t].weakSlave)
{
MatchedTexture slaveTexture = textures[k].list[t];
string basePkgName = slaveTexture.basePackageName;
if (basePkgName == Path.GetFileNameWithoutExtension(slaveTexture.path).ToUpperInvariant())
{
throw new Exception();
}
for (int j = 0; j < textures[k].list.Count; j++)
{
if (!textures[k].list[j].weakSlave &&
textures[k].list[j].packageName == basePkgName)
{
slaveTexture.linkToMaster = j;
textures[k].list[t] = slaveTexture;
break;
}
}
}
}
}
}
}
using (FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write))
{
MemoryStream mem = new MemoryStream();
mem.WriteUInt32(TexExplorer.textureMapBinTag);
mem.WriteUInt32(TexExplorer.textureMapBinVersion);
mem.WriteInt32(textures.Count);
for (int i = 0; i < textures.Count; i++)
{
mem.WriteInt32(textures[i].name.Length);
mem.WriteStringASCII(textures[i].name);
mem.WriteUInt32(textures[i].crc);
if (generateBuiltinMapFiles)
{
mem.WriteInt32(textures[i].width);
mem.WriteInt32(textures[i].height);
mem.WriteInt32((int)textures[i].pixfmt);
mem.WriteInt32(textures[i].alphadxt1 ? 1 : 0);
mem.WriteInt32(textures[i].numMips);
}
mem.WriteInt32(textures[i].list.Count);
for (int k = 0; k < textures[i].list.Count; k++)
{
mem.WriteInt32(textures[i].list[k].exportID);
mem.WriteInt32(textures[i].list[k].linkToMaster);
mem.WriteInt32(textures[i].list[k].path.Length);
mem.WriteStringASCII(textures[i].list[k].path);
}
}
if (!generateBuiltinMapFiles)
{
mem.WriteInt32(GameData.packageFiles.Count);
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
string s = GameData.RelativeGameData(GameData.packageFiles[i]);
mem.WriteInt32(s.Length);
mem.WriteStringASCII(s);
}
}
mem.SeekBegin();
if (generateBuiltinMapFiles)
{
fs.WriteUInt32(0x504D5443);
fs.WriteUInt32((uint)mem.Length);
byte[] compressed = new ZlibHelper.Zlib().Compress(mem.ToArray(), 9);
fs.WriteUInt32((uint)compressed.Length);
fs.WriteFromBuffer(compressed);
}
else
{
fs.WriteFromStream(mem, mem.Length);
}
}
if (mainWindow != null)
{
if (!generateBuiltinMapFiles)
{
MipMaps mipmaps = new MipMaps();
if (GameData.gameType == MeType.ME1_TYPE)
{
errors += mipmaps.removeMipMapsME1(1, textures, null, mainWindow, null);
errors += mipmaps.removeMipMapsME1(2, textures, null, mainWindow, null);
}
else
{
errors += mipmaps.removeMipMapsME2ME3(textures, null, mainWindow, null);
}
}
var time = Misc.stopTimer();
mainWindow.updateStatusLabel("Done. Process total time: " + Misc.getTimerFormat(time));
mainWindow.updateStatusLabel2("");
}
treeScan = textures;
return(errors);
}
private byte[] decompressTexture(MemoryStream stream, StorageTypes type, int uncompressedSize, int compressedSize)
{
byte[] data = new byte[uncompressedSize];
uint blockTag = stream.ReadUInt32();
if (blockTag != textureTag)
{
throw new Exception("not match");
}
uint blockSize = stream.ReadUInt32();
if (blockSize != maxBlockSize)
{
throw new Exception("not match");
}
uint compressedChunkSize = stream.ReadUInt32();
uint uncompressedChunkSize = stream.ReadUInt32();
if (uncompressedChunkSize != uncompressedSize)
{
throw new Exception("not match");
}
uint blocksCount = (uncompressedChunkSize + maxBlockSize - 1) / maxBlockSize;
if ((compressedChunkSize + SizeOfChunk + SizeOfChunkBlock * blocksCount) != compressedSize)
{
throw new Exception("not match");
}
List <Package.ChunkBlock> blocks = new List <Package.ChunkBlock>();
for (uint b = 0; b < blocksCount; b++)
{
Package.ChunkBlock block = new Package.ChunkBlock();
block.comprSize = stream.ReadUInt32();
block.uncomprSize = stream.ReadUInt32();
blocks.Add(block);
}
for (int b = 0; b < blocks.Count; b++)
{
Package.ChunkBlock block = blocks[b];
block.compressedBuffer = stream.ReadToBuffer(blocks[b].comprSize);
block.uncompressedBuffer = new byte[maxBlockSize * 2];
blocks[b] = block;
}
if (type == StorageTypes.extLZO || type == StorageTypes.pccLZO)
{
for (int b = 0; b < blocks.Count; b++)
{
uint dstLen = 0;
Package.ChunkBlock block = blocks[b];
dstLen = new LZO2Helper.LZO2().Decompress(block.compressedBuffer, block.comprSize, block.uncompressedBuffer);
if (dstLen != block.uncomprSize)
{
throw new Exception("Decompressed data size not expected!");
}
}
}
else
{
Parallel.For(0, blocks.Count, b =>
{
uint dstLen = 0;
Package.ChunkBlock block = blocks[b];
if (type == StorageTypes.extZlib || type == StorageTypes.pccZlib)
{
dstLen = new ZlibHelper.Zlib().Decompress(block.compressedBuffer, block.comprSize, block.uncompressedBuffer);
}
if (dstLen != block.uncomprSize)
{
throw new Exception("Decompressed data size not expected!");
}
});
}
int dstPos = 0;
for (int b = 0; b < blocks.Count; b++)
{
Buffer.BlockCopy(blocks[b].uncompressedBuffer, 0, data, dstPos, (int)blocks[b].uncomprSize);
dstPos += (int)blocks[b].uncomprSize;
}
return(data);
}
public string PrepareListOfTextures(MeType gameId, TexExplorer texEplorer, MainWindow mainWindow, Installer installer, ref string log, bool ipc)
{
string errors = "";
treeScan = null;
Misc.MD5FileEntry[] md5Entries;
if (gameId == MeType.ME1_TYPE)
{
pkgs = Program.tablePkgsME1;
md5Entries = Program.entriesME1;
}
else if (gameId == MeType.ME2_TYPE)
{
pkgs = Program.tablePkgsME2;
md5Entries = Program.entriesME2;
}
else
{
pkgs = Program.tablePkgsME3;
md5Entries = Program.entriesME3;
}
List <FoundTexture> textures = new List <FoundTexture>();
string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
Assembly.GetExecutingAssembly().GetName().Name);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string filename = Path.Combine(path, "me" + (int)gameId + "map.bin");
if (mainWindow != null)
{
if (File.Exists(filename))
{
using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.ReadWrite))
{
uint tag = fs.ReadUInt32();
uint version = fs.ReadUInt32();
if (tag != textureMapBinTag || version != textureMapBinVersion)
{
MessageBox.Show("Detected wrong or old version of textures scan file!" +
"\n\nYou need to restore the game to vanilla state then reinstall optional DLC/PCC mods." +
"\n\nThen from the main menu, select 'Remove Textures Scan File' and start Texture Manager again.");
mainWindow.updateStatusLabel("");
mainWindow.updateStatusLabel2("");
texEplorer.Close();
fs.Close();
log += "Detected wrong or old version of textures scan file!" + Environment.NewLine;
log += "You need to restore the game to vanilla state then reinstall optional DLC/PCC mods." + Environment.NewLine;
log += "Then from the main menu, select 'Remove Textures Scan File' and start Texture Manager again." + Environment.NewLine;
return("Detected wrong or old version of textures scan file!" + Environment.NewLine +
"You need to restore the game to vanilla state then reinstall optional DLC/PCC mods." + Environment.NewLine +
"Then from the main menu, select 'Remove Textures Scan File' and start Texture Manager again." + Environment.NewLine);
}
uint countTexture = fs.ReadUInt32();
for (int i = 0; i < countTexture; i++)
{
FoundTexture texture = new FoundTexture();
int len = fs.ReadInt32();
texture.name = fs.ReadStringASCII(len);
texture.crc = fs.ReadUInt32();
uint countPackages = fs.ReadUInt32();
texture.list = new List <MatchedTexture>();
for (int k = 0; k < countPackages; k++)
{
MatchedTexture matched = new MatchedTexture();
matched.exportID = fs.ReadInt32();
matched.linkToMaster = fs.ReadInt32();
len = fs.ReadInt32();
matched.path = fs.ReadStringASCII(len);
texture.list.Add(matched);
}
textures.Add(texture);
}
List <string> packages = new List <string>();
int numPackages = fs.ReadInt32();
for (int i = 0; i < numPackages; i++)
{
int len = fs.ReadInt32();
string pkgPath = fs.ReadStringASCII(len);
pkgPath = GameData.GamePath + pkgPath;
packages.Add(pkgPath);
}
for (int i = 0; i < packages.Count; i++)
{
if (GameData.packageFiles.Find(s => s.Equals(packages[i], StringComparison.OrdinalIgnoreCase)) == null)
{
MessageBox.Show("Detected removal of game files since last game data scan." +
"\n\nYou need to restore the game to vanilla state then reinstall optional DLC/PCC mods." +
"\n\nThen from the main menu, select 'Remove Textures Scan File' and start Texture Manager again.");
return("");
}
}
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
if (packages.Find(s => s.Equals(GameData.packageFiles[i], StringComparison.OrdinalIgnoreCase)) == null)
{
MessageBox.Show("Detected additional game files not present in latest game data scan." +
"\n\nYou need to restore the game to vanilla state then reinstall optional DLC/PCC mods." +
"\n\nThen from the main menu, select 'Remove Textures Scan File' and start Texture Manager again.");
return("");
}
}
treeScan = textures;
mainWindow.updateStatusLabel("");
mainWindow.updateStatusLabel2("");
}
if (!texEplorer.verifyGameDataEmptyMipMapsRemoval())
{
MessageBox.Show("Detected empty mips in game files." +
"\n\nYou need the game in vanilla state and optional DLC/PCC mods." +
"\n\nThen from the main menu, select 'Remove Textures Scan File' and start Texture Manager again.");
return("");
}
return(errors);
}
if (mainWindow != null)
{
List <string> badMods = Misc.detectBrokenMod(GameData.gameType);
if (badMods.Count != 0)
{
errors = "";
for (int l = 0; l < badMods.Count; l++)
{
errors += badMods[l] + Environment.NewLine;
}
MessageBox.Show("Detected not compatible mods: \n\n" + errors);
return("");
}
List <string> mods = Misc.detectMods(GameData.gameType);
if (mods.Count != 0 && GameData.gameType == MeType.ME1_TYPE && GameData.FullScanME1Game)
{
errors = "";
for (int l = 0; l < mods.Count; l++)
{
errors += mods[l] + Environment.NewLine;
}
DialogResult resp = MessageBox.Show("Detected NOT compatible/supported mods with this version of game: \n\n" + errors +
"\n\nPress Cancel to abort or press Ok button to continue.", "Warning !", MessageBoxButtons.OKCancel);
if (resp == DialogResult.Cancel)
{
return("");
}
}
}
DialogResult result = MessageBox.Show("Replacing textures and creating mods requires generating a map of the game's textures.\n" +
"You only need to do it once.\n\n" +
"IMPORTANT! Your game needs to be in vanilla state and have optional DLC/PCC mods installed.\n\n" +
"Are you sure you want to proceed?", "Textures mapping", MessageBoxButtons.YesNo);
if (result == DialogResult.No)
{
texEplorer.Close();
return("");
}
Misc.startTimer();
}
if (!GameData.FullScanME1Game)
{
int count = GameData.packageFiles.Count;
for (int i = 0; i < count; i++)
{
if (GameData.packageFiles[i].Contains("_IT.") ||
GameData.packageFiles[i].Contains("_FR.") ||
GameData.packageFiles[i].Contains("_ES.") ||
GameData.packageFiles[i].Contains("_DE.") ||
GameData.packageFiles[i].Contains("_RA.") ||
GameData.packageFiles[i].Contains("_RU.") ||
GameData.packageFiles[i].Contains("_PLPC.") ||
GameData.packageFiles[i].Contains("_DEU.") ||
GameData.packageFiles[i].Contains("_FRA.") ||
GameData.packageFiles[i].Contains("_ITA.") ||
GameData.packageFiles[i].Contains("_POL."))
{
GameData.packageFiles.Add(GameData.packageFiles[i]);
GameData.packageFiles.RemoveAt(i--);
count--;
}
}
}
if (!generateBuiltinMapFiles && !GameData.FullScanME1Game)
{
List <string> addedFiles = new List <string>();
List <string> modifiedFiles = new List <string>();
loadTexturesMap(gameId, textures);
List <string> sortedFiles = new List <string>();
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
sortedFiles.Add(GameData.RelativeGameData(GameData.packageFiles[i]).ToLowerInvariant());
}
sortedFiles.Sort();
for (int k = 0; k < textures.Count; k++)
{
for (int t = 0; t < textures[k].list.Count; t++)
{
string pkgPath = textures[k].list[t].path.ToLowerInvariant();
if (sortedFiles.BinarySearch(pkgPath) >= 0)
{
continue;
}
MatchedTexture f = textures[k].list[t];
f.path = "";
textures[k].list[t] = f;
}
}
if (installer != null)
{
installer.updateProgressStatus("Scanning packages");
}
if (mainWindow != null)
{
mainWindow.updateStatusLabel("Scanning packages...");
}
if (ipc)
{
Console.WriteLine("[IPC]STAGE_CONTEXT STAGE_SCAN");
Console.Out.Flush();
}
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
int index = -1;
bool modified = true;
bool foundPkg = false;
string package = GameData.RelativeGameData(GameData.packageFiles[i].ToLowerInvariant());
long packageSize = new FileInfo(GameData.packageFiles[i]).Length;
for (int p = 0; p < md5Entries.Length; p++)
{
if (package == md5Entries[p].path.ToLowerInvariant())
{
foundPkg = true;
if (packageSize == md5Entries[p].size)
{
modified = false;
break;
}
index = p;
}
}
if (foundPkg && modified)
{
modifiedFiles.Add(md5Entries[index].path);
}
else if (!foundPkg)
{
addedFiles.Add(GameData.RelativeGameData(GameData.packageFiles[i]));
}
}
int lastProgress = -1;
int totalPackages = modifiedFiles.Count + addedFiles.Count;
int currentPackage = 0;
if (ipc)
{
Console.WriteLine("[IPC]STAGE_WEIGHT STAGE_SCAN " +
string.Format("{0:0.000000}", ((float)totalPackages / GameData.packageFiles.Count)));
Console.Out.Flush();
}
for (int i = 0; i < modifiedFiles.Count; i++, currentPackage++)
{
if (installer != null)
{
installer.updateProgressStatus("Scanning textures " + ((currentPackage + 1) * 100) / totalPackages + "% ");
}
if (mainWindow != null)
{
mainWindow.updateStatusLabel("Finding textures in package " + (currentPackage + 1) + " of " + totalPackages + " - " + modifiedFiles[i]);
}
if (ipc)
{
Console.WriteLine("[IPC]PROCESSING_FILE " + modifiedFiles[i]);
int newProgress = currentPackage * 100 / totalPackages;
if (lastProgress != newProgress)
{
Console.WriteLine("[IPC]TASK_PROGRESS " + newProgress);
lastProgress = newProgress;
}
Console.Out.Flush();
}
errors += FindTextures(gameId, textures, modifiedFiles[i], true, ref log);
}
for (int i = 0; i < addedFiles.Count; i++, currentPackage++)
{
if (installer != null)
{
installer.updateProgressStatus("Scanning textures " + ((currentPackage + 1) * 100) / totalPackages + "% ");
}
if (mainWindow != null)
{
mainWindow.updateStatusLabel("Finding textures in package " + (currentPackage + 1) + " of " + totalPackages + " - " + addedFiles[i]);
}
if (ipc)
{
Console.WriteLine("[IPC]PROCESSING_FILE " + addedFiles[i]);
int newProgress = currentPackage * 100 / totalPackages;
if (lastProgress != newProgress)
{
Console.WriteLine("[IPC]TASK_PROGRESS " + newProgress);
lastProgress = newProgress;
}
Console.Out.Flush();
}
errors += FindTextures(gameId, textures, addedFiles[i], false, ref log);
}
for (int k = 0; k < textures.Count; k++)
{
bool found = false;
for (int t = 0; t < textures[k].list.Count; t++)
{
if (textures[k].list[t].path != "")
{
found = true;
break;
}
}
if (!found)
{
textures[k].list.Clear();
textures.Remove(textures[k]);
k--;
}
}
}
else
{
int lastProgress = -1;
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
if (installer != null)
{
installer.updateProgressStatus("Scanning textures " + ((i + 1) * 100) / GameData.packageFiles.Count + "% ");
}
if (mainWindow != null)
{
mainWindow.updateStatusLabel("Finding textures in package " + (i + 1) + " of " + GameData.packageFiles.Count + " - " + GameData.packageFiles[i]);
}
if (ipc)
{
Console.WriteLine("[IPC]PROCESSING_FILE " + GameData.packageFiles[i]);
int newProgress = i * 100 / GameData.packageFiles.Count;
if (lastProgress != newProgress)
{
Console.WriteLine("[IPC]TASK_PROGRESS " + newProgress);
lastProgress = newProgress;
}
Console.Out.Flush();
}
FindTextures(gameId, textures, GameData.RelativeGameData(GameData.packageFiles[i]), false, ref log);
}
}
if (gameId == MeType.ME1_TYPE)
{
for (int k = 0; k < textures.Count; k++)
{
for (int t = 0; t < textures[k].list.Count; t++)
{
uint mipmapOffset = textures[k].list[t].mipmapOffset;
if (textures[k].list[t].slave)
{
MatchedTexture slaveTexture = textures[k].list[t];
string basePkgName = slaveTexture.basePackageName;
if (basePkgName == Path.GetFileNameWithoutExtension(slaveTexture.path).ToUpperInvariant())
{
throw new Exception();
}
for (int j = 0; j < textures[k].list.Count; j++)
{
if (!textures[k].list[j].slave &&
textures[k].list[j].mipmapOffset == mipmapOffset &&
textures[k].list[j].packageName == basePkgName)
{
slaveTexture.linkToMaster = j;
slaveTexture.slave = true;
textures[k].list[t] = slaveTexture;
break;
}
}
}
}
if (!textures[k].list.Exists(s => s.slave) &&
textures[k].list.Exists(s => s.weakSlave))
{
List <MatchedTexture> texList = new List <MatchedTexture>();
for (int t = 0; t < textures[k].list.Count; t++)
{
MatchedTexture tex = textures[k].list[t];
if (tex.weakSlave)
{
texList.Add(tex);
}
else
{
texList.Insert(0, tex);
}
}
FoundTexture f = textures[k];
f.list = texList;
textures[k] = f;
if (textures[k].list[0].weakSlave)
{
continue;
}
for (int t = 0; t < textures[k].list.Count; t++)
{
if (textures[k].list[t].weakSlave)
{
MatchedTexture slaveTexture = textures[k].list[t];
string basePkgName = slaveTexture.basePackageName;
if (basePkgName == Path.GetFileNameWithoutExtension(slaveTexture.path).ToUpperInvariant())
{
throw new Exception();
}
for (int j = 0; j < textures[k].list.Count; j++)
{
if (!textures[k].list[j].weakSlave &&
textures[k].list[j].packageName == basePkgName)
{
slaveTexture.linkToMaster = j;
slaveTexture.slave = true;
textures[k].list[t] = slaveTexture;
break;
}
}
}
}
}
}
}
if (File.Exists(filename))
{
File.Delete(filename);
}
using (FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write))
{
MemoryStream mem = new MemoryStream();
mem.WriteUInt32(textureMapBinTag);
mem.WriteUInt32(textureMapBinVersion);
mem.WriteInt32(textures.Count);
for (int i = 0; i < textures.Count; i++)
{
if (generateBuiltinMapFiles)
{
mem.WriteByte((byte)textures[i].name.Length);
}
else
{
mem.WriteInt32(textures[i].name.Length);
}
mem.WriteStringASCII(textures[i].name);
mem.WriteUInt32(textures[i].crc);
if (generateBuiltinMapFiles)
{
mem.WriteInt16((short)textures[i].width);
mem.WriteInt16((short)textures[i].height);
mem.WriteByte((byte)textures[i].pixfmt);
mem.WriteByte((byte)textures[i].flags);
mem.WriteInt16((short)textures[i].list.Count);
}
else
{
mem.WriteInt32(textures[i].list.Count);
}
for (int k = 0; k < textures[i].list.Count; k++)
{
mem.WriteInt32(textures[i].list[k].exportID);
if (generateBuiltinMapFiles)
{
if (GameData.gameType == MeType.ME1_TYPE)
{
mem.WriteInt16((short)textures[i].list[k].linkToMaster);
if (textures[i].list[k].linkToMaster != -1)
{
mem.WriteStringASCIINull(textures[i].list[k].basePackageName);
}
}
mem.WriteByte(textures[i].list[k].removeEmptyMips ? (byte)1 : (byte)0);
mem.WriteByte((byte)textures[i].list[k].numMips);
mem.WriteInt16((short)pkgs.IndexOf(textures[i].list[k].path));
}
else
{
mem.WriteInt32(textures[i].list[k].linkToMaster);
mem.WriteInt32(textures[i].list[k].path.Length);
mem.WriteStringASCII(textures[i].list[k].path);
}
}
}
if (!generateBuiltinMapFiles)
{
mem.WriteInt32(GameData.packageFiles.Count);
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
string s = GameData.RelativeGameData(GameData.packageFiles[i]);
mem.WriteInt32(s.Length);
mem.WriteStringASCII(s);
}
}
mem.SeekBegin();
if (generateBuiltinMapFiles)
{
fs.WriteUInt32(0x504D5443);
fs.WriteUInt32((uint)mem.Length);
byte[] compressed = new ZlibHelper.Zlib().Compress(mem.ToArray(), 9);
fs.WriteUInt32((uint)compressed.Length);
fs.WriteFromBuffer(compressed);
}
else
{
fs.WriteFromStream(mem, mem.Length);
}
}
if (mainWindow != null)
{
if (!generateBuiltinMapFiles)
{
MipMaps mipmaps = new MipMaps();
if (GameData.gameType == MeType.ME1_TYPE)
{
errors += mipmaps.removeMipMapsME1(1, textures, mainWindow, null, false);
errors += mipmaps.removeMipMapsME1(2, textures, mainWindow, null, false);
}
else
{
errors += mipmaps.removeMipMapsME2ME3(textures, mainWindow, null, false, false);
}
if (GameData.gameType == MeType.ME3_TYPE)
{
TOCBinFile.UpdateAllTOCBinFiles();
}
}
}
treeScan = textures;
if (mainWindow != null)
{
var time = Misc.stopTimer();
mainWindow.updateStatusLabel("Done. Process total time: " + Misc.getTimerFormat(time));
mainWindow.updateStatusLabel2("");
}
return(errors);
}
/// <summary>
/// decompress an entire pcc file.
/// </summary>
/// <param name="input">pcc file passed in stream format</param>
/// <returns>a decompressed array of bytes</returns>
public static byte[] Decompress(Stream input)
{
input.Seek(0, SeekOrigin.Begin);
var magic = input.ReadValueU32(Endian.Little);
if (magic != 0x9E2A83C1 &&
magic.Swap() != 0x9E2A83C1)
{
throw new FormatException("not a pcc file");
}
var endian = magic == 0x9E2A83C1 ? Endian.Little : Endian.Big;
var versionLo = input.ReadValueU16(endian);
var versionHi = input.ReadValueU16(endian);
if (versionLo != 684 &&
versionHi != 194)
{
throw new FormatException("unsupported pcc version");
}
long headerSize = 8;
input.Seek(4, SeekOrigin.Current);
headerSize += 4;
var folderNameLength = input.ReadValueS32(endian);
headerSize += 4;
var folderNameByteLength =
folderNameLength >= 0 ? folderNameLength : (-folderNameLength * 2);
input.Seek(folderNameByteLength, SeekOrigin.Current);
headerSize += folderNameByteLength;
var packageFlagsOffset = input.Position;
var packageFlags = input.ReadValueU32(endian);
headerSize += 4;
if ((packageFlags & 0x02000000u) == 0)
{
throw new FormatException("pcc file is already decompressed");
}
if ((packageFlags & 8) != 0)
{
input.Seek(4, SeekOrigin.Current);
headerSize += 4;
}
uint nameCount = input.ReadValueU32(endian);
uint nameOffset = input.ReadValueU32(endian);
input.Seek(52, SeekOrigin.Current);
headerSize += 60;
var generationsCount = input.ReadValueU32(endian);
input.Seek(generationsCount * 12, SeekOrigin.Current);
headerSize += generationsCount * 12;
input.Seek(20, SeekOrigin.Current);
headerSize += 24;
var blockCount = input.ReadValueU32(endian);
int headBlockOff = (int)input.Position;
var afterBlockTableOffset = headBlockOff + (blockCount * 16);
var indataOffset = afterBlockTableOffset + 8;
byte[] buff;
input.Seek(0, SeekOrigin.Begin);
using (MemoryStream output = new MemoryStream())
{
output.Seek(0, SeekOrigin.Begin);
output.WriteFromStream(input, headerSize);
output.WriteValueU32(0, endian); // block count
input.Seek(afterBlockTableOffset, SeekOrigin.Begin);
output.WriteFromStream(input, 8);
//check if has extra name list (don't know it's usage...)
if ((packageFlags & 0x10000000) != 0)
{
long curPos = output.Position;
output.WriteFromStream(input, nameOffset - curPos);
}
ZlibHelper.Zlib z = new ZlibHelper.Zlib();
for (int i = 0; i < blockCount; i++)
{
input.Seek(headBlockOff, SeekOrigin.Begin);
var uncompressedOffset = input.ReadValueU32(endian);
var uncompressedSize = input.ReadValueU32(endian);
var compressedOffset = input.ReadValueU32(endian);
var compressedSize = input.ReadValueU32(endian);
headBlockOff = (int)input.Position;
buff = new byte[compressedSize];
input.Seek(compressedOffset, SeekOrigin.Begin);
input.Read(buff, 0, buff.Length);
byte[] temp = new byte[uncompressedSize];
z.Decompress(buff, compressedSize, temp);
output.Seek(uncompressedOffset, SeekOrigin.Begin);
output.Write(temp, 0, temp.Length);
}
output.Seek(packageFlagsOffset, SeekOrigin.Begin);
output.WriteValueU32(packageFlags & ~0x02000000u, endian);
return(output.ToArray());
}
}
/// <summary>
/// compress an entire pcc into a byte array.
/// </summary>
/// <param name="uncompressedPcc">uncompressed pcc stream.</param>
/// <returns>a compressed array of bytes.</returns>
public static Stream Compress(Stream uncompressedPcc)
{
uncompressedPcc.Position = 0;
var magic = uncompressedPcc.ReadValueU32(Endian.Little);
if (magic != 0x9E2A83C1 &&
magic.Swap() != 0x9E2A83C1)
{
throw new FormatException("not a pcc package");
}
var endian = magic == 0x9E2A83C1 ?
Endian.Little : Endian.Big;
var encoding = endian == Endian.Little ?
Encoding.Unicode : Encoding.BigEndianUnicode;
var versionLo = uncompressedPcc.ReadValueU16(endian);
var versionHi = uncompressedPcc.ReadValueU16(endian);
if (versionLo != 684 &&
versionHi != 194)
{
throw new FormatException("unsupported version");
}
uncompressedPcc.Seek(4, SeekOrigin.Current);
var folderNameLength = uncompressedPcc.ReadValueS32(endian);
var folderNameByteLength =
folderNameLength >= 0 ? folderNameLength : (-folderNameLength * 2);
uncompressedPcc.Seek(folderNameByteLength, SeekOrigin.Current);
var packageFlagsOffset = uncompressedPcc.Position;
var packageFlags = uncompressedPcc.ReadValueU32(endian);
if ((packageFlags & 8) != 0)
{
uncompressedPcc.Seek(4, SeekOrigin.Current);
}
var nameCount = uncompressedPcc.ReadValueU32(endian);
var namesOffset = uncompressedPcc.ReadValueU32(endian);
var exportCount = uncompressedPcc.ReadValueU32(endian);
var exportInfosOffset = uncompressedPcc.ReadValueU32(endian);
SortedDictionary <uint, uint> exportDataOffsets = new SortedDictionary <uint, uint>();
Stream data;
if ((packageFlags & 0x02000000) == 0)
{
data = uncompressedPcc;
}
else
{
throw new FormatException("pcc data is compressed");
}
// get info about export data, sizes and offsets
data.Seek(exportInfosOffset, SeekOrigin.Begin);
for (uint i = 0; i < exportCount; i++)
{
var classIndex = data.ReadValueS32(endian);
data.Seek(4, SeekOrigin.Current);
var outerIndex = data.ReadValueS32(endian);
var objectNameIndex = data.ReadValueS32(endian);
data.Seek(16, SeekOrigin.Current);
uint exportDataSize = data.ReadValueU32(endian);
uint exportDataOffset = data.ReadValueU32(endian);
exportDataOffsets.Add(exportDataOffset, exportDataSize);
data.Seek(4, SeekOrigin.Current);
var count = data.ReadValueU32(endian);
data.Seek(count * 4, SeekOrigin.Current);
data.Seek(20, SeekOrigin.Current);
}
const uint maxBlockSize = 0x100000;
Stream outputStream = new MemoryStream();
// copying pcc header
byte[] buffer = new byte[130];
uncompressedPcc.Seek(0, SeekOrigin.Begin);
uncompressedPcc.Read(buffer, 0, 130);
outputStream.Write(buffer, 0, buffer.Length);
//add compressed pcc flag
uncompressedPcc.Seek(12, SeekOrigin.Begin);
folderNameLength = uncompressedPcc.ReadValueS32();
folderNameByteLength =
folderNameLength >= 0 ? folderNameLength : (-folderNameLength * 2);
uncompressedPcc.Seek(folderNameByteLength, SeekOrigin.Current);
outputStream.Seek(uncompressedPcc.Position, SeekOrigin.Begin);
packageFlags = uncompressedPcc.ReadValueU32();
packageFlags |= 0x02000000; // add compression flag
outputStream.WriteValueU32(packageFlags);
outputStream.Seek(buffer.Length, SeekOrigin.Begin);
long outOffsetData;
long outOffsetBlockInfo;
long inOffsetData = namesOffset;
List <int> blockSizes = new List <int>();
int countSize = (int)(exportDataOffsets.Min(obj => obj.Key) - namesOffset);
//count the number of blocks and relative sizes
uint lastOffset = exportDataOffsets.Min(obj => obj.Key);
foreach (KeyValuePair <uint, uint> exportInfo in exportDataOffsets)
{
// part that adds empty spaces (leaved when editing export data and moved to the end of pcc) into the count
if (exportInfo.Key != lastOffset)
{
int emptySpace = (int)(exportInfo.Key - lastOffset);
if (countSize + emptySpace > maxBlockSize)
{
blockSizes.Add(countSize);
countSize = 0;
}
else
{
countSize += (int)emptySpace;
}
}
// adds export data into the count
if (countSize + exportInfo.Value > maxBlockSize)
{
blockSizes.Add(countSize);
countSize = (int)exportInfo.Value;
}
else
{
countSize += (int)exportInfo.Value;
}
lastOffset = exportInfo.Key + exportInfo.Value;
}
blockSizes.Add(countSize);
outputStream.WriteValueS32(blockSizes.Count);
outOffsetBlockInfo = outputStream.Position;
outOffsetData = namesOffset + (blockSizes.Count * 16);
uncompressedPcc.Seek(namesOffset, SeekOrigin.Begin);
//divide the block in segments
ZlibHelper.Zlib z = new ZlibHelper.Zlib();
for (int i = 0; i < blockSizes.Count; i++)
{
int currentUncBlockSize = blockSizes[i];
outputStream.Seek(outOffsetBlockInfo, SeekOrigin.Begin);
outputStream.WriteValueU32((uint)uncompressedPcc.Position);
outputStream.WriteValueS32(currentUncBlockSize);
outputStream.WriteValueU32((uint)outOffsetData);
byte[] inputBlock = new byte[currentUncBlockSize];
uncompressedPcc.Read(inputBlock, 0, (int)currentUncBlockSize);
byte[] compressedBlock = z.Compress(inputBlock);
outputStream.WriteValueS32(compressedBlock.Length);
outOffsetBlockInfo = outputStream.Position;
outputStream.Seek(outOffsetData, SeekOrigin.Begin);
outputStream.Write(compressedBlock, 0, compressedBlock.Length);
outOffsetData = outputStream.Position;
}
//copying some unknown values + extra names list
int bufferSize = (int)namesOffset - 0x86;
buffer = new byte[bufferSize];
uncompressedPcc.Seek(0x86, SeekOrigin.Begin);
uncompressedPcc.Read(buffer, 0, buffer.Length);
outputStream.Seek(outOffsetBlockInfo, SeekOrigin.Begin);
outputStream.Write(buffer, 0, buffer.Length);
outputStream.Seek(0, SeekOrigin.Begin);
return(outputStream);
}
