private void DownloadSingleFile(string filename)
{
try
{
Directory.CreateDirectory($"{path}/tmp/{filename}");
using (var client = new WebClient())
{
client.DownloadFile($"{assetUrl}{filename}.bundle", $"{path}/tmp/{filename}/{filename}.bundle");
}
List <string> pathes = new List <string>();
pathes.Add($"{path}/tmp/{filename}/{filename}.bundle");
var gameStructure = GameStructure.Load(pathes);
//EngineAssetExporter engineExporter = new EngineAssetExporter();
//gameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Texture2D, engineExporter);
TextureAssetExporter textureExporter = new TextureAssetExporter(this.path);
gameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Texture2D, textureExporter);
//gameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Texture2DArray, textureExporter);
gameStructure.Export($"{path}/exported/{filename}/", Texture2DAssetSelector);
}
catch (Exception ex)
{
Console.WriteLine($"Error downloading file '{filename}'! you may ignore this.");
}
}
public void Load(IReadOnlyList <string> args)
{
#if !DEBUG_PROGRAM
try
#endif
{
GameStructure = GameStructure.Load(args);
Validate();
string exportPath = Path.Combine("Ripped", GameStructure.Name);
PrepareExportDirectory(exportPath);
#if DEBUG
EngineAssetExporter engineExporter = new EngineAssetExporter();
GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Material, engineExporter);
GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Texture2D, engineExporter);
GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Mesh, engineExporter);
GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Shader, engineExporter);
GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Font, engineExporter);
GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Sprite, engineExporter);
#endif
GameStructure.Export(exportPath, AssetSelector);
Logger.Log(LogType.Info, LogCategory.General, "Finished");
}
#if !DEBUG_PROGRAM
catch (Exception ex)
{
Logger.Log(LogType.Error, LogCategory.General, ex.ToString());
}
#endif
}
//Refer MonoManager, ScriptAssetExporter, ScriptExportManager
void DoExport(Func <MonoScript, bool> selector = null)
{
var managedPath = Path.Combine(GameDir, "Managed");
var globalgamemanagersPath = Path.Combine(GameDir, "globalgamemanagers.assets");
var gameStructure = GameStructure.Load(new string[]
{
globalgamemanagersPath,
managedPath
});
fileCollection = gameStructure.FileCollection;
if (selector == null)
{
selector = (o) => true;
}
var assets = fileCollection.FetchAssets().Where(o => o is MonoScript ms && selector(ms)).ToArray();
ScriptExportManager scriptManager = new ScriptExportManager(ExportPath);
Dictionary <Object, ScriptExportType> exportTypes = new Dictionary <Object, ScriptExportType>();
foreach (Object asset in assets)
{
MonoScript script = (MonoScript)asset;
ScriptExportType exportType = script.GetExportType(scriptManager);
exportTypes.Add(asset, exportType);
}
foreach (KeyValuePair <Object, ScriptExportType> exportType in exportTypes)
{
string path = scriptManager.Export(exportType.Value);
}
//scriptManager.ExportRest();
}
void DoExportAll()
{
Util.PrepareExportDirectory(ExportPath);
var managedPath = Path.Combine(GameDir, "Managed");
var globalgamemanagersPath = Path.Combine(GameDir, "globalgamemanagers.assets");
var gameStructure = GameStructure.Load(new string[]
{
globalgamemanagersPath,
managedPath
});
fileCollection = gameStructure.FileCollection;
fileCollection.AssemblyManager.ScriptingBackEnd = ScriptingBackEnd.Mono;
var scripts = fileCollection.FetchAssets().Where(o => o is MonoScript ms).ToArray();
foreach (Object asset in scripts)
{
MonoScript script = (MonoScript)asset;
if (ScriptByName)
{
using (MD5 md5 = MD5.Create())
{
var data = md5.ComputeHash(Encoding.UTF8.GetBytes($"{script.AssemblyName}.{script.Namespace}.{script.ClassName}"));
var newGuid = new Guid(data);
Util.SetGUID(script, newGuid);
}
}
}
fileCollection.Exporter.Export(ExportPath, fileCollection, scripts, options);
}
void DoExportAll()
{
Util.PrepareExportDirectory(ExportPath);
var managedPath = Path.Combine(GameDir, "Managed");
var mainAssetPath = GetMainAssetPath();
var gameStructure = GameStructure.Load(new string[]
{
mainAssetPath,
managedPath
});
fileCollection = gameStructure.FileCollection;
var scripts = fileCollection.FetchAssets().Where(o => o is MonoScript ms).ToArray();
foreach (Object asset in scripts)
{
MonoScript script = (MonoScript)asset;
if (ScriptByName)
{
using (MD5 md5 = MD5.Create())
{
var data = md5.ComputeHash(Encoding.UTF8.GetBytes($"{script.AssemblyName}.{script.Namespace}.{script.ClassName}"));
Util.SetGUID(script, data);
}
}
}
gameStructure.Export(ExportPath, asset => asset is MonoScript);
}
private void LoadFiles(object data)
{
string[] files = (string[])data;
OnImportStarted();
#if !DEBUG
try
#endif
{
GameStructure = GameStructure.Load(files);
}
#if !DEBUG
catch (SerializedFileException ex)
{
ReportCrash(ex);
return;
}
catch (Exception ex)
{
ReportCrash(ex);
return;
}
#endif
if (GameStructure.IsValid)
{
Validate();
}
OnImportFinished();
if (GameStructure.IsValid)
{
Dispatcher.Invoke(() =>
{
IntroText.Text += "Files have been loaded";
ExportButton.Visibility = Visibility.Visible;
Fileview.AddItem(GameStructure.FileCollection);
Fileview.Refresh();
#if VIRTUAL
OnExportButtonClicked(null, null);
#endif
}
);
}
else
{
Dispatcher.Invoke(() =>
{
OnResetButtonClicked(null, null);
Logger.Log(LogType.Warning, LogCategory.Import, "No game files found");
}
);
}
}
private GameStructureExporter(string gameDir, string exportPath, List <string> files)
{
GameDir = gameDir;
AssetPath = gameDir;
ExportPath = exportPath;
options = new ExportOptions()
{
Version = new Version(2017, 3, 0, VersionType.Final, 3),
Platform = Platform.NoTarget,
Flags = TransferInstructionFlags.NoTransferInstructionFlags,
};
m_GameStructure = GameStructure.Load(files);
var fileCollection = m_GameStructure.FileCollection;
var textureExporter = new TextureAssetExporter();
var engineExporter = new EngineAssetExporter();
fileCollection.Exporter.OverrideExporter(ClassIDType.Material, engineExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Mesh, engineExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Shader, new DummyShaderExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.Font, engineExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Texture2D, textureExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Cubemap, textureExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Sprite, engineExporter); //engine or texture exporter?
fileCollection.Exporter.EventExportStarted += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportStarted");
UpdateTitle($"EventExportStarted");
};
fileCollection.Exporter.EventExportPreparationStarted += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportPreparationStarted");
UpdateTitle($"EventExportPreparationStarted");
};
fileCollection.Exporter.EventExportPreparationFinished += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportPreparationFinished");
UpdateTitle($"EventExportPreparationFinished");
};
fileCollection.Exporter.EventExportFinished += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportFinished");
UpdateTitle($"EventExportFinished");
};
fileCollection.Exporter.EventExportStarted += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportStarted");
UpdateTitle($"EventExportStarted");
};
fileCollection.Exporter.EventExportProgressUpdated += (int number, int total) =>
{
UpdateTitle($"Exported {number / (float)total * 100:0.#} - {number} of {total}");
};
}
private void LoadFiles(object data)
{
string[] files = (string[])data;
#if !DEBUG
try
#endif
{
OnImportStarted();
GameStructure = GameStructure.Load(files);
Validate();
OnImportFinished();
}
#if !DEBUG
catch (SerializedFileException ex)
{
Dispatcher.Invoke(() =>
{
Logger.Log(LogType.Error, LogCategory.Import, ex.ToString());
AddHyperlinkToConsole("Go to: ", "Create issue", IssuePage);
AddHyperlinkToConsole("Attach file: ", ex.FileName, ex.FilePath);
MessageBox.Show(this, $"Please, create an issue on github page {IssuePage} with attached file '{ex.FilePath}'.",
"An error during loading process has occuered!", MessageBoxButton.OK, MessageBoxImage.Error);
});
return;
}
catch (Exception ex)
{
Dispatcher.Invoke(() =>
{
Logger.Log(LogType.Error, LogCategory.Import, ex.ToString());
AddHyperlinkToConsole("Go to: ", "Create issue", IssuePage);
MessageBox.Show(this, $"Please, create an issue on github page {IssuePage} with attached file that cause this error.",
"An error during loading process has occuered!", MessageBoxButton.OK, MessageBoxImage.Error);
});
return;
}
#endif
Dispatcher.Invoke(() =>
{
IntroText.Text = "Files has been loaded";
ExportButton.Visibility = Visibility.Visible;
#if VIRTUAL
ButtonAutomationPeer peer = new ButtonAutomationPeer(ExportButton);
IInvokeProvider invokeProv = peer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
invokeProv.Invoke();
#endif
}
);
}
// =====================================================
// Methods
// =====================================================
private void LoadFiles(object data)
{
string[] files = (string[])data;
GameStructure = GameStructure.Load(files);
Validate();
Dispatcher.Invoke(() =>
{
IntroText.Text = "Files has been loaded";
ExportButton.Visibility = Visibility.Visible;
}
);
}
protected GameDataBase(string GameBasePath)
{
using (var gameStructrue = GameStructure.Load(new[] { GameBasePath }))
{
var assests =
gameStructrue
.FileCollection
.FetchAssets()
.Where(assest => assest.ClassID == ClassIDType.MonoBehaviour)
.Cast <MonoBehaviour>() ?? throw new InvalidDataException();
ItemSet = GetProtoList <ItemProto>(assests);
RecipeSet = GetProtoList <RecipeProto>(assests);
StringSet = GetProtoList <StringProto>(assests);
}
}
void DoExportAll()
{
Util.PrepareExportDirectory(ExportPath);
var managedPath = Path.Combine(GameDir, "Managed");
var globalgamemanagersPath = Path.Combine(GameDir, "globalgamemanagers.assets");
var gameStructure = GameStructure.Load(new string[]
{
globalgamemanagersPath,
managedPath
});
fileCollection = gameStructure.FileCollection;
fileCollection.AssemblyManager.ScriptingBackEnd = ScriptingBackEnd.Mono;
var scripts = fileCollection.FetchAssets().Where(o => o is MonoScript ms).ToArray();
fileCollection.Exporter.Export(ExportPath, fileCollection, scripts, options);
}
private void LoadFiles(object data)
{
string[] files = (string[])data;
#if !DEBUG
try
#endif
{
GameStructure = GameStructure.Load(files);
Validate();
}
#if !DEBUG
catch (SerializedFileException ex)
{
Dispatcher.Invoke(() =>
{
Logger.Instance.Log(LogType.Error, LogCategory.Import, ex.ToString());
AddHyperlinkText("Go to: ", "Create issue", IssuePage);
AddHyperlinkText("Attach file: ", ex.FileName, ex.FilePath);
MessageBox.Show(this, $"Please, create an issue on github page {IssuePage} with attached file '{ex.FilePath}'.",
"An error during loading process has occuered!", MessageBoxButton.OK, MessageBoxImage.Error);
});
return;
}
catch (Exception ex)
{
Dispatcher.Invoke(() =>
{
Logger.Instance.Log(LogType.Error, LogCategory.Import, ex.ToString());
AddHyperlinkText("Go to: ", "Create issue", IssuePage);
MessageBox.Show(this, $"Please, create an issue on github page {IssuePage} with attached file that cause this error.",
"An error during loading process has occuered!", MessageBoxButton.OK, MessageBoxImage.Error);
});
return;
}
#endif
Dispatcher.Invoke(() =>
{
IntroText.Text = "Files has been loaded";
ExportButton.Visibility = Visibility.Visible;
}
);
}
private void LoadFiles(object data)
{
string[] files = (string[])data;
#if !DEBUG
try
#endif
{
OnImportStarted();
GameStructure = GameStructure.Load(files);
Validate();
OnImportFinished();
}
#if !DEBUG
catch (SerializedFileException ex)
{
ReportCrash(ex);
return;
}
catch (Exception ex)
{
ReportCrash(ex);
return;
}
#endif
Dispatcher.Invoke(() =>
{
IntroText.Text = "Files has been loaded";
ExportButton.Visibility = Visibility.Visible;
Fileview.AddItem(GameStructure.FileCollection);
Fileview.Refresh();
#if VIRTUAL
ButtonAutomationPeer peer = new ButtonAutomationPeer(ExportButton);
IInvokeProvider invokeProv = peer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
invokeProv.Invoke();
#endif
}
);
}
//Refer MonoManager, ScriptAssetExporter, ScriptExportManager
void DoExport(Func <MonoScript, bool> selector = null)
{
var managedPath = Path.Combine(GameDir, "Managed");
var globalgamemanagersPath = Path.Combine(GameDir, "globalgamemanagers.assets");
var gameStructure = GameStructure.Load(new string[]
{
globalgamemanagersPath,
managedPath
});
fileCollection = gameStructure.FileCollection;
if (selector == null)
{
selector = (o) => true;
}
var assets = fileCollection.FetchAssets().Where(o => o is MonoScript ms && selector(ms)).ToArray();
ScriptExportManager scriptManager = new ScriptExportManager(ExportPath);
Dictionary <Object, ScriptExportType> exportTypes = new Dictionary <Object, ScriptExportType>();
foreach (Object asset in assets)
{
MonoScript script = (MonoScript)asset;
if (ScriptByName)
{
using (MD5 md5 = MD5.Create())
{
var data = md5.ComputeHash(Encoding.UTF8.GetBytes($"{script.AssemblyName}.{script.Namespace}.{script.ClassName}"));
var newGuid = new Guid(data);
Util.SetGUID(script, newGuid);
}
}
ScriptExportType exportType = script.GetExportType(scriptManager);
exportTypes.Add(asset, exportType);
}
foreach (KeyValuePair <Object, ScriptExportType> exportType in exportTypes)
{
string path = scriptManager.Export(exportType.Value);
}
//scriptManager.ExportRest();
}
public GameStructureExporter(ExportSettings settings, List <string> files, Func <uTinyRipper.Classes.Object, bool> filter = null)
{
GameDir = settings.GameDir;
ExportPath = settings.ExportDir;
options = new ExportOptions()
{
Platform = Platform.NoTarget,
Flags = TransferInstructionFlags.NoTransferInstructionFlags,
};
GameStructure = GameStructure.Load(files);
if (string.IsNullOrEmpty(settings.ExportVersion))
{
options.Version = new Version(2017, 3, 0, VersionType.Final, 3);
}
else if (settings.ExportVersion.ToLower() == "detect")
{
//The version in unity default resources and unity_builtin_extra seem to differ from the game version
var versionCheckFile = GameStructure.FileCollection.Files.FirstOrDefault(f => !Path.GetFileName(f.Name).Contains("unity"));
if (versionCheckFile != null)
{
options.Version = versionCheckFile.Version;
Logger.Log(LogType.Info, LogCategory.Export, $"Version detected as {options.Version.ToString()}");
}
else
{
Logger.Log(LogType.Warning, LogCategory.Export, $"Could not detect version");
options.Version = new Version(2017, 3, 0, VersionType.Final, 3);
}
}
else
{
options.Version = new Version();
options.Version.Parse(settings.ExportVersion);
Logger.Log(LogType.Info, LogCategory.Export, $"Version set to {options.Version.ToString()}");
}
if (filter != null)
{
Filter = filter;
}
else
{
Filter = (obj) => true;
}
var fileCollection = GameStructure.FileCollection;
var textureExporter = new TextureAssetExporter();
var engineExporter = new EngineAssetExporter();
fileCollection.Exporter.OverrideExporter(ClassIDType.Material, engineExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Mesh, engineExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Shader, new CustomShaderAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.TextAsset, new TextAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.AudioClip, new AudioAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.Font, new FontAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.MovieTexture, new MovieTextureAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.Texture2D, textureExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Cubemap, textureExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Sprite, engineExporter); //engine or texture exporter?
fileCollection.Exporter.EventExportStarted += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportStarted");
UpdateTitle($"EventExportStarted");
};
fileCollection.Exporter.EventExportPreparationStarted += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportPreparationStarted");
UpdateTitle($"EventExportPreparationStarted");
};
fileCollection.Exporter.EventExportPreparationFinished += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportPreparationFinished");
UpdateTitle($"EventExportPreparationFinished");
};
fileCollection.Exporter.EventExportFinished += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportFinished");
UpdateTitle($"EventExportFinished");
};
fileCollection.Exporter.EventExportStarted += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportStarted");
UpdateTitle($"EventExportStarted");
};
fileCollection.Exporter.EventExportProgressUpdated += (int number, int total) =>
{
UpdateTitle($"Exported {number / (float)total * 100:0.#} - {number} of {total}");
};
if (settings.ScriptByName)
{
foreach (var asset in fileCollection.FetchAssets())
{
if (asset is MonoScript script)
{
using (MD5 md5 = MD5.Create())
{
var data = md5.ComputeHash(Encoding.UTF8.GetBytes($"{script.AssemblyName}.{script.Namespace}.{script.ClassName}"));
var newGuid = new Guid(data);
Util.SetGUID(script, newGuid);
}
}
}
}
if (settings.ShaderByName)
{
foreach (var asset in fileCollection.FetchAssets())
{
if (asset is Shader shader)
{
using (MD5 md5 = MD5.Create())
{
var data = md5.ComputeHash(Encoding.UTF8.GetBytes($"{shader.ValidName}"));
var newGuid = new Guid(data);
var engGuid = new EngineGUID(newGuid);
Util.SetGUID(shader, newGuid);
Console.WriteLine($"Set shader {shader.ValidName} to Guid {engGuid}");
}
}
}
}
}
public void rip(string[] args, string targetDir)
{
Logger.Instance = PythonLogger.Instance;
Config.IsAdvancedLog = true;
Config.IsGenerateGUIDByContent = false;
Config.IsExportDependencies = true;
if (args.Length == 0)
{
Console.WriteLine("No arguments");
return;
}
foreach (string arg in args)
{
if (FileMultiStream.Exists(arg))
{
continue;
}
if (DirectoryUtils.Exists(arg))
{
continue;
}
Console.WriteLine(FileMultiStream.IsMultiFile(arg) ?
$"File '{arg}' doesn't has all parts for combining" :
$"Neither file nor directory with path '{arg}' exists");
return;
}
try
{
GameStructure = GameStructure.Load(args);
Validate();
// MRH - can make this an option to include/exclude. Including will transcode, e.g. fsb (FSB5) into wav
GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.AudioClip, new AudioAssetExporter());
/* MRH - borrowing from the GUI... there seems to be much more work there than in the CLI
* uTinyRipperGUI.Exporters.TextureAssetExporter textureExporter = new uTinyRipperGUI.Exporters.TextureAssetExporter();
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Texture2D, textureExporter);
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Cubemap, textureExporter);
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Sprite, textureExporter);
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Shader, new uTinyRipperGUI.Exporters.ShaderAssetExporter());
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.TextAsset, new TextAssetExporter());
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Font, new FontAssetExporter());
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.MovieTexture, new MovieTextureAssetExporter());
*
* EngineAssetExporter engineExporter = new EngineAssetExporter();
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Material, engineExporter);
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Texture2D, engineExporter);
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Mesh, engineExporter);
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Shader, engineExporter);
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Font, engineExporter);
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.Sprite, engineExporter);
* GameStructure.FileCollection.Exporter.OverrideExporter(ClassIDType.MonoBehaviour, engineExporter);
*
* PrepareExportDirectory(targetDir);
*/
GameStructure.Export(targetDir, AssetSelector);
Logger.Log(LogType.Info, LogCategory.General, "Finished");
}
catch (Exception ex)
{
Logger.Log(LogType.Error, LogCategory.General, ex.ToString());
}
}
public GameStructureExporter(ExportSettings settings, IEnumerable <string> files)
{
GameDir = settings.GameDir;
ExportPath = settings.ExportDir;
GameStructure = GameStructure.Load(files);
Version version = new Version(2017, 3, 0, VersionType.Final, 3);
if (string.IsNullOrEmpty(settings.ExportVersion) || settings.ExportVersion.ToLower() == "detect")
{
//The version in unity default resources and unity_builtin_extra seem to differ from the game version
version = GameStructure.FileCollection.GameFiles.Values.Max(t => t.Version);
Logger.Log(LogType.Info, LogCategory.Export, $"Version detected as {version.ToString()}");
}
else
{
version = Version.Parse(settings.ExportVersion);
Logger.Log(LogType.Info, LogCategory.Export, $"Version set to {version.ToString()}");
}
options = new ExportOptions(
version,
Platform.NoTarget,
TransferInstructionFlags.NoTransferInstructionFlags
);
var fileCollection = GameStructure.FileCollection;
var textureExporter = new TextureAssetExporter();
var engineExporter = new EngineAssetExporter();
fileCollection.Exporter.OverrideExporter(ClassIDType.Material, engineExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Mesh, engineExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Shader, new CustomShaderAssetExporter(settings));
fileCollection.Exporter.OverrideExporter(ClassIDType.TextAsset, new TextAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.AudioClip, new AudioAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.Font, new FontAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.MovieTexture, new MovieTextureAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.Texture2D, engineExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Texture2D, textureExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Cubemap, textureExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Sprite, engineExporter); //engine or texture exporter?
fileCollection.Exporter.EventExportStarted += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportStarted");
UpdateTitle($"EventExportStarted");
};
fileCollection.Exporter.EventExportPreparationStarted += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportPreparationStarted");
UpdateTitle($"EventExportPreparationStarted");
};
fileCollection.Exporter.EventExportPreparationFinished += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportPreparationFinished");
UpdateTitle($"EventExportPreparationFinished");
};
fileCollection.Exporter.EventExportFinished += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportFinished");
UpdateTitle($"EventExportFinished");
};
fileCollection.Exporter.EventExportStarted += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportStarted");
UpdateTitle($"EventExportStarted");
};
fileCollection.Exporter.EventExportProgressUpdated += (int number, int total) =>
{
UpdateTitle($"Exported {number / (float)total * 100:0.#} - {number} of {total}");
};
if (settings.ScriptByName)
{
foreach (var asset in fileCollection.FetchAssets())
{
if (asset is MonoScript script)
{
using (MD5 md5 = MD5.Create())
{
var data = md5.ComputeHash(Encoding.UTF8.GetBytes($"{script.AssemblyName}.{script.Namespace}.{script.ClassName}"));
var newGuid = new Guid(data);
Util.SetGUID(script, newGuid);
}
}
}
}
if (settings.ShaderByName)
{
foreach (var asset in fileCollection.FetchAssets())
{
if (asset is Shader shader)
{
using (MD5 md5 = MD5.Create())
{
var data = md5.ComputeHash(Encoding.UTF8.GetBytes($"{shader.ValidName}"));
var newGuid = new Guid(data);
var engGuid = new GUID(newGuid);
Util.SetGUID(shader, newGuid);
Console.WriteLine($"Set shader {shader.ValidName} to Guid {engGuid}");
}
}
}
}
}
private GameStructureExporter(ExportSettings settings, List <string> files, Func <uTinyRipper.Classes.Object, bool> filter = null)
{
GameDir = settings.GameDir;
ExportPath = settings.ExportDir;
options = new ExportOptions()
{
Version = new Version(2017, 3, 0, VersionType.Final, 3),
Platform = Platform.NoTarget,
Flags = TransferInstructionFlags.NoTransferInstructionFlags,
};
m_GameStructure = GameStructure.Load(files);
if (filter != null)
{
Filter = filter;
}
else
{
Filter = (obj) => true;
}
var fileCollection = m_GameStructure.FileCollection;
var textureExporter = new TextureAssetExporter();
var engineExporter = new EngineAssetExporter();
fileCollection.Exporter.OverrideExporter(ClassIDType.Material, engineExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Mesh, engineExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Shader, new CustomShaderAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.TextAsset, new TextAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.AudioClip, new AudioAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.Font, new FontAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.MovieTexture, new MovieTextureAssetExporter());
fileCollection.Exporter.OverrideExporter(ClassIDType.Texture2D, textureExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Cubemap, textureExporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.Sprite, engineExporter); //engine or texture exporter?
fileCollection.Exporter.EventExportStarted += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportStarted");
UpdateTitle($"EventExportStarted");
};
fileCollection.Exporter.EventExportPreparationStarted += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportPreparationStarted");
UpdateTitle($"EventExportPreparationStarted");
};
fileCollection.Exporter.EventExportPreparationFinished += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportPreparationFinished");
UpdateTitle($"EventExportPreparationFinished");
};
fileCollection.Exporter.EventExportFinished += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportFinished");
UpdateTitle($"EventExportFinished");
};
fileCollection.Exporter.EventExportStarted += () =>
{
Logger.Log(LogType.Info, LogCategory.Export, "EventExportStarted");
UpdateTitle($"EventExportStarted");
};
fileCollection.Exporter.EventExportProgressUpdated += (int number, int total) =>
{
UpdateTitle($"Exported {number / (float)total * 100:0.#} - {number} of {total}");
};
if (settings.ScriptByName)
{
foreach (var asset in fileCollection.FetchAssets())
{
if (asset is MonoScript script)
{
using (MD5 md5 = MD5.Create())
{
var data = md5.ComputeHash(Encoding.UTF8.GetBytes($"{script.AssemblyName}.{script.Namespace}.{script.ClassName}"));
var newGuid = new Guid(data);
Util.SetGUID(script, newGuid);
}
}
}
}
if (settings.ShaderByName)
{
foreach (var asset in fileCollection.FetchAssets())
{
if (asset is Shader shader)
{
using (MD5 md5 = MD5.Create())
{
var data = md5.ComputeHash(Encoding.UTF8.GetBytes($"{shader.ValidName}"));
var newGuid = new Guid(data);
var engGuid = new EngineGUID(newGuid);
Util.SetGUID(shader, newGuid);
Console.WriteLine($"Set shader {shader.ValidName} to Guid {engGuid}");
}
}
}
}
}
public void Load(IReadOnlyList <string> args)
{
try
{
if (args?.Any() != true)
{
return;
}
PrepareExportDirectory("Ripped");
var gameDir = args[0];
var classes = args
.FirstOrDefault(arg => arg.StartsWith("--Types="))
.Substring("--Types=".Length)
.Split(',')
.Select(cls =>
{
if (Enum.TryParse <ClassIDType>(cls, out var result))
{
return(result);
}
return((ClassIDType)(-1));
})
.Where(v => ((int)(v)) >= 0)
.ToArray();
var filename = Path.GetFileName(gameDir);
var player = Path.Combine(gameDir, $"{filename}.exe");
var playerInfo = FileVersionInfo.GetVersionInfo(player);
var unityVersion = playerInfo.ProductVersion;
unityVersion = unityVersion.Substring(0, unityVersion.LastIndexOf('.'));
var gameStructure = GameStructure.Load(new[] { gameDir });
var fileCollection = gameStructure.FileCollection;
ShutItAllDown(fileCollection.Exporter);
fileCollection.Exporter.OverrideExporter(ClassIDType.MonoScript, new NoScriptExporter());
foreach (var cls in classes)
{
EnableExport(cls, fileCollection.Exporter);
}
Dictionary <string, Guid> AssemblyHash = new Dictionary <string, Guid>();
Dictionary <string, long> ScriptId = new Dictionary <string, long>();
var unityPlayerVersion = new System.Version(unityVersion);
var version = new Version(unityPlayerVersion.Major, unityPlayerVersion.Minor, unityPlayerVersion.Revision, VersionType.Final, 3);
var options = new ExportOptions(
version,
Platform.NoTarget,
TransferInstructionFlags.NoTransferInstructionFlags
);
var serializedFiles = fileCollection.GameFiles.Values;
fileCollection.Exporter.Export("Ripped", fileCollection, serializedFiles, options);
Logger.Log(LogType.Info, LogCategory.General, "Finished");
}
catch (Exception ex)
{
Logger.Log(LogType.Error, LogCategory.General, ex.ToString());
}
}
