static void PatchVR(string gameManagersBackupPath, string gameManagersPath, string classDataPath)
{
Console.WriteLine("Patching globalgamemanagers...");
Console.WriteLine($"Using classData file from path '{classDataPath}'");
AssetsManager am = new AssetsManager();
am.LoadClassPackage(classDataPath);
AssetsFileInstance ggm = am.LoadAssetsFile(gameManagersBackupPath, false);
AssetsFile ggmFile = ggm.file;
AssetsFileTable ggmTable = ggm.table;
am.LoadClassDatabaseFromPackage(ggmFile.typeTree.unityVersion);
List <AssetsReplacer> replacers = new List <AssetsReplacer>();
AssetFileInfoEx buildSettings = ggmTable.GetAssetInfo(11);
AssetTypeValueField buildSettingsBase = am.GetATI(ggmFile, buildSettings).GetBaseField();
AssetTypeValueField enabledVRDevices = buildSettingsBase.Get("enabledVRDevices").Get("Array");
AssetTypeTemplateField stringTemplate = enabledVRDevices.templateField.children[1];
AssetTypeValueField[] vrDevicesList = new AssetTypeValueField[] { StringField("OpenVR", stringTemplate) };
enabledVRDevices.SetChildrenList(vrDevicesList);
replacers.Add(new AssetsReplacerFromMemory(0, buildSettings.index, (int)buildSettings.curFileType, 0xffff, buildSettingsBase.WriteToByteArray()));
using (AssetsFileWriter writer = new AssetsFileWriter(File.OpenWrite(gameManagersPath)))
{
ggmFile.Write(writer, 0, replacers, 0);
}
}
private void button1_Click(object sender, EventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog();
if (ofd.ShowDialog() != DialogResult.OK)
{
return;
}
string mainFile = ofd.FileName;
string outFile = Path.Combine(Path.GetDirectoryName(ofd.FileName), "out.assets");
//string classFile = "U5.6.0f3_AT.NET.dat";
FileStream mffs = new FileStream(mainFile, FileMode.Open);
FileStream offs = new FileStream(outFile, FileMode.Create);
AssetsFile assetsFile = new AssetsFile(new AssetsFileReader(mffs));
AssetsFileWriter writer = new AssetsFileWriter(offs);
AssetsReplacer assetsReplacer1 = new AssetsReplacerFromFile(0, 100, 0x1, 0xFFFF, new FileStream("testasset.dat", FileMode.Open), 0, 0x0E);
assetsFile.Write(writer, 0, new AssetsReplacer[] { assetsReplacer1 }, 0);
writer.Close();
writer.Dispose();
//AssetsFileTable assetsFileTable = new AssetsFileTable(assetsFile);
//AssetFileInfoEx assetsFileInfo = assetsFileTable.getAssetInfo(289578);
//FileStream cffs = new FileStream(classFile, FileMode.Open);
//AssetTypeTemplateField pBaseField = new AssetTypeTemplateField();
//ClassDatabaseFile classDatabaseFile = new ClassDatabaseFile();
//classDatabaseFile.Read(new AssetsFileReader(cffs));
//ClassDatabaseType classDatabaseType = AssetHelper.FindAssetClassByName(classDatabaseFile, "MonoBehaviour");
//pBaseField.FromClassDatabase(classDatabaseFile, classDatabaseType, 0);
//AssetTypeInstance ati = new AssetTypeInstance(1, new[] { pBaseField }, new AssetsFileReader(mffs), false, assetsFileInfo.absoluteFilePos);
//MonoClass mc = new MonoClass();
//mc.Read("Peeper", "E:\\Steam\\steamapps\\common\\Subnautica\\Subnautica_Data\\Managed\\Assembly-CSharp.dll");
//AssetTypeTemplateField[] templateField = pBaseField.children.Concat(mc.children).ToArray();
//pBaseField.children = templateField;
//pBaseField.childrenCount = (uint)pBaseField.children.Length;
//AssetTypeInstance ati2 = new AssetTypeInstance(1, new[] { pBaseField }, new AssetsFileReader(mffs), false, assetsFileInfo.absoluteFilePos);
//MessageBox.Show("" + ati.GetBaseField().childrenCount);
//MessageBox.Show("" + ati.GetBaseField().childrenCount);
//MessageBox.Show("" + ati.GetBaseField().Get("m_Component").Get("Array").Get(0).Get("component").Get("m_PathID").GetValue().AsInt64());
//MessageBox.Show("" + ati2.GetBaseField().Get("rechargeInterval").GetValue().AsFloat());
//Console.WriteLine(ati.GetBaseField().Get(2).GetValue().asString);
//Console.ReadLine();
}
public static void WriteCombinedAssets(this IAssetsFileProvider fp, AssetsFile assetsFile, string assetsFilePath)
{
if (assetsFilePath.EndsWith("split0"))
{
throw new ArgumentException("Don't pass in filenames with split0, pass in the original.");
}
fp.DeleteFiles(assetsFilePath + ".split*");
using (var ms = new MemoryStream())
{
assetsFile.Write(ms);
ms.Seek(0, SeekOrigin.Begin);
fp.Write(assetsFilePath, ms.ToArray(), true, true);
}
}
public static void GenerateLevelFiles(AssetsManager am, AssetsFileInstance inst)
{
EditorUtility.DisplayProgressBar("HKEdit", "Reading dependencies...", 0.5f);
am.UpdateDependencies();
//quicker asset id lookup
for (int i = 0; i < am.files.Count; i++)
{
AssetsFileInstance afi = am.files[i];
if (i % 100 == 0)
{
EditorUtility.DisplayProgressBar("HKEdit", "Generating QLTs...", (float)i / am.files.Count);
}
afi.table.GenerateQuickLookupTree();
}
ClassDatabaseFile cldb = am.classFile;
AssetsFileTable table = inst.table;
ReferenceCrawler crawler = new ReferenceCrawler(am);
List <AssetFileInfoEx> initialGameObjects = table.GetAssetsOfType(0x01);
for (int i = 0; i < initialGameObjects.Count; i++)
{
if (i % 100 == 0)
{
EditorUtility.DisplayProgressBar("HKEdit", "Recursing GameObject dependencies... (step 1/3)", (float)i / initialGameObjects.Count);
}
AssetFileInfoEx inf = initialGameObjects[i];
crawler.AddReference(new AssetID(inst.path, (long)inf.index), false);
crawler.FindReferences(inst, inf);
}
Dictionary <AssetID, AssetID> glblToLcl = crawler.references;
List <Type_0D> types = new List <Type_0D>();
List <string> typeNames = new List <string>();
Dictionary <string, AssetsFileInstance> fileToInst = am.files.ToDictionary(d => d.path);
int j = 0;
foreach (KeyValuePair <AssetID, AssetID> id in glblToLcl)
{
if (j % 100 == 0)
{
EditorUtility.DisplayProgressBar("HKEdit", "Rewiring asset pointers... (step 2/3)", (float)j / glblToLcl.Count);
}
AssetsFileInstance depInst = fileToInst[id.Key.fileName];
AssetFileInfoEx depInf = depInst.table.getAssetInfo((ulong)id.Key.pathId);
ClassDatabaseType clType = AssetHelper.FindAssetClassByID(cldb, depInf.curFileType);
string clName = clType.name.GetString(cldb);
if (!typeNames.Contains(clName))
{
Type_0D type0d = C2T5.Cldb2TypeTree(cldb, clName);
type0d.classId = (int)depInf.curFileType;
types.Add(type0d);
typeNames.Add(clName);
}
crawler.ReplaceReferences(depInst, depInf, id.Value.pathId);
j++;
}
EditorUtility.DisplayProgressBar("HKEdit", "Saving scene... (step 3/3)", 1f);
types.Add(CreateEditDifferTypeTree(cldb));
List <Type_0D> assetTypes = new List <Type_0D>()
{
C2T5.Cldb2TypeTree(cldb, 0x1c),
C2T5.Cldb2TypeTree(cldb, 0x30),
C2T5.Cldb2TypeTree(cldb, 0x53)
};
string origFileName = Path.GetFileNameWithoutExtension(inst.path);
string sceneGuid = CreateMD5(origFileName);
string ExportedScenes = Path.Combine("Assets", "ExportedScenes");
//circumvents "!BeginsWithCaseInsensitive(file.pathName, AssetDatabase::kAssetsPathWithSlash)' assertion
string ExportedScenesData = "ExportedScenesData";
CreateMetaFile(sceneGuid, Path.Combine(ExportedScenes, origFileName + ".unity.meta"));
AssetsFile sceneFile = new AssetsFile(new AssetsFileReader(new MemoryStream(BundleCreator.CreateBlankAssets(ver, types))));
AssetsFile assetFile = new AssetsFile(new AssetsFileReader(new MemoryStream(BundleCreator.CreateBlankAssets(ver, assetTypes))));
byte[] sceneFileData;
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter w = new AssetsFileWriter(ms))
{
w.bigEndian = false;
//unity editor won't load whole assets files by guid, so we have to use hardcoded paths
sceneFile.dependencies.pDependencies = new AssetsFileDependency[]
{
CreateDependency(ExportedScenesData + "/" + origFileName + "-data.assets"),
CreateScriptDependency(Constants.editDifferMsEditorScriptHash, Constants.editDifferLsEditorScriptHash)
};
sceneFile.dependencies.dependencyCount = 2;
sceneFile.preloadTable.items = new AssetPPtr[]
{
new AssetPPtr(2, 11500000)
};
sceneFile.preloadTable.len = 1;
sceneFile.Write(w, 0, crawler.sceneReplacers.Concat(crawler.sceneMonoReplacers).ToArray(), 0);
sceneFileData = ms.ToArray();
}
byte[] assetFileData;
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter w = new AssetsFileWriter(ms))
{
w.bigEndian = false;
assetFile.Write(w, 0, crawler.assetReplacers.ToArray(), 0);
assetFileData = ms.ToArray();
}
File.WriteAllBytes(Path.Combine(ExportedScenes, origFileName + ".unity"), sceneFileData);
File.WriteAllBytes(Path.Combine(ExportedScenesData, origFileName + "-data.assets"), assetFileData);
File.WriteAllText(Path.Combine(ExportedScenesData, origFileName + ".metadata"), CreateHKWEMetaFile(am, inst));
EditorUtility.ClearProgressBar();
}
private static void LoadScene()
{
am = new AssetsManager();
am.LoadClassPackage("cldb.dat");
am.useTemplateFieldCache = true;
am.updateAfterLoad = false;
hkDir = Util.SteamHelper.GetHollowKnightDataPath();
var globalgamemanagers = am.LoadAssetsFile(Path.Combine(hkDir, "globalgamemanagers"), false);
var buildSettings = globalgamemanagers.table.getAssetInfo(11);
var baseField = am.GetATI(globalgamemanagers.file, buildSettings).GetBaseField();
var scenesArray = baseField.Get("scenes").Get("Array");
// TODO: Allow level to be selected
const int level = 0;
var levelName = scenesArray[level].GetValue().AsString().Substring(14);
levelName = levelName.Substring(0, levelName.Length - 6);
progressBarTitle = "Loading Scene #" + level + ": " + levelName;
if (ShouldCancel("Checking workspace", 0.2f))
{
return;
}
if (!baseField.Get("m_Version").GetValue().AsString().Equals(Application.unityVersion))
{
EditorUtility.ClearProgressBar();
EditorUtility.DisplayDialog("Incorrect Unity version!", " You are using " +
Application.unityVersion + " but the assets are compiled for version " +
baseField.Get("m_Version").GetValue().AsString(), "Ok");
return;
}
unityVersion = Application.unityVersion;
if (!Directory.Exists(scenesDir))
{
Directory.CreateDirectory(scenesDir);
}
if (!Directory.Exists(dataDir))
{
Directory.CreateDirectory(dataDir);
}
var metaFilePath = Path.Combine(scenesDir, "level" + level + ".unity.meta");
var sceneFilePath = Path.Combine(scenesDir, "level" + level + ".unity");
var assetsFilePath = Path.Combine(dataDir, "level" + level + ".assets");
if (File.Exists(sceneFilePath))
{
if (EditorUtility.DisplayDialog("Overwrite scene?", "" +
" You have already exported this scene. Would you like to overwrite it or open the existing scene? ",
"Open Existing", "Overwrite"))
{
if (ShouldCancel("Opening Scene", 0.5f))
{
return;
}
EditorSceneManager.OpenScene(sceneFilePath);
EditorUtility.ClearProgressBar();
return;
}
else
{
File.Delete(sceneFilePath);
}
}
if (File.Exists(metaFilePath))
{
File.Delete(metaFilePath);
}
if (File.Exists(assetsFilePath))
{
File.Delete(assetsFilePath);
}
curSceneId = 1;
curAssetId = 1;
pointers = new Dictionary <AssetID, AssetID>();
sceneReplacers = new List <AssetsReplacer>();
assetReplacers = new List <AssetsReplacer>();
monoReplacers = new List <AssetsReplacer>();
if (ShouldCancel("Reading level file", 0.5f))
{
return;
}
var scenePath = Path.Combine(Util.SteamHelper.GetHollowKnightDataPath(), "level" + level);
var scene = am.LoadAssetsFile(scenePath, true);
if (ShouldCancel("Updating Dependencies", 0.8f))
{
return;
}
am.UpdateDependencies();
for (var i = 0; i < am.files.Count; i++)
{
if (i % 100 == 0 && ShouldCancel("Generating QLTs", (float)i / am.files.Count))
{
return;
}
am.files[i].table.GenerateQuickLookupTree();
}
var table = scene.table;
var gameObjects = table.GetAssetsOfType(0x01);
var gameObjectBaseFields = new Dictionary <AssetFileInfoEx, AssetTypeValueField>();
var c = 0;
for (c = 0; c < gameObjects.Count; c++)
{
if (c % 100 == 0 && ShouldCancel("Finding initial GameObjects", (float)c / gameObjects.Count))
{
return;
}
var gameObjectInfo = gameObjects[c];
var gameObjectBaseField = am.GetATI(scene.file, gameObjectInfo).GetBaseField();
AddPointer(new AssetID(scene.path, (long)gameObjectInfo.index), false);
gameObjectBaseFields.Add(gameObjectInfo, gameObjectBaseField);
}
c = 0;
foreach (var pair in gameObjectBaseFields)
{
if (c % 100 == 0 && ShouldCancel("Recursing GameObject dependencies", (float)c / gameObjectBaseFields.Count))
{
return;
}
FindNestedPointers(scene, pair.Value, pair.Key, false);
c++;
}
var types = new List <Type_0D>();
var typeNames = new List <string>();
var fileToInst = am.files.ToDictionary(d => d.path);
var j = 0;
foreach (var pair in pointers)
{
if (j % 100 == 0 && ShouldCancel("Rewiring asset pointers", (float)j / pointers.Count))
{
return;
}
var file = fileToInst[pair.Key.fileName];
var info = file.table.getAssetInfo((ulong)pair.Key.pathId);
var assetClass = AssetHelper.FindAssetClassByID(am.classFile, info.curFileType);
var assetName = assetClass.name.GetString(am.classFile);
if (!typeNames.Contains(assetName))
{
var type0d = C2T5.Cldb2TypeTree(am.classFile, assetName);
type0d.classId = (int)info.curFileType;
types.Add(type0d);
typeNames.Add(assetName);
}
ReplacePointers(file, info, pair.Value.pathId);
j++;
}
if (ShouldCancel("Saving scene", 1))
{
return;
}
List <Type_0D> assetTypes = new List <Type_0D>()
{
C2T5.Cldb2TypeTree(am.classFile, 0x1c), // audioclip
C2T5.Cldb2TypeTree(am.classFile, 0x30), // shader
C2T5.Cldb2TypeTree(am.classFile, 0x53) // texture2d
};
var sceneGuid = Util.UnityHelper.CreateMD5(levelName);
UnityHelper.CreateMetaFile(sceneGuid, metaFilePath);
var sceneFile = new AssetsFile(new AssetsFileReader(new MemoryStream(BundleCreator.CreateBlankAssets(unityVersion, types))));
var assetFile = new AssetsFile(new AssetsFileReader(new MemoryStream(BundleCreator.CreateBlankAssets(unityVersion, assetTypes))));
byte[] sceneFileData;
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter w = new AssetsFileWriter(ms))
{
w.bigEndian = false;
sceneFile.dependencies.pDependencies = new AssetsFileDependency[]
{
UnityHelper.CreateDependency(assetsFilePath),
};
sceneFile.dependencies.dependencyCount = 1;
sceneFile.preloadTable.items = new AssetPPtr[] {};
sceneFile.preloadTable.len = 0;
sceneFile.Write(w, 0, sceneReplacers.Concat(monoReplacers).ToArray(), 0);
sceneFileData = ms.ToArray();
}
byte[] assetFileData;
using (var ms = new MemoryStream())
using (var w = new AssetsFileWriter(ms))
{
w.bigEndian = false;
assetFile.Write(w, 0, assetReplacers.ToArray(), 0);
assetFileData = ms.ToArray();
}
File.WriteAllBytes(sceneFilePath, sceneFileData);
File.WriteAllBytes(assetsFilePath, assetFileData);
if (ShouldCancel("Refreshing Assets", 0.95f))
{
return;
}
AssetDatabase.Refresh();
EditorUtility.ClearProgressBar();
}
private static void ApplyEmip(string[] args)
{
HashSet <string> flags = GetFlags(args);
string emipFile = args[1];
string rootDir = args[2];
if (!File.Exists(emipFile))
{
Console.WriteLine($"File {emipFile} does not exist!");
return;
}
InstallerPackageFile instPkg = new InstallerPackageFile();
FileStream fs = File.OpenRead(emipFile);
AssetsFileReader r = new AssetsFileReader(fs);
instPkg.Read(r, true);
Console.WriteLine($"Installing emip...");
Console.WriteLine($"{instPkg.modName} by {instPkg.modCreators}");
Console.WriteLine(instPkg.modDescription);
foreach (var affectedFile in instPkg.affectedFiles)
{
string affectedFileName = Path.GetFileName(affectedFile.path);
string affectedFilePath = Path.Combine(rootDir, affectedFile.path);
if (affectedFile.isBundle)
{
string decompFile = $"{affectedFilePath}.decomp";
string modFile = $"{affectedFilePath}.mod";
string bakFile = GetNextBackup(affectedFilePath);
if (bakFile == null)
{
return;
}
if (flags.Contains("-md"))
{
decompFile = null;
}
Console.WriteLine($"Decompressing {affectedFileName} to {decompFile??"memory"}...");
AssetBundleFile bun = DecompressBundle(affectedFilePath, decompFile);
List <BundleReplacer> reps = new List <BundleReplacer>();
foreach (var rep in affectedFile.replacers)
{
var bunRep = (BundleReplacer)rep;
if (bunRep is BundleReplacerFromAssets)
{
//read in assets files from the bundle for replacers that need them
string assetName = bunRep.GetOriginalEntryName();
var bunRepInf = BundleHelper.GetDirInfo(bun, assetName);
long pos = bun.bundleHeader6.GetFileDataOffset() + bunRepInf.offset;
bunRep.Init(bun.reader, pos, bunRepInf.decompressedSize);
}
reps.Add(bunRep);
}
Console.WriteLine($"Writing {modFile}...");
FileStream mfs = File.OpenWrite(modFile);
AssetsFileWriter mw = new AssetsFileWriter(mfs);
bun.Write(mw, reps, instPkg.addedTypes); //addedTypes does nothing atm
mfs.Close();
bun.Close();
Console.WriteLine($"Swapping mod file...");
File.Move(affectedFilePath, bakFile);
File.Move(modFile, affectedFilePath);
if (!flags.Contains("-kd") && !flags.Contains("-md") && File.Exists(decompFile))
{
File.Delete(decompFile);
}
Console.WriteLine($"Done.");
}
else //isAssetsFile
{
string modFile = $"{affectedFilePath}.mod";
string bakFile = GetNextBackup(affectedFilePath);
if (bakFile == null)
{
return;
}
FileStream afs = File.OpenRead(affectedFilePath);
AssetsFileReader ar = new AssetsFileReader(afs);
AssetsFile assets = new AssetsFile(ar);
List <AssetsReplacer> reps = new List <AssetsReplacer>();
foreach (var rep in affectedFile.replacers)
{
var assetsReplacer = (AssetsReplacer)rep;
reps.Add(assetsReplacer);
}
Console.WriteLine($"Writing {modFile}...");
FileStream mfs = File.OpenWrite(modFile);
AssetsFileWriter mw = new AssetsFileWriter(mfs);
assets.Write(mw, 0, reps, 0, instPkg.addedTypes);
mfs.Close();
ar.Close();
Console.WriteLine($"Swapping mod file...");
File.Move(affectedFilePath, bakFile);
File.Move(modFile, affectedFilePath);
Console.WriteLine($"Done.");
}
}
return;
}
public static byte[] CreateBundleFromLevel(AssetsManager am, /*byte[] data,*/ AssetsFileInstance inst, string sceneName, DiffFile diffFile, string bunPath)
{
AssetsFile file = inst.file;
AssetsFileTable table = inst.table;
string folderName = Path.GetDirectoryName(inst.path);
//string sceneName = Path.GetFileNameWithoutExtension(inst.path) + "_mod";
List <AssetsReplacer> assetsSA = new List <AssetsReplacer>();
List <AssetFileInfoEx> infos = table.pAssetFileInfo.ToList();
//List<int> typeIds = new List<int>();
//foreach (AssetFileInfoEx info in infos)
//{
// int typeId = (int)info.curFileType;
// if (!typeIds.Contains(typeId) && typeId != 0x72)
// typeIds.Add(typeId);
//}
assetsSA.Add(PreloadData.CreatePreloadData(1));
assetsSA.Add(BundleMeta.CreateBundleInformation(sceneName, 2));
//todo: pull from original assets file, cldb is not always update to date
List <Type_0D> types = new List <Type_0D>();
//foreach (int typeId in typeIds)
//{
// types.Add(C2T5.Cldb2TypeTree(am.classFile, typeId));
//}
List <Type_0D> typesSA = new List <Type_0D>
{
C2T5.Cldb2TypeTree(am.classFile, 0x96), //PreloadData
C2T5.Cldb2TypeTree(am.classFile, 0x8E) //AssetBundle
};
const string ver = "2017.4.10f1";
List <AssetsReplacer> replacers = new List <AssetsReplacer>();
//UnityEngine.Debug.Log("HKWE DM " + diffFile.magic);
//UnityEngine.Debug.Log("HKWE GC " + diffFile.changes.Count + diffFile.adds.Count + diffFile.removes.Count);
//AssetsReplacerFromMemory mem = MoveTest.RunMoveTest(table.getAssetInfo(2642), am.GetATI(file, table.getAssetInfo(2642)).GetBaseField(), 2642) as AssetsReplacerFromMemory;
foreach (GameObjectChange goChange in diffFile.changes)
{
//UnityEngine.Debug.Log("HKWE GO " + goChange.pathId);
foreach (ComponentChangeOrAdd compChange in goChange.changes)
{
AssetFileInfoEx goInfo = table.getAssetInfo((ulong)goChange.pathId);
AssetTypeValueField goBaseField = am.GetATI(file, goInfo).GetBaseField();
AssetTypeValueField compPptr = goBaseField.Get("m_Component").Get("Array")[(uint)compChange.componentIndex].Get("component");
AssetsManager.AssetExternal compExt = am.GetExtAsset(inst, compPptr);
AssetFileInfoEx compInfo = compExt.info;
AssetTypeValueField compBaseField = compExt.instance.GetBaseField();
//UnityEngine.Debug.Log("HKWE LR " + compInfo.index);
AssetsReplacer imAlreadyReplacer = ComponentDiffReplacer.DiffComponent(compInfo, compBaseField, am.classFile, compChange, compInfo.index);
replacers.Add(imAlreadyReplacer);
}
}
AssetsManager amBun = new AssetsManager(); //we create a new manager because the two filenames will probably conflict
amBun.classFile = am.classFile; //we can just reuse the classfile which is kinda hacky
AssetsFileInstance bunInst = amBun.LoadAssetsFile(new MemoryStream(GetBundleData(bunPath, 0)), "HKWEDiffs", false); //placeholder path since we have no deps
//rearrange the pathids immediately after the
//last one from the level to keep unity happy
ulong levelLargestPathID = 0;
foreach (AssetFileInfoEx inf in table.pAssetFileInfo)
{
if (inf.index > levelLargestPathID)
{
levelLargestPathID = inf.index;
}
}
ReferenceCrawler.ReorderIds(amBun, bunInst, levelLargestPathID + 1);
byte[] bunSAInst = GetBundleData(bunPath, 1);
//HashSet<ulong> addedDeps = new HashSet<ulong>();
foreach (AssetFileInfoEx inf in bunInst.table.pAssetFileInfo)
{
replacers.Add(MakeReplacer(inf.index, am, bunInst, inst, inf, bunSAInst, types));
}
//foreach (GameObjectInfo inf in diffFile.infos)
//{
// Debug.Log("7");
// ulong bunPathId = GetBundlePathId(amBun, bunInst, inf);
//
// AssetFileInfoEx objInf = bunInst.table.getAssetInfo(bunPathId);
// replacers.Add(MakeReplacer(bunPathId, am, bunInst, inst, objInf, bunSAInst, types));
//
// List<ulong> deps = ReferenceCrawler.CrawlPPtrs(amBun, bunInst, bunPathId);
// foreach (ulong dep in deps)
// {
// if (!addedDeps.Contains(dep))
// {
// addedDeps.Add(dep);
// AssetFileInfoEx depInf = bunInst.table.getAssetInfo(dep);
// //if (depInf.curFileType == 0x01 || depInf.curFileType == 0x04 || depInf.curFileType == 0xD4 || depInf.curFileType == 0x15 || depInf.curFileType == 0xD5)
// //{
// // continue;
// //}
// replacers.Add(MakeReplacer(dep, am, bunInst, inst, depInf, bunSAInst, types));
// }
// }
// ////its possible to get a collision but very unlikely since unity already randomizes ids which are 8 bytes long
// ////there's nothing here to test if a collision would be created so just hope that you don't win the lottery
// //ulong bunPathId = GetBundlePathId(amBun, bunInst, inf);
// ////AssetFileInfoEx afInf = bunInst.table.getAssetInfo(bunPathId);
// ////replacers.Add(MakeReplacer(bunPathId, afInf, bunInst.stream));
// //List<ulong> deps = ReferenceCrawler.CrawlPPtrs(am, bunInst, bunPathId);
// ////if (info.curFileType == 0x01 || info.curFileType == 0x04 || info.curFileType == 0xD4)
// ////{
// //// continue;
// ////}
// //foreach (ulong dep in deps)
// //{
// // AssetFileInfoEx depInf = bunInst.table.getAssetInfo(dep);
// // //MakeReplacer(dep, am, bunInst, inst, depInf, bunSAInst, types);
// // AssetsReplacerFromMemory ar = MakeReplacer(dep, am, bunInst, inst, depInf, bunSAInst, types);
// // //todo- I guess this was just for testing purposes to block out everything, remove this at some point
// // if (depInf.curFileType == 0x01 || depInf.curFileType == 0x04 || depInf.curFileType == 0xD4 || depInf.curFileType == 0x15 || depInf.curFileType == 0xD5) //depInf.curFileType == 0x1C
// // {
// // continue;
// // }
// // replacers.Add(ar);
// //}
//}
byte[] data = null;
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(ms))
{
//file.typeTree.hasTypeTree = true; //so we don't have to calculate hashes
//foreach (Type_0D type in file.typeTree.pTypes_Unity5)
//{
// if (!types.Any(t => t.classId == type.classId))
// {
// types.Insert(0, C2T5.Cldb2TypeTree(am.classFile, type.classId));
// }
//}
file.typeTree.pTypes_Unity5 = file.typeTree.pTypes_Unity5.Concat(types.ToArray()).ToArray();
//file.typeTree.pTypes_Unity5 = types.ToArray();
file.typeTree.fieldCount = (uint)file.typeTree.pTypes_Unity5.Length;
//file.typeTree.fieldCount = (uint)types.Count;
file.Write(writer, 0, replacers.ToArray(), 0);
data = ms.ToArray();
}
//File.WriteAllBytes("_bundlefinal1.unity3d", data);
byte[] blankDataSA = BundleCreator.CreateBlankAssets(ver, typesSA);
AssetsFile blankFileSA = new AssetsFile(new AssetsFileReader(new MemoryStream(blankDataSA)));
byte[] dataSA = null;
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(ms))
{
blankFileSA.Write(writer, 0, assetsSA.ToArray(), 0);
dataSA = ms.ToArray();
}
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(ms))
{
AssetsBundleFile bundle = BundleCreator.CreateBlankBundle(ver, data.Length, dataSA.Length, sceneName);
bundle.Write(writer);
writer.Write(dataSA);
writer.Write(data);
return(ms.ToArray());
}
}
public static void GenerateDiffFile(AssetsManager am, AssetsFileInstance buildInst, AssetsFileInstance sceneInst, HKWEMeta meta)
{
EditorUtility.DisplayProgressBar("HKEdit", "Reading dependencies...", 0.5f);
am.UpdateDependencies();
ClassDatabaseFile cldb = am.classFile;
DiffData result = new DiffData()
{
goChanges = new List <GameObjectChange>(),
goAdditions = new List <GameObjectAddition>()
};
Dictionary <EditDifferData, long> differToSceneId = new Dictionary <EditDifferData, long>();
Dictionary <long, EditDifferData> buildIdToDiffer = new Dictionary <long, EditDifferData>();
List <EditDifferData> differData = new List <EditDifferData>();
AssetsFileTable sceneTable = sceneInst.table;
List <AssetFileInfoEx> sceneGos = sceneTable.GetAssetsOfType(0x01);
for (int i = 0; i < sceneGos.Count; i++)
{
if (i % 100 == 0)
{
EditorUtility.DisplayProgressBar("HKEdit", "Finding diff IDs... (step 1/3)", (float)i / sceneGos.Count);
}
AssetFileInfoEx inf = sceneGos[i];
AssetTypeValueField baseField = am.GetATI(sceneInst.file, inf).GetBaseField();
AssetTypeValueField editDifferMono = GetEDMono(am, sceneInst, baseField);
EditDifferData diff = new EditDifferData()
{
fileId = editDifferMono.Get("fileId").GetValue().AsInt(),
pathId = editDifferMono.Get("pathId").GetValue().AsInt64(),
origPathId = editDifferMono.Get("origPathId").GetValue().AsInt64(),
newAsset = editDifferMono.Get("newAsset").GetValue().AsBool()
};
buildIdToDiffer[diff.origPathId] = diff;
differToSceneId[diff] = inf.index;
differData.Add(diff);
}
//////////////////////////
AssetsFileTable origTable = buildInst.table;
List <AssetFileInfoEx> origGos = origTable.GetAssetsOfType(0x01);
List <long> origDeletIds = new List <long>();
//int nextBundleId = 1;
//// == delete changes == //
//for (int i = 0; i < origGos.Count; i++)
//{
// if (i % 100 == 0)
// EditorUtility.DisplayProgressBar("HKEdit", "Checking for deletes... (step 2/3)", (float)i / origGos.Count);
// AssetFileInfoEx inf = sceneGos[i];
// if (!differData.Any(d => d.origPathId == inf.index))
// {
// GameObjectChange change = new GameObjectChange
// {
// flags = GameObjectChangeFlags.Deleted
// };
// result.goChanges.Add(change);
// origDeletIds.Add(inf.index);
// }
//}
// == add changes == //
//to get this working in a built game, we need
//built assets (ie pngs -> texture2d) the problem
//is there's no easy way to direct unity to do that
//without loading the scene and using unity's api
//but we can pull out assets into a prefab and build
//the prefab but there are problems with duplicate
//dependencies being copied, so we pack them all
//into one place so that doesn't happen
//(for reference, in hkwe1, each gameobject got
//its own prefab)
//find dependencies
ReferenceCrawlerBundle createdCrawler = new ReferenceCrawlerBundle(am); //assets created by the user in the ditor
ReferenceCrawlerBundle existingCrawler = new ReferenceCrawlerBundle(am); //assets that already existed in the scene
for (int i = 0; i < differData.Count; i++)
{
if (i % 100 == 0)
{
EditorUtility.DisplayProgressBar("HKEdit", "Checking for additions... (step 2/3)", (float)i / differData.Count);
}
EditDifferData dat = differData[i];
if (dat.newAsset)
{
long sceneId = differToSceneId[dat];
AssetFileInfoEx inf = sceneInst.table.GetAssetInfo(sceneId);
createdCrawler.SetReferences(sceneInst, inf);
GameObjectAddition addition = new GameObjectAddition
{
bundleId = createdCrawler.GetNextId(), //?
sceneId = dat.pathId,
dependencies = new List <GameObjectAdditionDependency>()
};
//nextBundleId++;
foreach (KeyValuePair <AssetID, AssetID> goRef in createdCrawler.references)
{
addition.dependencies.Add(new GameObjectAdditionDependency
{
sceneId = goRef.Key.pathId,
bundleId = goRef.Value.pathId
});
}
result.goAdditions.Add(addition);
}
else
{
long newPathId = differToSceneId[dat];
AssetFileInfoEx inf = sceneInst.table.GetAssetInfo(newPathId);
existingCrawler.SetReferences(sceneInst, inf);
}
}
//load up all created assets into a prefab
List <Type_0D> types = new List <Type_0D>();
List <string> typeNames = new List <string>();
foreach (AssetsReplacer rep in createdCrawler.sceneReplacers)
{
ClassDatabaseType clType = AssetHelper.FindAssetClassByID(cldb, (uint)rep.GetClassID());
string clName = clType.name.GetString(cldb);
if (!typeNames.Contains(clName))
{
Type_0D type0d = C2T5.Cldb2TypeTree(cldb, clName);
type0d.classId = clType.classId;
types.Add(type0d);
typeNames.Add(clName);
}
}
List <AssetsReplacer> replacers = new List <AssetsReplacer>();
replacers.Add(CreatePrefabAsset(2)); //better hope id 2 is a gameobject
replacers.AddRange(createdCrawler.sceneReplacers);
AssetsFile createdFile = new AssetsFile(new AssetsFileReader(new MemoryStream(BundleCreator.CreateBlankAssets(ver, types))));
byte[] data;
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(ms))
{
createdFile.Write(writer, 0, replacers, 0);
data = ms.ToArray();
}
}
public static byte[] CreateBundleFromLevel(AssetsManager am, AssetsFileInstance inst)
{
EditorUtility.DisplayProgressBar("HKEdit", "Reading Files...", 0f);
am.UpdateDependencies();
//quicker asset id lookup
for (int i = 0; i < am.files.Count; i++)
{
AssetsFileInstance afi = am.files[i];
EditorUtility.DisplayProgressBar("HKEdit", "Generating QLTs", (float)i / am.files.Count);
afi.table.GenerateQuickLookupTree();
}
//setup
AssetsFile file = inst.file;
AssetsFileTable table = inst.table;
string folderName = Path.GetDirectoryName(inst.path);
List <AssetFileInfoEx> infos = table.pAssetFileInfo.ToList();
List <string> fileNames = new List <string>();
Dictionary <AssetID, byte[]> deps = new Dictionary <AssetID, byte[]>();
fileNames.Add(inst.name);
//add own ids to list so we don't reread them
foreach (AssetFileInfoEx info in infos)
{
if (info.curFileType != 1)
{
continue;
}
AssetID id = new AssetID(inst.name, (long)info.index);
deps.Add(id, null);
}
//look through each field in each asset in this file
for (int i = 0; i < infos.Count; i++)
{
AssetFileInfoEx info = infos[i];
if (info.curFileType != 1)
{
continue;
}
EditorUtility.DisplayProgressBar("HKEdit", "Crawling PPtrs", (float)i / infos.Count);
ReferenceCrawler.CrawlPPtrs(am, inst, info.index, fileNames, deps);
}
//add typetree data for dependencies
long curId = 1;
List <Type_0D> types = new List <Type_0D>();
List <string> typeNames = new List <string>();
List <AssetsReplacer> assets = new List <AssetsReplacer>();
Dictionary <string, AssetsFileInstance> insts = new Dictionary <string, AssetsFileInstance>();
//asset id is our custom id that uses filename/pathid instead of fileid/pathid
//asset id to path id
Dictionary <AssetID, long> aidToPid = new Dictionary <AssetID, long>();
//script id to mono id
Dictionary <ScriptID, ushort> sidToMid = new Dictionary <ScriptID, ushort>();
uint lastId = 0;
ushort nextMonoId = 0;
int depCount = 0;
foreach (KeyValuePair <AssetID, byte[]> dep in deps)
{
EditorUtility.DisplayProgressBar("HKEdit", "Fixing Dependencies", (float)depCount / deps.Keys.Count);
AssetID id = dep.Key;
byte[] assetData = dep.Value;
AssetsFileInstance afInst = null;
if (insts.ContainsKey(id.fileName))
{
afInst = insts[id.fileName];
}
else
{
afInst = am.files.First(f => f.name == id.fileName);
}
if (afInst == null)
{
continue;
}
AssetFileInfoEx inf = afInst.table.getAssetInfo((ulong)id.pathId);
if (lastId != inf.curFileType)
{
lastId = inf.curFileType;
}
ClassDatabaseType clType = AssetHelper.FindAssetClassByID(am.classFile, inf.curFileType);
string clName = clType.name.GetString(am.classFile);
ushort monoIndex = 0xFFFF;
if (inf.curFileType != 0x72)
{
if (!typeNames.Contains(clName))
{
Type_0D type0d = C2T5.Cldb2TypeTree(am.classFile, clName);
type0d.classId = (int)inf.curFileType; //?
types.Add(type0d);
typeNames.Add(clName);
}
}
else
{
//unused for now
AssetTypeValueField baseField = am.GetATI(afInst.file, inf).GetBaseField();
AssetTypeValueField m_Script = baseField.Get("m_Script");
AssetTypeValueField scriptBaseField = am.GetExtAsset(afInst, m_Script).instance.GetBaseField();
string m_ClassName = scriptBaseField.Get("m_ClassName").GetValue().AsString();
string m_Namespace = scriptBaseField.Get("m_Namespace").GetValue().AsString();
string m_AssemblyName = scriptBaseField.Get("m_AssemblyName").GetValue().AsString();
ScriptID sid = new ScriptID(m_ClassName, m_Namespace, m_AssemblyName);
if (!sidToMid.ContainsKey(sid))
{
MonoClass mc = new MonoClass();
mc.Read(m_ClassName, Path.Combine(Path.Combine(Path.GetDirectoryName(inst.path), "Managed"), m_AssemblyName), afInst.file.header.format);
Type_0D type0d = C2T5.Cldb2TypeTree(am.classFile, clName);
TemplateFieldToType0D typeConverter = new TemplateFieldToType0D();
TypeField_0D[] monoFields = typeConverter.TemplateToTypeField(mc.children, type0d);
type0d.pStringTable = typeConverter.stringTable;
type0d.stringTableLen = (uint)type0d.pStringTable.Length;
type0d.scriptIndex = nextMonoId;
type0d.pTypeFieldsEx = type0d.pTypeFieldsEx.Concat(monoFields).ToArray();
type0d.typeFieldsExCount = (uint)type0d.pTypeFieldsEx.Length;
types.Add(type0d);
sidToMid.Add(sid, nextMonoId);
nextMonoId++;
}
monoIndex = sidToMid[sid];
}
aidToPid.Add(id, curId);
AssetsReplacer rep = new AssetsReplacerFromMemory(0, (ulong)curId, (int)inf.curFileType, monoIndex, assetData);
assets.Add(rep);
curId++;
depCount++;
}
byte[] blankData = BundleCreator.CreateBlankAssets(ver, types);
AssetsFile blankFile = new AssetsFile(new AssetsFileReader(new MemoryStream(blankData)));
EditorUtility.DisplayProgressBar("HKEdit", "Writing first file...", 0f);
byte[] data = null;
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(ms))
{
blankFile.Write(writer, 0, assets.ToArray(), 0);
data = ms.ToArray();
}
//File.WriteAllBytes("debug.assets", data);
MemoryStream msn = new MemoryStream(data);
AssetsManager amn = new AssetsManager();
amn.classFile = am.classFile;
AssetsFileInstance instn = amn.LoadAssetsFile(msn, ((FileStream)inst.file.reader.BaseStream).Name, false);
instn.table.GenerateQuickLookupTree();
deps.Clear();
List <AssetsReplacer> assetsn = new List <AssetsReplacer>();
//gameobject id to mono id
Dictionary <long, long> gidToMid = new Dictionary <long, long>();
long nextBehaviourId = (long)instn.table.pAssetFileInfo.Max(i => i.index) + 1;
CreateEditDifferTypeTree(amn.classFile, instn);
CreateSceneMetadataTypeTree(amn.classFile, instn);
Random rand = new Random();
rand.Next();
foreach (KeyValuePair <AssetID, long> kvp in aidToPid)
{
AssetFileInfoEx inf = instn.table.getAssetInfo((ulong)kvp.Value);
if (inf.curFileType == 0x01)
{
gidToMid.Add(kvp.Value, nextBehaviourId);
assetsn.Add(CreateEditDifferMonoBehaviour(kvp.Value, kvp.Key, nextBehaviourId++, rand));
}
}
for (int i = 0; i < instn.table.pAssetFileInfo.Length; i++)
{
AssetFileInfoEx inf = instn.table.pAssetFileInfo[i];
EditorUtility.DisplayProgressBar("HKEdit", "Crawling PPtrs", (float)i / instn.table.pAssetFileInfo.Length);
ReferenceCrawler.CrawlReplacePPtrs(amn, instn, inf.index, fileNames, deps, aidToPid, gidToMid);
}
//add monoscript assets to preload table to make unity happy
List <AssetPPtr> preloadPptrs = new List <AssetPPtr>();
preloadPptrs.Add(new AssetPPtr(1, 11500000));
preloadPptrs.Add(new AssetPPtr(2, 11500000));
foreach (KeyValuePair <AssetID, byte[]> dep in deps)
{
AssetID id = dep.Key;
byte[] assetData = dep.Value;
long pid = id.pathId;
if (pid == 1)
{
assetData = AddMetadataMonobehaviour(assetData, nextBehaviourId);
}
AssetFileInfoEx inf = instn.table.getAssetInfo((ulong)pid);
ushort monoId = instn.file.typeTree.pTypes_Unity5[inf.curFileTypeOrIndex].scriptIndex;
assetsn.Add(new AssetsReplacerFromMemory(0, (ulong)pid, (int)inf.curFileType, monoId, assetData));
if (inf.curFileType == 0x73)
{
preloadPptrs.Add(new AssetPPtr(0, (ulong)pid));
}
}
List <long> usedIds = assetsn.Select(a => (long)a.GetPathID()).ToList();
//will break if no gameobjects but I don't really care at this point
assetsn.Add(CreateSceneMetadataMonoBehaviour(1, nextBehaviourId++, inst.name, usedIds));
instn.file.preloadTable.items = preloadPptrs.ToArray();
instn.file.preloadTable.len = (uint)instn.file.preloadTable.items.Length;
//add dependencies to monobehaviours
List <AssetsFileDependency> fileDeps = new List <AssetsFileDependency>();
AddScriptDependency(fileDeps, Constants.editDifferMsEditorScriptHash, Constants.editDifferLsEditorScriptHash);
AddScriptDependency(fileDeps, Constants.sceneMetadataMsEditorScriptHash, Constants.sceneMetadataLsEditorScriptHash);
instn.file.dependencies.pDependencies = fileDeps.ToArray();
instn.file.dependencies.dependencyCount = (uint)fileDeps.Count;
EditorUtility.DisplayProgressBar("HKEdit", "Writing second file...", 0f);
byte[] datan = null;
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(ms))
{
instn.file.Write(writer, 0, assetsn.ToArray(), 0);
datan = ms.ToArray();
}
EditorUtility.ClearProgressBar();
return(datan);
}
