private byte[] GetRawData(AudioClip clip)
{
if (AudioClip.IsReadLoadType(clip.File.Version))
{
ResourcesFile res = clip.File.Collection.FindResourcesFile(clip.File, clip.FSBResource.Source);
if (res == null)
{
Logger.Instance.Log(LogType.Warning, LogCategory.Export, $"Can't export '{clip.Name}' because resources file '{clip.FSBResource.Source}' wasn't found");
return(null);
}
res.Stream.Position = clip.FSBResource.Offset;
if (StreamedResource.IsReadSize(clip.File.Version))
{
byte[] buffer = new byte[clip.FSBResource.Size];
res.Stream.Read(buffer, 0, buffer.Length);
return(buffer);
}
else
{
Logger.Instance.Log(LogType.Warning, LogCategory.Export, $"Can't export '{clip.Name}' because unknown raw data size");
return(null);
}
}
else
{
return((byte[])clip.AudioData);
}
}
public override void ExportBinary(IExportContainer container, Stream stream)
{
if (IsReadLoadType(container.Version))
{
using (ResourcesFile res = File.Collection.FindResourcesFile(File, FSBResource.Source))
{
if (res == null)
{
Logger.Log(LogType.Warning, LogCategory.Export, $"Can't export '{Name}' because resources file '{FSBResource.Source}' hasn't been found");
return;
}
if (StreamedResource.IsReadSize(container.Version))
{
using (PartialStream resStream = new PartialStream(res.Stream, res.Offset, res.Size))
{
resStream.Position = FSBResource.Offset;
resStream.CopyStream(stream, FSBResource.Size);
}
}
else
{
// I think they read data by its type for this verison, so I can't even export raw data :/
Logger.Log(LogType.Warning, LogCategory.Export, $"Can't export '{Name}' because of unknown size");
}
}
}
else
{
if (IsReadStreamingInfo(container.Version))
{
if (Stream == 2)
{
using (ResourcesFile res = File.Collection.FindResourcesFile(File, StreamingInfo.Path))
{
if (res == null)
{
Logger.Log(LogType.Warning, LogCategory.Export, $"Can't export '{Name}' because resources file '{StreamingInfo.Path}' hasn't been found");
return;
}
using (PartialStream resStream = new PartialStream(res.Stream, res.Offset, res.Size))
{
resStream.Position = StreamingInfo.Offset;
resStream.CopyStream(stream, StreamingInfo.Size);
}
}
}
else
{
stream.Write(m_audioData, 0, m_audioData.Length);
}
}
else
{
stream.Write(m_audioData, 0, m_audioData.Length);
}
}
}
public IReadOnlyList <byte> GetAudioData()
{
if (IsReadLoadType(File.Version))
{
using (ResourcesFile res = File.Collection.FindResourcesFile(File, FSBResource.Source))
{
if (res == null)
{
return(new byte[0]);
}
if (StreamedResource.IsReadSize(File.Version))
{
byte[] data = new byte[FSBResource.Size];
using (PartialStream resStream = new PartialStream(res.Stream, res.Offset, res.Size))
{
resStream.Position = FSBResource.Offset;
resStream.ReadBuffer(data, 0, data.Length);
}
return(data);
}
else
{
return(new byte[0]);
}
}
}
else
{
if (IsReadStreamingInfo(File.Version))
{
if (LoadType == AudioClipLoadType.Streaming)
{
if (m_audioData == null)
{
using (ResourcesFile res = File.Collection.FindResourcesFile(File, StreamingInfo.Path))
{
if (res == null)
{
return(new byte[0]);
}
byte[] data = new byte[FSBResource.Size];
using (PartialStream resStream = new PartialStream(res.Stream, res.Offset, res.Size))
{
resStream.Position = StreamingInfo.Offset;
resStream.ReadBuffer(data, 0, data.Length);
}
return(data);
}
}
}
}
return(m_audioData);
}
}
public virtual Stream GetResourceStream(StreamedResource resource)
{
ResourceArchive resourceArchive = this.Bundle.GetAssetArchive(resource.Source) as ResourceArchive;
if (resourceArchive == null)
{
return(null);
}
return(resourceArchive.GetResourceStream((long)resource.Offset, (long)resource.Size));
}
public override void ExportBinary(IAssetsExporter exporter, Stream stream)
{
if (IsReadLoadType(exporter.Version))
{
ResourcesFile res = File.Collection.FindResourcesFile(File, FSBResource.Source);
if (res == null)
{
Logger.Log(LogType.Warning, LogCategory.Export, $"Can't export '{Name}' because resources file '{FSBResource.Source}' wasn't found");
return;
}
res.Stream.Position = FSBResource.Offset;
if (StreamedResource.IsReadSize(exporter.Version))
{
res.Stream.CopyStream(stream, FSBResource.Size);
}
else
{
// I think they read data by it's type for this verison, so I can't even export raw data :/
}
}
else
{
if (IsReadStreamingInfo(exporter.Version))
{
if (Stream == 2)
{
ResourcesFile res = File.Collection.FindResourcesFile(File, StreamingInfo.Path);
if (res == null)
{
Logger.Log(LogType.Warning, LogCategory.Export, $"Can't export '{Name}' because resources file '{StreamingInfo.Path}' wasn't found");
return;
}
res.Stream.Position = FSBResource.Offset;
res.Stream.CopyStream(stream, StreamingInfo.Size);
}
else
{
stream.Write(m_audioData, 0, m_audioData.Length);
}
}
else
{
stream.Write(m_audioData, 0, m_audioData.Length);
}
}
}
public object Parse(TypeNode typeNode, ArchiveBinaryReader reader)
{
object result = null;
switch (typeNode.TypeFlag)
{
case "bool":
result = reader.ReadBoolean();
break;
case "SInt8":
result = reader.ReadSByte();
break;
case "char":
case "UInt8":
result = reader.ReadByte();
break;
case "short":
case "SInt16":
result = reader.ReadInt16();
break;
case "unsigned short":
case "UInt16":
result = reader.ReadUInt16();
break;
case "int":
case "SInt32":
result = reader.ReadInt32();
break;
case "unsigned int":
case "UInt32":
case "Type*":
result = reader.ReadUInt32();
break;
case "long long":
case "SInt64":
result = reader.ReadInt64();
break;
case "unsigned long long":
case "UInt64":
result = reader.ReadUInt64();
break;
case "float":
result = reader.ReadSingle();
break;
case "double":
result = reader.ReadDouble();
break;
case "Quaternionf":
{
result = reader.ReadQuaternion();
break;
}
case "float4":
case "Vector4f":
{
result = reader.ReadVector4();
break;
}
case "float3":
case "Vector3f":
{
result = reader.ReadVector3();
break;
}
case "float2":
case "Vector2f":
{
result = reader.ReadVector2();
break;
}
case "ColorRGBA":
{
if (typeNode.Version == 2)
{
result = reader.ReadColor32();
}
else
{
result = reader.ReadColor();
}
break;
}
case "Matrix4x4f":
{
result = reader.ReadMatrix4x4();
break;
}
case "Hash128":
{
result = reader.ReadHash128();
break;
}
case "string":
{
result = reader.ReadString();
break;
}
case "vector":
case "staticvector":
case "set":
{
var valueTypeNode = typeNode.Children[0];
result = this.Parse(valueTypeNode, reader);
break;
}
case "map":
{
var pairTypeNode = typeNode.Children[0].Children[1];
var keyTypeNode = pairTypeNode.Children[0];
var valueTypeNode = pairTypeNode.Children[1];
var size = reader.ReadInt32();
Map map = new Map(typeNode);
for (int i = 0; i < size; i++)
{
var key = this.Parse(keyTypeNode, reader);
var value = this.Parse(valueTypeNode, reader);
map.Add(key, value);
}
result = map;
break;
}
case "Array":
{
var valueTypeNode = typeNode.Children[1];
var size = reader.ReadInt32();
result = this.ParseArray(valueTypeNode, size, reader);
break;
}
case "PPtr":
{
var fileID = reader.ReadInt32();
var pathID = reader.ReadInt64();
result = new PPtr(fileID, pathID, typeNode.TypeName);
break;
}
case "TypelessData":
{
var size = reader.ReadInt32();
result = new TypelessData(reader.ReadBytes(size));
break;
}
case "StreamedResource":
{
var source = reader.ReadString();
var offset = reader.ReadUInt64();
var size = reader.ReadUInt64();
var streamedResource = new StreamedResource(source, offset, size);
result = streamedResource;
break;
}
case "AssetBundle":
{
AssetBundle bundle = new AssetBundle(((TypeTree)typeNode).Archive);
bundle.FullName = reader.ReadString();
var size = reader.ReadInt32();
List <PPtr> preloadTable = new List <PPtr>(size);
for (int i = 0; i < size; i++)
{
PPtr pptr = new PPtr(reader.ReadInt32(), reader.ReadInt64(), "PPtr<Object>");
preloadTable.Add(pptr);
}
bundle.Preloads.AddRange(preloadTable);
size = reader.ReadInt32();
List <AssetPair> container = new List <AssetPair>(size);
for (int i = 0; i < size; i++)
{
var first = reader.ReadString();
var preloadIndex = reader.ReadInt32();
var preloadSize = reader.ReadInt32();
var pptr = new PPtr(reader.ReadInt32(), reader.ReadInt64(), "PPtr<Object>");
var pair = new AssetPair(first, new Objects.AssetInfo(preloadIndex, preloadSize, pptr));
container.Add(pair);
}
bundle.Container.AddRange(container);
bundle.MainAsset = new Objects.AssetInfo(reader.ReadInt32(), reader.ReadInt32(), new PPtr(reader.ReadInt32(), reader.ReadInt64(), "PPtr<Object>"));
bundle.RuntimeCompatibility = reader.ReadUInt32();
bundle.Name = reader.ReadString();
size = reader.ReadInt32();
List <string> dependencies = new List <string>(size);
for (int i = 0; i < size; i++)
{
dependencies.Add(reader.ReadString());
}
bundle.Dependencies.AddRange(dependencies);
bundle.IsStreamed = reader.ReadBoolean();
result = bundle;
break;
}
case "PreloadData":
{
PreloadData preloadData = new PreloadData(((TypeTree)typeNode).Archive);
preloadData.Name = reader.ReadString();
var size = reader.ReadInt32();
List <PPtr> preloadTable = new List <PPtr>(size);
for (int i = 0; i < size; i++)
{
PPtr pptr = new PPtr(reader.ReadInt32(), reader.ReadInt64(), "PPtr<Object>");
preloadTable.Add(pptr);
}
preloadData.Preloads.AddRange(preloadTable);
size = reader.ReadInt32();
List <string> dependencies = new List <string>(size);
for (int i = 0; i < size; i++)
{
dependencies.Add(reader.ReadString());
}
preloadData.Dependencies.AddRange(dependencies);
result = preloadData;
break;
}
case "AssetBundleManifest":
{
Objects.AssetBundleManifest obj = new Objects.AssetBundleManifest((TypeTree)typeNode);
foreach (TypeNode childNode in typeNode.Children)
{
var key = childNode.FieldName;
var childValue = this.Parse(childNode, reader);
obj[key] = childValue;
}
result = obj;
break;
}
default:
{
DynamicObject obj = typeNode is TypeTree ? new UnityDynamicObject((TypeTree)typeNode) : new DynamicObject(typeNode);
foreach (TypeNode childNode in typeNode.Children)
{
var key = childNode.FieldName;
var childValue = this.Parse(childNode, reader);
obj[key] = childValue;
}
result = obj;
break;
}
}
if (typeNode.IsAlign)
{
reader.Align(4);
}
return(result);
}
protected virtual void ReadNode(TypeNode typeNode, ArchiveBinaryReader reader, ObjectArchive archive, Stream output, FeatureInfo data)
{
Stream src = reader.BaseStream;
switch (typeNode.TypeFlag)
{
case "bool":
case "SInt8":
case "char":
case "UInt8":
case "short":
case "SInt16":
case "unsigned short":
case "UInt16":
case "int":
case "SInt32":
case "unsigned int":
case "UInt32":
case "Type*":
case "long long":
case "SInt64":
case "unsigned long long":
case "UInt64":
case "float":
case "double":
case "Quaternionf":
case "float4":
case "Vector4f":
case "float3":
case "Vector3f":
case "float2":
case "Vector2f":
case "ColorRGBA":
case "Matrix4x4f":
case "Hash128":
{
this.CopyTo(src, output, typeNode.Size);
break;
}
case "string":
{
if ((typeNode.Depth == 1 || (typeNode.Depth == 2 && typeNode.Root.TypeID == TypeID.Shader)) && typeNode.FieldName.Equals("m_Name"))
{
var position = reader.BaseStream.Position;
data.Name = reader.ReadString();
reader.BaseStream.Position = position;
}
int size = reader.ReadInt32();
if (size > 0)
{
this.CopyTo(src, output, size);
}
reader.Align(4);
break;
}
case "Array":
{
var valueTypeNode = typeNode.Children[1];
var size = reader.ReadInt32();
if (size <= 0)
{
break;
}
this.ReadArrayNode(valueTypeNode, size, reader, archive, output, data);
break;
}
case "TypelessData":
{
var size = reader.ReadInt32();
if (size > 0)
{
this.CopyTo(src, output, size);
}
break;
}
case "PPtr":
{
var fileID = reader.ReadInt32();
var pathID = reader.ReadInt64();
var pptr = new PPtr(fileID, pathID, typeNode.TypeName);
data.Add(pptr);
break;
}
case "StreamedResource":
{
var source = reader.ReadString();
var offset = reader.ReadUInt64();
var size = reader.ReadUInt64();
var streamedResource = new StreamedResource(source, offset, size);
data.Resources = streamedResource;
if (size <= 0)
{
break;
}
using (Stream dataStream = archive.GetResourceStream(streamedResource))
{
if (dataStream == null)
{
break;
}
byte[] buffer = ArchiveUtil.HashBytes(dataStream);
output.Write(buffer, 0, buffer.Length);
}
break;
}
default:
{
foreach (TypeNode childNode in typeNode.Children)
{
ReadNode(childNode, reader, archive, output, data);
}
break;
}
}
if (typeNode.IsAlign)
{
reader.Align(4);
}
}
