public void Write(AssetsFileWriter writer)
{
writer.WriteNullTerminated(signature);
writer.Write(fileVersion);
writer.WriteNullTerminated(minPlayerVersion);
writer.WriteNullTerminated(fileEngineVersion);
writer.Write(totalFileSize);
writer.Write(compressedSize);
writer.Write(decompressedSize);
writer.Write(flags);
}
public static byte[] WriteToByteArray(this AssetTypeInstance instance)
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter w = new AssetsFileWriter(ms))
{
instance.Write(w);
data = ms.ToArray();
}
return(data);
}
public static byte[] WriteToByteArray(this AssetTypeValueField valueField)
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter w = new AssetsFileWriter(ms))
{
valueField.Write(w);
data = ms.ToArray();
}
return(data);
}
public ulong Write(ulong curFilePos, AssetsFileWriter writer)
{
writer.Write(version);
writer.Write(depth);
writer.Write(isArray);
writer.Write(typeStringOffset);
writer.Write(nameStringOffset);
writer.Write(size);
writer.Write(index);
writer.Write(flags);
return(writer.Position);
}
public static AssetsReplacer ConvertTexture(AssetTypeValueField baseField, ulong pathId, string folderPath)
{
//byte[] data = null;
AssetTypeValueField m_StreamData = baseField.Get("m_StreamData");
//int offset = (int)m_StreamData.Get("offset").GetValue().AsUInt();
//int size = (int)m_StreamData.Get("size").GetValue().AsUInt();
//
//if (size != 0)
//{
// string path = m_StreamData.Get("path").GetValue().AsString();
// using (FileStream stream = new FileStream(Path.Combine(folderPath, path), FileMode.Open))
// using (MemoryStream memStream = new MemoryStream())
// {
// long fileSize = stream.Length;
// data = new byte[size];
// stream.Position = offset;
//
// int bytesRead;
// var buffer = new byte[2048];
// while (((bytesRead = stream.Read(buffer, 0, Math.Min(2048, (offset + size) - (int)stream.Position))) > 0))
// {
// memStream.Write(buffer, 0, bytesRead);
// if (stream.Position >= offset + size)
// {
// break;
// }
// }
// data = memStream.ToArray();
// }
//}
//this may not be needed, instead change the path to a hardcoded path to the resS
//m_StreamData.Get("offset").value.value.asUInt32 = 0;
//m_StreamData.Get("size").value.value.asUInt32 = 0;
m_StreamData.Get("path").value.value.asString = Path.Combine(folderPath, m_StreamData.Get("path").GetValue().AsString());
//baseField.Get("image data").GetValue().type = EnumValueTypes.ValueType_ByteArray;
//baseField.Get("image data").GetValue().Set(new AssetTypeByteArray() {
// data = data,
// size = (uint)data.Length
//});
//baseField.Get("image data").templateField.valueType = EnumValueTypes.ValueType_ByteArray;
byte[] textureAsset;
using (MemoryStream memStream = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(memStream))
{
writer.bigEndian = false;
baseField.Write(writer);
textureAsset = memStream.ToArray();
}
return(new AssetsReplacerFromMemory(0, pathId, 0x1C, 0xFFFF, textureAsset));
}
public bool Write(AssetsFileWriter writer, ulong curFilePos /*, AssetsFileVerifyLogger errorLogger = NULL*/)
{
writer.Position = curFilePos;
writer.WriteNullTerminated(signature);
writer.Write(fileVersion);
writer.WriteNullTerminated(minPlayerVersion);
writer.WriteNullTerminated(fileEngineVersion);
writer.Write(totalFileSize);
writer.Write(compressedSize);
writer.Write(decompressedSize);
writer.Write(flags);
return(true);
}
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();
}
//todo- not guaranteed to get texture in sharedassets
private static byte[] FixTexture2D(AssetTypeValueField baseField, byte[] saData)
{
AssetTypeValueField m_StreamData = baseField.Get("m_StreamData");
int offset = (int)m_StreamData.Get("offset").GetValue().AsUInt();
int size = (int)m_StreamData.Get("size").GetValue().AsUInt();
byte[] data = new byte[0];
if (size != 0)
{
string path = m_StreamData.Get("path").GetValue().AsString();
using (MemoryStream inStream = new MemoryStream(saData))
using (MemoryStream outStream = new MemoryStream())
{
long fileSize = inStream.Length;
data = new byte[size];
inStream.Position = offset;
int bytesRead;
var buffer = new byte[2048];
while ((bytesRead = inStream.Read(buffer, 0, Math.Min(2048, (offset + size) - (int)inStream.Position))) > 0)
{
outStream.Write(buffer, 0, bytesRead);
if (inStream.Position >= offset + size)
{
break;
}
}
data = outStream.ToArray();
}
}
m_StreamData.Get("offset").value.value.asUInt32 = 0;
m_StreamData.Get("size").value.value.asUInt32 = 0;
m_StreamData.Get("path").value.value.asString = "";
baseField.Get("image data").GetValue().type = EnumValueTypes.ValueType_ByteArray;
baseField.Get("image data").GetValue().Set(new AssetTypeByteArray()
{
data = data,
size = (uint)data.Length
});
baseField.Get("image data").templateField.valueType = EnumValueTypes.ValueType_ByteArray;
byte[] assetData;
using (MemoryStream memStream = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(memStream))
{
writer.bigEndian = false;
baseField.Write(writer);
assetData = memStream.ToArray();
}
return(assetData);
}
private void ImportAssets()
{
var inf = currentFile.table.GetAssetInfo("MyBoringAsset");
var baseField = helper.GetATI(currentFile.file, inf).GetBaseField();
baseField.Get("m_Name")
.GetValue()
.Set("MyCoolAsset");
var newGoBytes = baseField.WriteToByteArray();
//AssetsReplacerFromMemory's monoScriptIndex should always be 0xFFFF unless it's a MonoBehaviour
var repl = new AssetsReplacerFromMemory(0, inf.index, (int)inf.curFileType, 0xFFFF, newGoBytes);
var writer = new AssetsFileWriter(File.OpenWrite("resources-modified.assets"));
currentFile.file.Write(writer, 1, new AssetsReplacer[] { repl }.ToList(), 1);
}
}//Minimum AssetsFile format : 6
public ulong Write(ulong absFilePos, AssetsFileWriter writer, uint version)
{
writer.WriteNullTerminated(unityVersion);
writer.Write(this.version);
writer.Write(hasTypeTree);
writer.Write(fieldCount);
for (int i = 0; i < fieldCount; i++)
{
pTypes_Unity5[i].Write(hasTypeTree, writer.Position, writer, version);
}
if (version < 0x0E)
{
writer.WriteUInt24(dwUnknown);
}
return(writer.Position);
}
private byte[] CreateEditDifferMonoBehaviour(long goPid, AssetTypeValueField componentArray, AssetID origGoPptr)
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter w = new AssetsFileWriter(ms))
{
w.bigEndian = false;
w.Write(0);
w.Write(goPid);
w.Write(1);
w.Write(2);
w.Write((long)11500000);
w.WriteCountStringInt32("");
w.Align();
w.Write(0);
w.Write(origGoPptr.pathId);
w.Write(origGoPptr.pathId);
w.Write(0);
int componentArrayLength = componentArray.GetValue().AsArray().size;
w.Write(componentArrayLength);
for (int i = 0; i < componentArrayLength; i++)
{
AssetTypeValueField component = componentArray[i].Get("component");
int m_FileID = component.Get("m_FileID").GetValue().AsInt();
long m_PathID = component.Get("m_PathID").GetValue().AsInt64();
if (m_PathID == 0) //removed (monobehaviour)
{
w.Write((long)-1);
}
else if (m_FileID == 0) //correct file
{
w.Write(m_PathID);
}
else //another file (shouldn't happen?)
{
w.Write((long)0);
}
}
w.Write(0 /*rand.Next()*/);
data = ms.ToArray();
}
return(data);
}
private void DecompressBundle(string path)
{
//from uabe
AssetsFileReader reader = new AssetsFileReader(new FileStream(path, FileMode.Open));
AssetsBundleFile bundle = new AssetsBundleFile();
bundle.Read(reader, true);
reader.Position = 0;
AssetsFileWriter writer = new AssetsFileWriter(new FileStream(path + ".up", FileMode.Create));
bundle.Unpack(reader, writer);
//writer.BaseStream.Position = 0;
//bundle = new AssetsBundleFile();
//bundle.Read(new AssetsFileReader(writer.BaseStream), false);
reader.BaseStream.Close();
writer.BaseStream.Close();
}
private void SaveBundle(string path)
{
if (BundleInst == null)
{
return;
}
using (var fs = File.OpenWrite(path))
using (var writer = new AssetsFileWriter(fs))
{
BundleInst.file.Write(writer, ModifiedFiles.Values.ToList());
}
Modified = false;
var items = cboxBundleContents.Items.Cast <string>().Select(i => i.Replace(" *", ""));
cboxBundleContents.Items.Clear();
cboxBundleContents.Items.AddRange((object[])items);
}
private static byte[] AddMetadataMonobehaviour(byte[] data, long behaviourId)
{
//it seems unity is so broken that after something other than
//gameobjects are added to the asset list, you can't add any
//monobehaviour components to gameobjects after it or it crashes
//anyway, since I'm stuck on this one and I can't really push
//to the beginning of the list, I'll just put the info onto
//the first gameobject in the scene
using (MemoryStream fms = new MemoryStream(data))
using (AssetsFileReader fr = new AssetsFileReader(fms))
{
fr.bigEndian = false;
int componentSize = fr.ReadInt32();
List <AssetPPtr> pptrs = new List <AssetPPtr>();
for (int i = 0; i < componentSize; i++)
{
int fileId = fr.ReadInt32();
long pathId = fr.ReadInt64();
//this gets rid of assets that have no reference
if (!(fileId == 0 && pathId == 0))
{
pptrs.Add(new AssetPPtr((uint)fileId, (ulong)pathId));
}
}
//add reference to Metadata mb
pptrs.Add(new AssetPPtr(0, (ulong)behaviourId));
int assetLengthMinusCP = (int)(data.Length - 4 - (componentSize * 12));
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter w = new AssetsFileWriter(ms))
{
w.bigEndian = false;
w.Write(pptrs.Count);
foreach (AssetPPtr pptr in pptrs)
{
w.Write(pptr.fileID);
w.Write(pptr.pathID);
}
w.Write(fr.ReadBytes(assetLengthMinusCP));
return(ms.ToArray());
}
}
}
//this one has to work differently since we already modified the value field
//so we save it to a stream and read from it manually so it works faster
//note it may be better to loop through all objects but this would be slower
//in the future, all components should be added so we won't need this
private static byte[] FixGameObjectFast(AssetsFileInstance inst, AssetFileInfoEx inf, AssetTypeValueField field, ulong editDifferPid)
{
//dump current data to ms
using (MemoryStream fms = new MemoryStream())
using (AssetsFileWriter fw = new AssetsFileWriter(fms))
{
fw.bigEndian = false;
field.Write(fw);
fms.Position = 0;
AssetsFileReader r = new AssetsFileReader(fms);
r.bigEndian = false;
int componentSize = r.ReadInt32();
List <AssetPPtr> pptrs = new List <AssetPPtr>();
for (int i = 0; i < componentSize; i++)
{
int fileId = r.ReadInt32();
long pathId = r.ReadInt64();
//this gets rid of assets that have no reference
if (!(fileId == 0 && pathId == 0))
{
pptrs.Add(new AssetPPtr((uint)fileId, (ulong)pathId));
}
}
//add reference to EditDiffer mb
pptrs.Add(new AssetPPtr(0, editDifferPid));
int assetLengthMinusCP = (int)(inf.curFileSize - 4 - (componentSize * 12));
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter w = new AssetsFileWriter(ms))
{
w.bigEndian = false;
w.Write(pptrs.Count);
foreach (AssetPPtr pptr in pptrs)
{
w.Write(pptr.fileID);
w.Write(pptr.pathID);
}
w.Write(r.ReadBytes(assetLengthMinusCP));
return(ms.ToArray());
}
}
}
private byte[] CreateTk2DEmulatorMonoBehaviour(long goPid, Tk2dInfo tk2dInfo)
{
byte[] data;
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter w = new AssetsFileWriter(ms))
{
w.bigEndian = false;
w.Write(0);
w.Write(goPid);
w.Write(1);
w.Write(3);
w.Write((long)11500000);
w.WriteCountStringInt32("");
w.Align();
w.Write(tk2dInfo.positions.Length);
for (int i = 0; i < tk2dInfo.positions.Length; i++)
{
Vector3 position = tk2dInfo.positions[i];
w.Write(position.x);
w.Write(position.y);
w.Write(position.z);
}
w.Align();
w.Write(tk2dInfo.uvs.Length);
for (int i = 0; i < tk2dInfo.uvs.Length; i++)
{
Vector3 uv = tk2dInfo.uvs[i];
w.Write(uv.x);
w.Write(uv.y);
}
w.Align();
w.Write(tk2dInfo.indices.Length);
for (int i = 0; i < tk2dInfo.indices.Length; i++)
{
w.Write(tk2dInfo.indices[i]);
}
w.Align();
data = ms.ToArray();
}
return(data);
}
public byte[]? ImportTextAsset(StreamReader sr)
{
this.sr = sr;
using (MemoryStream ms = new MemoryStream())
{
aw = new AssetsFileWriter(ms);
aw.bigEndian = false;
try
{
ImportTextAssetLoop();
}
catch
{
return(null);
}
return(ms.ToArray());
}
}
public Dictionary <BundleReplacer, MemoryStream> WriteFilesToMemory(List <AssetsReplacer> replacers)
{
var bunDict = new Dictionary <BundleReplacer, MemoryStream>();
var lastFileId = replacers.Max(r => r.GetFileID());
for (var fileId = 0; fileId <= lastFileId; fileId++)
{
var id = fileId;
var sortedAssetsList = replacers.Where(r => r.GetFileID() == id).ToList();
using var ms = new MemoryStream();
using var writer = new AssetsFileWriter(ms);
var fileInst = Workspace.LoadedFiles[fileId];
fileInst.file.Write(writer, 0, sortedAssetsList, 0);
bunDict.Add(AssetModifier.CreateBundleReplacer(fileInst.name, true, ms.ToArray()), ms);
}
return(bunDict);
}
/// <summary>
/// Unpack the specified bundle instance and return a new instance of the unpacked version.
/// </summary>
/// <param name="manager">The assets manager</param>
/// <param name="bundle">The bundle to unpack</param>
/// <param name="unpackedFile">The unpacked bundle file</param>
/// <returns></returns>
private static BundleFileInstance Unpack(
AssetsManager manager,
BundleFileInstance bundle,
string unpackedFile
)
{
using var unpackedStream = File.OpenWrite(unpackedFile);
using var reader = new AssetsFileReader(bundle.stream);
using var writer = new AssetsFileWriter(unpackedStream);
bundle.file.Unpack(reader, writer);
writer.Flush();
// Close the stream so assetsManager can open the file
unpackedStream.Close();
return(manager.LoadBundleFile(unpackedFile));
}
public void WriteFiles(List <AssetsReplacer> replacers, bool overwrite = false)
{
var lastFileId = replacers.Max(r => r.GetFileID());
for (var fileId = 0; fileId <= lastFileId; fileId++)
{
var id = fileId;
var sortedAssetsList = replacers.Where(r => r.GetFileID() == id).ToList(); // sort the list of replacers by fileID
var fileInst = Workspace.LoadedFiles[fileId];
if (overwrite)
{
var path = fileInst.path;
var tempPath = Path.Combine(Path.GetTempPath(), fileInst.name);
using var fs = File.OpenWrite(tempPath);
using var writer = new AssetsFileWriter(fs);
fileInst.file.Write(writer, 0, sortedAssetsList, 0);
Am.UnloadAssetsFile(path);
fs.Close();
File.Replace(tempPath, path, path + ".backup");
Workspace.LoadedFiles[fileId] = Am.LoadAssetsFile(path, false);
}
else
{
var sfd = new SaveFileDialog
{
Title = @"Save as...",
Filter = @"All types (*.*)|*.*|Assets file (*.assets)|*.assets",
FileName = fileInst.name
};
if (sfd.ShowDialog() != DialogResult.OK)
{
continue;
}
if (fileInst.path == sfd.FileName)
{
MsgBoxUtils.ShowErrorDialog("If you want to overwrite files go to \"File->Save\" instead of \"File->Save as...\"!");
return;
}
using var fs = File.OpenWrite(sfd.FileName);
using var writer = new AssetsFileWriter(fs);
fileInst.file.Write(writer, 0, sortedAssetsList, 0);
}
}
}
internal static void ChangeDisableUnityAudio(string path, bool newValue, QModGame game)
{
if (game != QModGame.Subnautica && game != QModGame.BelowZero)
{
throw new ArgumentException("Neither Subnautica nor Below Zero detected!");
}
AssetsManager am = new AssetsManager();
AssetsFileInstance afi = am.LoadAssetsFile(path, false);
if (game == QModGame.Subnautica)
{
am.LoadClassDatabase("cldb.dat");
}
else
{
am.LoadClassDatabase("cldb2018.dat");
}
AssetFileInfoEx audioInfo = afi.table.getAssetInfo(4);
AssetTypeInstance audioAti = am.GetATI(afi.file, audioInfo);
AssetTypeValueField audioBaseField = audioAti.GetBaseField();
audioBaseField.Get("m_DisableAudio").GetValue().Set(newValue);
byte[] audioAsset;
using (MemoryStream memStream = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(memStream))
{
writer.bigEndian = false;
audioBaseField.Write(writer);
audioAsset = memStream.ToArray();
}
List <AssetsReplacer> rep = new List <AssetsReplacer>()
{
new AssetsReplacerFromMemory(0, 4, 0x0B, 0xFFFF, audioAsset)
};
using (MemoryStream memStream = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(memStream))
{
afi.file.Write(writer, 0, rep.ToArray(), 0);
afi.stream.Close();
File.WriteAllBytes(path, memStream.ToArray());
}
}
public static byte[] CreateBlankAssets(string engineVersion, List <Type_0D> types)
{
using (MemoryStream ms = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(ms))
{
AssetsFileHeader header = new AssetsFileHeader()
{
metadataSize = 0,
fileSize = 0x1000,
format = 0x11,
offs_firstFile = 0x1000,
endianness = 0,
unknown = new byte[] { 0, 0, 0 }
};
TypeTree typeTree = new TypeTree()
{
unityVersion = engineVersion,
version = 0x5,
hasTypeTree = true,
fieldCount = (uint)types.Count(),
pTypes_Unity5 = types.ToArray()
};
header.Write(writer.Position, writer);
writer.bigEndian = false;
typeTree.Write(writer.Position, writer, 0x11);
writer.Write((uint)0);
writer.Align();
//preload table and dependencies
writer.Write((uint)0);
writer.Write((uint)0);
//due to a write bug in at.net we have to pad to 0x1000
while (ms.Position < 0x1000)
{
writer.Write((byte)0);
}
return(ms.ToArray());
}
}
public void Write(AssetsFileWriter writer, int version)
{
typeName.Write(writer);
fieldName.Write(writer);
writer.Write(depth);
writer.Write(isArray);
writer.Write(size);
switch (version)
{
case 1:
writer.Write(flags2);
break;
case 3:
case 4:
writer.Write(this.version);
writer.Write(flags2);
break;
}
}
public ulong Write(AssetsFileWriter writer, ulong filePos, int version)
{
typeName.Write(writer, filePos);
fieldName.Write(writer, filePos);
writer.Write(depth);
writer.Write(isArray);
writer.Write(size);
switch (version)
{
case 1:
writer.Write(flags2);
break;
case 3:
writer.Write(this.version);
writer.Write(flags2);
break;
}
return(writer.Position);
}
public static AssetsReplacer RunMoveTest(AssetFileInfoEx info, AssetTypeValueField baseField, ulong pathId)
{
//GameObject 609->Transform 2642
AssetTypeValueField m_LocalPosition = baseField.Get("m_LocalPosition");
m_LocalPosition.Get("x").GetValue().Set(89.93f);
m_LocalPosition.Get("y").GetValue().Set(25.56f);
m_LocalPosition.Get("z").GetValue().Set(48.73f);
byte[] moveAsset;
using (MemoryStream memStream = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(memStream))
{
writer.bigEndian = false;
baseField.Write(writer);
moveAsset = memStream.ToArray();
}
return(new AssetsReplacerFromMemory(0, pathId, 0x04, 0xFFFF, moveAsset));
}
public static AssetsReplacer ConvertShader(AssetTypeValueField baseField, ulong pathId, List <ulong> dependencies)
{
AssetTypeValueField m_Dependencies = baseField.Get("m_Dependencies").Get("Array");
for (int i = 0; i < m_Dependencies.GetValue().AsArray().size; i++)
{
m_Dependencies[(uint)i].Get("m_FileID").GetValue().Set(0);
m_Dependencies[(uint)i].Get("m_PathID").GetValue().Set(dependencies[i]);
}
byte[] shaderAsset;
using (MemoryStream memStream = new MemoryStream())
using (AssetsFileWriter writer = new AssetsFileWriter(memStream))
{
writer.bigEndian = false;
baseField.Write(writer);
shaderAsset = memStream.ToArray();
}
return(new AssetsReplacerFromMemory(0, pathId, 0x30, 0xFFFF, shaderAsset));
}
//Write doesn't compress
public void Write(AssetsFileWriter writer)
{
writer.Write(checksumHigh);
writer.Write(checksumLow);
writer.Write(blockCount);
for (int i = 0; i < blockCount; i++)
{
writer.Write(blockInf[i].decompressedSize);
writer.Write(blockInf[i].compressedSize);
writer.Write(blockInf[i].flags);
}
writer.Write(directoryCount);
for (int i = 0; i < directoryCount; i++)
{
writer.Write(dirInf[i].offset);
writer.Write(dirInf[i].decompressedSize);
writer.Write(dirInf[i].flags);
writer.WriteNullTerminated(dirInf[i].name);
}
}
public void AddReplacer(AssetsReplacer replacer, MemoryStream previewStream = null)
{
if (replacer == null)
{
return;
}
var forInstance = LoadedFiles[replacer.GetFileID()];
var assetId = new AssetID(forInstance.path, replacer.GetPathID());
var index = LoadedAssets.FindIndex(i => i.FileID == replacer.GetFileID() && i.PathID == replacer.GetPathID());
var item = LoadedAssets[index];
if (NewAssets.ContainsKey(assetId))
{
RemoveReplacer(replacer);
}
NewAssets[assetId] = replacer;
if (previewStream == null)
{
var newStream = new MemoryStream();
var newWriter = new AssetsFileWriter(newStream);
replacer.Write(newWriter);
newStream.Position = 0;
previewStream = newStream;
}
NewAssetDatas[assetId] = previewStream;
if (replacer is AssetsRemover)
{
LoadedContainers.Remove(assetId);
}
else
{
var cont = MakeAssetContainer(item, NewAssetDatas[assetId]);
UpdateAssetInfo(cont, assetId, index);
}
Modified = true;
}
public void Write(AssetsFileWriter writer)
{
writer.bigEndian = false;
writer.Write(Encoding.ASCII.GetBytes(magic));
writer.Write(includesCldb);
writer.WriteCountStringInt16(modName);
writer.WriteCountStringInt16(modCreators);
writer.WriteCountStringInt16(modDescription);
if (includesCldb)
{
addedTypes.Write(writer);
writer.Position = addedTypes.header.stringTablePos + addedTypes.header.stringTableLen;
}
writer.Write(affectedFiles.Count);
for (int i = 0; i < affectedFiles.Count; i++)
{
InstallerPackageAssetsDesc desc = affectedFiles[i];
writer.Write(desc.isBundle);
writer.WriteCountStringInt16(desc.path);
writer.Write(desc.replacers.Count);
for (int j = 0; j < desc.replacers.Count; j++)
{
object repObj = desc.replacers[j];
if (repObj is AssetsReplacer repAsset)
{
repAsset.WriteReplacer(writer);
}
else if (repObj is BundleReplacer repBundle)
{
repBundle.WriteReplacer(writer);
}
}
}
}
public void AddReplacer(AssetsFileInstance forFile, AssetsReplacer replacer, Stream? previewStream = null)
{
AssetsFile assetsFile = forFile.file;
AssetID assetId = new AssetID(forFile.path, replacer.GetPathID());
if (NewAssets.ContainsKey(assetId))
RemoveReplacer(forFile, NewAssets[assetId], true);
NewAssets[assetId] = replacer;
//make stream to use as a replacement to the one from file
if (previewStream == null)
{
MemoryStream newStream = new MemoryStream();
AssetsFileWriter newWriter = new AssetsFileWriter(newStream);
replacer.Write(newWriter);
newStream.Position = 0;
previewStream = newStream;
}
NewAssetDatas[assetId] = previewStream;
if (!(replacer is AssetsRemover))
{
AssetsFileReader reader = new AssetsFileReader(previewStream);
AssetContainer cont = new AssetContainer(
reader, 0, replacer.GetPathID(), (uint)replacer.GetClassID(),
replacer.GetMonoScriptID(), (uint)previewStream.Length, forFile);
LoadedAssets[assetId] = cont;
}
else
{
LoadedAssets.Remove(assetId);
}
if (ItemUpdated != null)
ItemUpdated(forFile, assetId);
Modified = true;
}
