public void LoadData()
{
BaseStream.Seek(Header.HeaderSize, SeekOrigin.Begin);
using (AssetsReader reader = new AssetsReader(BaseStream, false))
{
Metadata = new AssetsMetadata(this);
Metadata.Parse(reader);
}
BaseStream.Seek(Header.ObjectDataOffset, SeekOrigin.Begin);
if (Manager.ForceLoadAllFiles)
{
foreach (var ext in Metadata.ExternalFiles)
{
Manager.GetAssetsFile(ext.FileName);
}
}
if (!Manager.LazyLoad)
{
foreach (var oi in Metadata.ObjectInfos)
{
var o = oi.Object;
}
BaseStream.Close();
BaseStream.Dispose();
BaseStream = null;
}
}
public BundleFile(Stream stream)
{
using (var reader = new AssetsReader(stream, false))
{
Parse(reader);
}
}
public static SmartPtr <T> Read(AssetsFile assetsFile, AssetsObject owner, AssetsReader reader)
{
if (owner == null)
{
Log.LogErr("WARNING: SmartPtr created without an owner!");
}
int fileID = reader.ReadInt32();
reader.AlignTo(4);
Int64 pathID = reader.ReadInt64();
if (fileID == 0 && pathID == 0)
{
return(new SmartPtr <T>());
}
var objInfo = assetsFile.GetObjectInfo <T>(fileID, pathID);
if (objInfo == null)
{
Log.LogErr($"WARNING: Could not find objectinfo for creating SmartPtr of type {typeof(T).Name} on owner type {owner?.GetType()?.Name ?? "(null owner)"}! Returned a null pointer instead.");
return(null);
}
SmartPtr <T> ptr = new SmartPtr <T>(owner, assetsFile.GetObjectInfo <T>(fileID, pathID));
//TODO: not sure this is only ever called by existing objects
ptr.IsNew = false;
return(ptr);
}
public AssetsFile(AssetsManager manager, IFileProvider fileProvider, string assetsRootPath, string assetsFileName, bool loadData = true)
{
Manager = manager;
FileProvider = fileProvider;
AssetsRootPath = assetsRootPath;
AssetsFilename = assetsFileName;
OpenBaseStream();
BaseStream.Seek(0, SeekOrigin.Begin);
using (AssetsReader reader = new AssetsReader(BaseStream, false))
{
Header = new AssetsFileHeader(reader);
}
if (Header.MetadataSize > Header.FileSize || Header.ObjectDataOffset < Header.MetadataSize || (Header.Version != 17 && Header.Version != 20))
{
throw new NotSupportedException($"{AssetsFilename} doesn't appear to be a valid assets file, or {Header.Version} is unsupported!");
}
if (loadData)
{
LoadData();
}
}
private void Parse(AssetsReader reader)
{
Offset = reader.ReadBEInt64();
Size = reader.ReadBEInt64();
_flags = reader.ReadBEUInt32();
Filename = reader.ReadCStr();
}
private void Parse(AssetsReader reader)
{
UncompressedSize = reader.ReadBEUInt32();
CompressedSize = reader.ReadBEUInt32();
_flags = reader.ReadBEUInt16();
}
private void Parse(AssetsReader reader)
{
ObjectID = reader.ReadInt64();
DataOffset = reader.ReadInt32();
DataSize = reader.ReadInt32();
TypeIndex = reader.ReadInt32();
}
private void Parse(AssetsReader reader)
{
int numTreeNodes = reader.ReadInt32();
int stringBufferSize = reader.ReadInt32();
for (int i = 0; i < numTreeNodes; i++)
{
Entries.Add(new TypeTreeEntry(reader));
}
StringBuffer = new String(reader.ReadChars(stringBufferSize));
}
private void Parse(AssetsReader reader)
{
Version = reader.ReadInt16();
Depth = reader.ReadSByte();
IsArray = reader.ReadBoolean();
TypeOffset = reader.ReadInt32();
NameOffset = reader.ReadInt32();
Size = reader.ReadInt32();
Index = reader.ReadInt32();
Flags = reader.ReadInt32();
}
private void Parse(AssetsReader reader)
{
MetadataSize = reader.ReadBEInt32();
FileSize = reader.ReadBEInt32();
Version = reader.ReadBEInt32();
ObjectDataOffset = reader.ReadBEInt32();
IsBigEndian = reader.ReadBoolean();
//padding apparently
//reader.ReadBytes(3);
reader.AlignTo(4);
}
public AssetsObject(IObjectInfo <AssetsObject> objectInfo, AssetsReader reader, bool parseObject = false)
{
ObjectInfo = objectInfo;
if (parseObject)
{
ParseObject(reader);
}
else
{
Parse(reader);
}
}
public void Parse(AssetsReader reader)
{
Version = reader.ReadCStr();
Platform = reader.ReadInt32();
HasTypeTrees = reader.ReadBoolean();
int numTypes = reader.ReadInt32();
for (int i = 0; i < numTypes; i++)
{
Types.Add(new AssetsType(reader, HasTypeTrees));
}
List <ObjectRecord> records = new List <ObjectRecord>();
int numObj = reader.ReadInt32();
for (int i = 0; i < numObj; i++)
{
reader.AlignTo(4);
var obj = new ObjectRecord(reader);
records.Add(obj);
}
int numAdds = reader.ReadInt32();
for (int i = 0; i < numAdds; i++)
{
reader.AlignTo(4);
Adds.Add(new RawPtr(reader));
}
int numExt = reader.ReadInt32();
for (int i = 0; i < numExt; i++)
{
ExternalFiles.Add(new ExternalFile(reader));
}
reader.ReadCStr();
//load the object infos in order based on their type
foreach (var record in records.OrderBy(x => PreloadObjectOrder(x)).ThenBy(x => x.ObjectID))
{
var obj = ObjectInfo <AssetsObject> .Parse(ParentFile, record);
ObjectInfos.Add(obj);
if (ShouldForceLoadObject(record))
{
var o = obj.Object;
}
}
}
private void Parse(AssetsReader reader, bool hasTypeTree)
{
ClassID = reader.ReadInt32();
Unknown1 = reader.ReadSByte();
Unknown2 = reader.ReadInt16();
if (IsScriptType)
{
ScriptHash = reader.ReadGuid();
}
TypeHash = reader.ReadGuid();
if (hasTypeTree)
{
TypeTree = new TypeTree(reader);
}
}
private void ParseDirectory(AssetsReader reader)
{
//unknown?
_directoryUnknown = reader.ReadBytes(16);
int numBlocks = reader.ReadBEInt32();
for (int i = 0; i < numBlocks; i++)
{
BlockInfos.Add(new BlockInfo(reader));
}
int numEntries = reader.ReadBEInt32();
for (int i = 0; i < numEntries; i++)
{
Entries.Add(new DirectoryEntry(reader));
}
}
public void Parse(AssetsFile assetsFile, AssetsObject owner, AssetsReader reader)
{
Texture = SmartPtr <Texture2DObject> .Read(assetsFile, owner, reader);
AlphaTexture = SmartPtr <Texture2DObject> .Read(assetsFile, owner, reader);
SubMeshes = reader.ReadArrayOf(r => new Submesh(reader));
IndexBuffer = reader.ReadArray();
reader.AlignTo(4);
VertexData = new VertexData(reader);
BindPose = reader.ReadArrayOf(r => r.ReadSingle());
TextureRect = new RectF(reader);
TextureRectOffset = new Vector2F(reader);
AtlasRectOffset = new Vector2F(reader);
SettingsRaw = reader.ReadUInt32();
UVTransform = new Vector4F(reader);
DownscaleMultiplier = reader.ReadSingle();
}
public override void ParseObject(AssetsReader reader)
{
Name = reader.ReadString();
Rect = new RectF(reader);
Offset = new Vector2F(reader);
Border = new Vector4F(reader);
PixelsToUnits = reader.ReadSingle();
Pivot = new Vector2F(reader);
Extrude = reader.ReadUInt32();
IsPolygon = reader.ReadBoolean();
reader.AlignTo(4);
RenderDataKey = new Map <Guid, long>(reader.ReadGuid(), reader.ReadInt64());
AtlasTags = reader.ReadArrayOf(r => r.ReadString());
SpriteAtlas = SmartPtr <AssetsObject> .Read(ObjectInfo.ParentFile, this, reader);
RenderData = new SpriteRenderData(ObjectInfo.ParentFile, this, reader);
PhysicsShape = reader.ReadArrayOf(r => r.ReadArrayOf(r2 => new Vector2F(r2)));
Bones = reader.ReadArrayOf(r => (ISmartPtr <Transform>)SmartPtr <Transform> .Read(ObjectInfo.ParentFile, this, reader));
}
public TypeTreeEntry(AssetsReader reader)
{
Parse(reader);
}
public void Parse(AssetsReader reader)
{
ParseBase(reader);
ParseObject(reader);
}
public SpriteObject(IObjectInfo <AssetsObject> objectInfo, AssetsReader reader) : base(objectInfo)
{
Parse(reader);
}
private void Parse(AssetsReader reader)
{
//basic header stuff
signature = reader.ReadCStr();
if (signature != "UnityFS")
{
throw new NotSupportedException("Stream is not UnityFS");
}
fileVersion = reader.ReadBEInt32();
if (fileVersion != 6)
{
throw new NotSupportedException("File version is not supported");
}
PlayerVersion = reader.ReadCStr();
EngineVersion = reader.ReadCStr();
BundleSize = reader.ReadBEInt64();
//header info
int compressedSize = reader.ReadBEInt32();
int decompressedSize = reader.ReadBEInt32();
flags = reader.ReadBEUInt32();
if (IsDirectoryAtEnd(flags))
{
var start = (int)reader.BaseStream.Position;
reader.Seek((int)reader.BaseStream.Length - compressedSize);
infoBytes = reader.ReadBytes(compressedSize);
reader.Seek(start);
}
else
{
infoBytes = reader.ReadBytes(compressedSize);
}
Stream blockInfoStream = null;
try
{
switch (CompressionMode(flags))
{
case UnityFSCompressionMode.LZ4:
case UnityFSCompressionMode.LZ4HC:
blockInfoStream = new MemoryStream(LZ4.LZ4Codec.Decode(infoBytes, 0, infoBytes.Length, decompressedSize));
break;
case UnityFSCompressionMode.NoCompression:
blockInfoStream = new MemoryStream(infoBytes);
break;
case UnityFSCompressionMode.LZMA:
// TODO Better way of encoding/decoding
blockInfoStream = new MemoryStream(LZMADecode(infoBytes, decompressedSize));
break;
}
using (AssetsReader infoReader = new AssetsReader(blockInfoStream, false))
ParseDirectory(infoReader);
}
finally
{
if (blockInfoStream != null)
{
blockInfoStream.Dispose();
}
}
MemoryStream outputStream = new MemoryStream();
foreach (var blockInfo in BlockInfos)
{
byte[] blockData = null;
switch (blockInfo.CompressionMode)
{
case UnityFSCompressionMode.LZ4:
case UnityFSCompressionMode.LZ4HC:
blockData = LZ4.LZ4Codec.Decode(reader.ReadBytes((int)blockInfo.CompressedSize), 0, (int)blockInfo.CompressedSize, (int)blockInfo.UncompressedSize);
break;
case UnityFSCompressionMode.NoCompression:
blockData = reader.ReadBytes((int)blockInfo.UncompressedSize);
break;
case UnityFSCompressionMode.LZMA:
blockData = LZMADecode(reader.BaseStream, (int)blockInfo.CompressedSize, (int)blockInfo.UncompressedSize);
break;
}
outputStream.Write(blockData, 0, blockData.Length);
}
using (outputStream)
{
foreach (var entry in Entries)
{
outputStream.Seek(entry.Offset, SeekOrigin.Begin);
entry.Data = outputStream.ReadBytes((int)entry.Size);
}
}
}
public SpriteRenderData(AssetsFile assetsFile, AssetsObject owner, AssetsReader reader)
{
Parse(assetsFile, owner, reader);
}
public BlockInfo(AssetsReader reader)
{
Parse(reader);
}
public virtual void ParseObject(AssetsReader reader)
{
Data = reader.ReadBytes(ObjectInfo.DataSize);
}
public DirectoryEntry(AssetsReader reader)
{
Parse(reader);
}
public AssetsFileHeader(AssetsReader reader)
{
Parse(reader);
}
public AssetInfo(AssetsFile assetsFile, AssetsObject owner, AssetsReader reader)
{
Parse(assetsFile, owner, reader);
}
private void Parse(AssetsFile assetsFile, AssetsObject owner, AssetsReader reader)
{
PreloadIndex = reader.ReadInt32();
PreloadSize = reader.ReadInt32();
Asset = SmartPtr <AssetsObject> .Read(assetsFile, owner, reader);
}
public RawPtr(AssetsReader reader)
{
Parse(reader);
}
public AssetsType(AssetsReader reader, bool hasTypeTrees = false)
{
Parse(reader, hasTypeTrees);
}
private void Parse(AssetsReader reader)
{
FileID = reader.ReadInt32();
reader.AlignTo(4);
PathID = reader.ReadInt64();
}
