private void LoadAssetsFile(string fullName, EndianBinaryReader reader)
{
var fileName = Path.GetFileName(fullName);
if (!assetsFileListHash.Contains(fileName))
{
Logger.Info($"Loading {fileName}");
try
{
var assetsFile = new SerializedFile(this, fullName, reader);
assetsFileList.Add(assetsFile);
assetsFileListHash.Add(assetsFile.fileName);
foreach (var sharedFile in assetsFile.m_Externals)
{
var sharedFilePath = Path.Combine(Path.GetDirectoryName(fullName), sharedFile.fileName);
var sharedFileName = sharedFile.fileName;
if (!importFilesHash.Contains(sharedFileName))
{
if (!File.Exists(sharedFilePath))
{
var findFiles = Directory.GetFiles(Path.GetDirectoryName(fullName), sharedFileName, SearchOption.AllDirectories);
if (findFiles.Length > 0)
{
sharedFilePath = findFiles[0];
}
}
if (File.Exists(sharedFilePath))
{
importFiles.Add(sharedFilePath);
importFilesHash.Add(sharedFileName);
}
}
}
}
catch (Exception e)
{
Logger.Error($"Error while reading assets file {fileName}", e);
reader.Dispose();
}
}
else
{
reader.Dispose();
}
}
private void LoadAssetsFile(string fullName, EndianBinaryReader reader)
{
var fileName = Path.GetFileName(fullName);
if (!assetsFileListHash.Contains(fileName))
{
Logger.Info($"Loading {fileName}");
try
{
var assetsFile = new SerializedFile(this, fullName, reader);
assetsFileList.Add(assetsFile);
assetsFileListHash.Add(assetsFile.fileName);
//foreach (var sharedFile in assetsFile.m_Externals)
//{
// var sharedFilePath = Path.GetDirectoryName(fullName) + "\\" + sharedFile.fileName;
// var sharedFileName = sharedFile.fileName;
// if (!importFilesHash.Contains(sharedFileName))
// {
// if (!File.Exists(sharedFilePath))
// {
// var findFiles = Directory.GetFiles(Path.GetDirectoryName(fullName), sharedFileName, SearchOption.AllDirectories);
// if (findFiles.Length > 0)
// {
// sharedFilePath = findFiles[0];
// }
// }
// if (File.Exists(sharedFilePath))
// {
// importFiles.Add(sharedFilePath);
// importFilesHash.Add(sharedFileName);
// }
// }
//}
}
catch
{
reader.Dispose();
//Logger.Warning($"Unable to load assets file {fileName}");
}
}
else
{
reader.Dispose();
}
}
private static void LoadWebFile(string fullName, EndianBinaryReader reader)
{
var fileName = Path.GetFileName(fullName);
StatusStripUpdate("Loading " + fileName);
var webFile = new WebFile(reader);
reader.Dispose();
foreach (var file in webFile.fileList)
{
var dummyName = Path.GetDirectoryName(fullName) + "\\" + file.fileName;
switch (CheckFileType(file.stream, out reader))
{
case FileType.AssetsFile:
LoadAssetsFile(dummyName, reader, fullName);
break;
case FileType.BundleFile:
LoadBundleFile(dummyName, reader, fullName);
break;
case FileType.WebFile:
LoadWebFile(dummyName, reader);
break;
}
resourceFileReaders.Add(file.fileName.ToUpper(), reader);
}
}
private static int ExtractBundleFile(string bundleFileName)
{
int extractedCount = 0;
var extractPath = bundleFileName + "_unpacked\\";
Directory.CreateDirectory(extractPath);
var reader = new EndianBinaryReader(File.OpenRead(bundleFileName));
var bundleFile = new BundleFile(reader);
reader.Dispose();
if (bundleFile.fileList.Count > 0)
{
StatusStripUpdate($"Decompressing {Path.GetFileName(bundleFileName)} ...");
foreach (var memFile in bundleFile.fileList)
{
var filePath = extractPath + memFile.fileName.Replace('/', '\\');
if (!Directory.Exists(Path.GetDirectoryName(filePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
}
if (!File.Exists(filePath))
{
File.WriteAllBytes(filePath, memFile.stream.ToArray());
memFile.stream.Dispose();
extractedCount += 1;
}
}
}
return(extractedCount);
}
private void LoadWebFile(string fullName, EndianBinaryReader reader)
{
var fileName = Path.GetFileName(fullName);
Logger.Info("Loading " + fileName);
var webFile = new WebFile(reader);
reader.Dispose();
foreach (var file in webFile.fileList)
{
var dummyPath = Path.GetDirectoryName(fullName) + "\\" + file.fileName;
switch (CheckFileType(file.stream, out reader))
{
case FileType.AssetsFile:
LoadAssetsFromMemory(dummyPath, reader, fullName);
break;
case FileType.BundleFile:
LoadBundleFile(dummyPath, reader, fullName);
break;
case FileType.WebFile:
LoadWebFile(dummyPath, reader);
break;
}
}
}
private void LoadBundleFile(string fullName, EndianBinaryReader reader, string parentPath = null)
{
var fileName = Path.GetFileName(fullName);
Logger.Info("Loading " + fileName);
try
{
var bundleFile = new BundleFile(reader, fullName);
foreach (var file in bundleFile.fileList)
{
var dummyPath = Path.GetDirectoryName(fullName) + "\\" + file.fileName;
LoadAssetsFromMemory(dummyPath, new EndianBinaryReader(file.stream), parentPath ?? fullName, bundleFile.versionEngine);
}
}
catch
{
/*var str = $"Unable to load bundle file {fileName}";
* if (parentPath != null)
* {
* str += $" from {Path.GetFileName(parentPath)}";
* }
* Logger.Error(str);*/
}
finally
{
reader.Dispose();
}
}
public void Dispose()
{
this.m_BlocksInfo = null;
this.m_Header = null;
this.m_DirectoryInfo = null;
reader?.Dispose();
}
private void LoadAssetsFile(string fullName, EndianBinaryReader reader)
{
var fileName = Path.GetFileName(fullName);
if (!assetsfileListHash.Contains(fileName.ToUpper()))
{
Logger.Info($"Loading {fileName}");
var assetsFile = new SerializedFile(this, fullName, reader);
if (assetsFile.valid)
{
assetsFileList.Add(assetsFile);
assetsfileListHash.Add(assetsFile.upperFileName);
foreach (var sharedFile in assetsFile.m_Externals)
{
var sharedFilePath = Path.GetDirectoryName(fullName) + "\\" + sharedFile.fileName;
var sharedFileName = sharedFile.fileName;
if (!importFilesHash.Contains(sharedFileName.ToUpper()))
{
if (!File.Exists(sharedFilePath))
{
var findFiles = Directory.GetFiles(Path.GetDirectoryName(fullName), sharedFileName, SearchOption.AllDirectories);
if (findFiles.Length > 0)
{
sharedFilePath = findFiles[0];
}
}
if (File.Exists(sharedFilePath))
{
importFiles.Add(sharedFilePath);
importFilesHash.Add(sharedFileName.ToUpper());
}
}
}
}
else
{
reader.Dispose();
}
}
else
{
reader.Dispose();
}
}
private void LoadBundleFile(string fullName, EndianBinaryReader reader, string parentPath = null)
{
var fileName = Path.GetFileName(fullName);
Logger.Info("Decompressing " + fileName);
var bundleFile = new BundleFile(reader, fullName);
reader.Dispose();
foreach (var file in bundleFile.fileList)
{
var dummyPath = Path.GetDirectoryName(fullName) + "\\" + file.fileName;
LoadAssetsFromMemory(dummyPath, new EndianBinaryReader(file.stream), parentPath ?? fullName, bundleFile.versionEngine);
}
}
private static int ExtractBundleFile(string bundleFileName, EndianBinaryReader reader)
{
var bundleFile = new BundleFile(reader);
reader.Dispose();
if (bundleFile.fileList.Count > 0)
{
StatusStripUpdate($"Decompressing {Path.GetFileName(bundleFileName)} ...");
var extractPath = bundleFileName + "_unpacked\\";
Directory.CreateDirectory(extractPath);
return(ExtractMemoryFile(extractPath, bundleFile.fileList));
}
return(0);
}
private static int ExtractWebDataFile(string webFileName, EndianBinaryReader reader)
{
StatusStripUpdate($"Decompressing {Path.GetFileName(webFileName)} ...");
var webFile = new WebFile(reader);
reader.Dispose();
if (webFile.fileList.Count > 0)
{
var extractPath = webFileName + "_unpacked\\";
Directory.CreateDirectory(extractPath);
return(ExtractStreamFile(extractPath, webFile.fileList));
}
return(0);
}
private void LoadMxrFile(string fullName, EndianBinaryReader reader)
{
var fileName = Path.GetFileName(fullName);
if (!assetsFileListHash.Contains(fileName))
{
Logger.Info($"Loading {fileName}");
try
{
var assetsFile = new Mxr.MxrSerializedFile(this, fullName, reader);
assetsFileList.Add(assetsFile);
assetsFileListHash.Add(assetsFile.fileName);
}
catch
{
reader.Dispose();
//Logger.Warning($"Unable to load MXR file {fileName}");
}
}
else
{
reader.Dispose();
}
}
private void LoadWebFile(string fullName, EndianBinaryReader reader)
{
var fileName = Path.GetFileName(fullName);
Logger.Info("Loading " + fileName);
try
{
var webFile = new WebFile(reader);
foreach (var file in webFile.fileList)
{
var dummyPath = Path.Combine(Path.GetDirectoryName(fullName), file.fileName);
switch (CheckFileType(file.stream, out var fileReader))
{
case FileType.AssetsFile:
LoadAssetsFromMemory(dummyPath, fileReader, fullName);
break;
case FileType.BundleFile:
LoadBundleFile(dummyPath, fileReader, fullName);
break;
case FileType.WebFile:
LoadWebFile(dummyPath, fileReader);
break;
case FileType.ResourceFile:
resourceFileReaders[file.fileName] = fileReader; //TODO
break;
}
}
}
catch (Exception e)
{
Logger.Error($"Error while reading web file {fileName}", e);
}
finally
{
reader.Dispose();
}
}
private void LoadWebFile(string fullName, EndianBinaryReader reader)
{
var fileName = Path.GetFileName(fullName);
Logger.Info("Loading " + fileName);
try
{
var webFile = new WebFile(reader);
foreach (var file in webFile.fileList)
{
var dummyPath = Path.GetDirectoryName(fullName) + "\\" + file.fileName;
switch (CheckFileType(file.stream, out var fileReader))
{
case FileType.AssetsFile:
LoadAssetsFromMemory(dummyPath, fileReader, fullName);
break;
case FileType.BundleFile:
LoadBundleFile(dummyPath, fileReader, fullName);
break;
case FileType.WebFile:
LoadWebFile(dummyPath, fileReader);
break;
case FileType.ResourceFile:
resourceFileReaders.Add(file.fileName, fileReader);
break;
}
}
}
catch
{
//Logger.Error($"Unable to load web file {fileName}");
}
finally
{
reader.Dispose();
}
}
private void LoadBundleFile(string fullName, EndianBinaryReader reader, string parentPath = null)
{
var fileName = Path.GetFileName(fullName);
Logger.Info("Loading " + fileName);
try
{
var bundleFile = new BundleFile(reader, fullName);
foreach (var file in bundleFile.fileList)
{
var subReader = new EndianBinaryReader(file.stream);
if (SerializedFile.IsSerializedFile(subReader))
{
var dummyPath = Path.GetDirectoryName(fullName) + Path.DirectorySeparatorChar + file.fileName;
if (bundleFile.fileList.Length == 1)
{
dummyPath = fullName;
}
LoadAssetsFromMemory(dummyPath, subReader, parentPath ?? fullName, bundleFile.m_Header.unityRevision, (bundleFile.fileList.Length == 1));
}
else
{
resourceFileReaders.Add(file.fileName, subReader);
}
}
}
catch
{
/*var str = $"Unable to load bundle file {fileName}";
* if (parentPath != null)
* {
* str += $" from {Path.GetFileName(parentPath)}";
* }
* Logger.Error(str);*/
}
finally
{
reader.Dispose();
}
}
private static void LoadBundleFile(string fullName, List <AssetsFile> assetsfileList,
EndianBinaryReader reader, Dictionary <string, EndianBinaryReader> resourceFileReaders, string parentPath = null)
{
var fileName = Path.GetFileName(fullName);
StatusStripUpdate("Decompressing " + fileName);
var bundleFile = new BundleFile(reader, fullName);
reader.Dispose();
foreach (var file in bundleFile.fileList)
{
if (!assetsfileListHash.Value.Contains(file.fileName.ToUpper()))
{
StatusStripUpdate("Loading " + file.fileName);
var assetsFile = new AssetsFile(Path.GetDirectoryName(fullName) + "\\" + file.fileName, new EndianBinaryReader(file.stream));
if (assetsFile.valid)
{
assetsFile.parentPath = parentPath ?? fullName;
if (assetsFile.fileGen == 6) //2.6.x and earlier don't have a string version before the preload table
{
//make use of the bundle file version
assetsFile.m_Version = bundleFile.versionEngine;
assetsFile.version = Regex.Matches(bundleFile.versionEngine, @"\d").Cast <Match>().Select(m => int.Parse(m.Value)).ToArray();
assetsFile.buildType = Regex.Replace(bundleFile.versionEngine, @"\d", "").Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries);
}
assetsfileList.Add(assetsFile);
assetsfileListHash.Value.Add(assetsFile.upperFileName);
}
else
{
resourceFileReaders.Add(assetsFile.upperFileName, assetsFile.reader);
}
}
}
}
private void LoadBundleFile(string fullName, EndianBinaryReader reader, string parentPath = null)
{
var fileName = Path.GetFileName(fullName);
Logger.Info("Loading " + fileName);
try
{
var bundleFile = new BundleFile(reader, fullName);
foreach (var file in bundleFile.fileList)
{
var subReader = new EndianBinaryReader(file.stream);
if (SerializedFile.IsSerializedFile(subReader))
{
var dummyPath = Path.GetDirectoryName(fullName) + Path.DirectorySeparatorChar + file.fileName;
LoadAssetsFromMemory(dummyPath, subReader, parentPath ?? fullName, bundleFile.m_Header.unityRevision);
}
else
{
resourceFileReaders[file.fileName] = subReader; //TODO
}
}
}
catch (Exception e)
{
var str = $"Error while reading bundle file {fileName}";
if (parentPath != null)
{
str += $" from {Path.GetFileName(parentPath)}";
}
Logger.Error(str, e);
}
finally
{
reader.Dispose();
}
}
private void readBase5()
{
int classID = assetsFileReader.ReadInt32();
if (fileGen > 15)//5.5.0 and up
{
assetsFileReader.ReadByte();
int type1;
if ((type1 = assetsFileReader.ReadInt16()) >= 0)
{
type1 = -1 - type1;
}
else
{
type1 = classID;
}
classIDs.Add(new[] { type1, classID });
if (classID == 114)
{
assetsFileReader.Position += 16;
}
classID = type1;
}
else if (classID < 0)
{
assetsFileReader.Position += 16;
}
assetsFileReader.Position += 16;
if (baseDefinitions)
{
int varCount = assetsFileReader.ReadInt32();
int stringSize = assetsFileReader.ReadInt32();
assetsFileReader.Position += varCount * 24;
var stringReader = new EndianBinaryReader(new MemoryStream(assetsFileReader.ReadBytes(stringSize)));
string className = "";
var classVar = new List <ClassMember>();
//build Class Structures
assetsFileReader.Position -= varCount * 24 + stringSize;
for (int i = 0; i < varCount; i++)
{
ushort num0 = assetsFileReader.ReadUInt16();
byte level = assetsFileReader.ReadByte();
bool isArray = assetsFileReader.ReadBoolean();
ushort varTypeIndex = assetsFileReader.ReadUInt16();
ushort test = assetsFileReader.ReadUInt16();
string varTypeStr;
if (test == 0) //varType is an offset in the string block
{
stringReader.Position = varTypeIndex;
varTypeStr = stringReader.ReadStringToNull();
}
else //varType is an index in an internal strig array
{
varTypeStr = baseStrings.ContainsKey(varTypeIndex) ? baseStrings[varTypeIndex] : varTypeIndex.ToString();
}
ushort varNameIndex = assetsFileReader.ReadUInt16();
test = assetsFileReader.ReadUInt16();
string varNameStr;
if (test == 0)
{
stringReader.Position = varNameIndex;
varNameStr = stringReader.ReadStringToNull();
}
else
{
varNameStr = baseStrings.ContainsKey(varNameIndex) ? baseStrings[varNameIndex] : varNameIndex.ToString();
}
int size = assetsFileReader.ReadInt32();
int index = assetsFileReader.ReadInt32();
int flag = assetsFileReader.ReadInt32();
if (index == 0)
{
className = varTypeStr + " " + varNameStr;
}
else
{
classVar.Add(new ClassMember
{
Level = level - 1,
Type = varTypeStr,
Name = varNameStr,
Size = size,
Flag = flag
});
}
}
stringReader.Dispose();
assetsFileReader.Position += stringSize;
var aClass = new ClassStruct {
ID = classID, Text = className, members = classVar
};
aClass.SubItems.Add(classID.ToString());
ClassStructures[classID] = aClass;
}
}
private static void LoadAssetsFile(string fullName, EndianBinaryReader reader, string parentPath = null)
{
var fileName = Path.GetFileName(fullName);
StatusStripUpdate("Loading " + fileName);
if (!assetsfileListHash.Contains(fileName.ToUpper()))
{
var assetsFile = new AssetsFile(fullName, reader);
if (assetsFile.valid)
{
assetsFile.parentPath = parentPath;
assetsfileList.Add(assetsFile);
assetsfileListHash.Add(assetsFile.upperFileName);
#region for 2.6.x find mainData and get string version
if (assetsFile.header.m_Version == 6 && fileName != "mainData")
{
var mainDataFile = assetsfileList.Find(aFile => aFile.fileName == "mainData");
if (mainDataFile != null)
{
assetsFile.unityVersion = mainDataFile.unityVersion;
assetsFile.version = mainDataFile.version;
assetsFile.buildType = mainDataFile.buildType;
}
else if (File.Exists(Path.GetDirectoryName(fullName) + "\\mainData"))
{
mainDataFile = new AssetsFile(Path.GetDirectoryName(fullName) + "\\mainData", new EndianBinaryReader(File.OpenRead(Path.GetDirectoryName(fullName) + "\\mainData")));
assetsFile.unityVersion = mainDataFile.unityVersion;
assetsFile.version = mainDataFile.version;
assetsFile.buildType = mainDataFile.buildType;
}
}
#endregion
int value = 0;
foreach (var sharedFile in assetsFile.sharedAssetsList)
{
var sharedFilePath = Path.GetDirectoryName(fullName) + "\\" + sharedFile.fileName;
var sharedFileName = sharedFile.fileName;
if (!importFilesHash.Contains(sharedFileName.ToUpper()))
{
if (!File.Exists(sharedFilePath))
{
var findFiles = Directory.GetFiles(Path.GetDirectoryName(fullName), sharedFileName, SearchOption.AllDirectories);
if (findFiles.Length > 0)
{
sharedFilePath = findFiles[0];
}
}
if (File.Exists(sharedFilePath))
{
importFiles.Add(sharedFilePath);
importFilesHash.Add(sharedFileName.ToUpper());
value++;
}
}
}
if (value > 0)
{
ProgressBarMaximumAdd(value);
}
}
else
{
reader.Dispose();
}
}
}
