GARbro-mirror/ArcFormats/Unity/Asset.cs

468 lines
16 KiB
C#
Raw Normal View History

//! \file Asset.cs
//! \date Wed Apr 05 18:58:07 2017
//! \brief Unity asset class.
//
// Based on the [UnityPack](https://github.com/HearthSim/UnityPack)
//
// Copyright (c) Jerome Leclanche
//
// C# port copyright (C) 2017 by morkt
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using GameRes.Utility;
namespace GameRes.Formats.Unity
{
internal class Asset
{
int m_format;
uint m_data_offset;
bool m_is_little_endian;
UnityTypeData m_tree = new UnityTypeData();
Dictionary<long, int> m_adds;
List<AssetRef> m_refs;
Dictionary<int, TypeTree> m_types = new Dictionary<int, TypeTree>();
Dictionary<long, UnityObject> m_objects = new Dictionary<long, UnityObject>();
public int Format { get { return m_format; } }
public bool IsLittleEndian { get { return m_is_little_endian; } }
public long DataOffset { get { return m_data_offset; } }
public UnityTypeData Tree { get { return m_tree; } }
public IEnumerable<UnityObject> Objects { get { return m_objects.Values; } }
public void Load (AssetReader input)
{
input.ReadInt32(); // header_size
input.ReadUInt32(); // file_size
m_format = input.ReadInt32();
m_data_offset = input.ReadUInt32();
if (m_format >= 9)
m_is_little_endian = 0 == input.ReadInt32();
2017-04-14 13:43:46 +08:00
input.SetupReaders (this);
m_tree.Load (input);
bool long_ids = Format >= 14;
if (Format >= 7 && Format < 14)
long_ids = 0 != input.ReadInt32();
input.SetupReadId (long_ids);
int obj_count = input.ReadInt32();
for (int i = 0; i < obj_count; ++i)
{
input.Align();
var obj = new UnityObject (this);
obj.Load (input);
RegisterObject (obj);
}
if (Format >= 11)
{
int count = input.ReadInt32();
m_adds = new Dictionary<long, int> (count);
for (int i = 0; i < count; ++i)
{
input.Align();
var id = input.ReadId();
m_adds[id] = input.ReadInt32();
}
}
if (Format >= 6)
{
int count = input.ReadInt32();
m_refs = new List<AssetRef> (count);
for (int i = 0; i < count; ++i)
{
var asset_ref = AssetRef.Load (input);
m_refs.Add (asset_ref);
}
}
input.ReadCString();
}
void RegisterObject (UnityObject obj)
{
if (m_tree.TypeTrees.ContainsKey (obj.TypeId))
{
m_types[obj.TypeId] = m_tree.TypeTrees[obj.TypeId];
}
else if (!m_types.ContainsKey (obj.TypeId))
{
/*
var trees = TypeTree.Default (this).TypeTrees;
if (trees.ContainsKey (obj.ClassId))
{
m_types[obj.TypeId] = trees[obj.ClassId];
}
else
*/
{
Trace.WriteLine (string.Format ("Unknown type id {0}", obj.ClassId.ToString()), "[Unity.Asset]");
m_types[obj.TypeId] = null;
}
}
if (m_objects.ContainsKey (obj.PathId))
throw new ApplicationException (string.Format ("Duplicate asset object {0} (PathId: {1})", obj, obj.PathId));
m_objects[obj.PathId] = obj;
}
}
internal class AssetRef
{
public string AssetPath;
public Guid Guid;
public int Type;
public string FilePath;
public object Asset;
public static AssetRef Load (AssetReader reader)
{
var r = new AssetRef();
r.AssetPath = reader.ReadCString();
r.Guid = new Guid (reader.ReadBytes (16));
r.Type = reader.ReadInt32();
r.FilePath = reader.ReadCString();
r.Asset = null;
return r;
}
}
internal class UnityObject
{
public Asset Asset;
public long PathId;
public long Offset;
public uint Size;
public int TypeId;
public int ClassId;
public bool IsDestroyed;
public UnityObject (Asset owner)
{
Asset = owner;
}
public AssetReader Open (Stream input)
{
var stream = new StreamRegion (input, Offset, Size, true);
var reader = new AssetReader (stream, "");
2017-04-14 13:43:46 +08:00
reader.SetupReaders (Asset);
return reader;
}
public void Load (AssetReader reader)
{
PathId = reader.ReadId();
Offset = reader.ReadUInt32() + Asset.DataOffset;
Size = reader.ReadUInt32();
if (Asset.Format < 17)
{
TypeId = reader.ReadInt32();
ClassId = reader.ReadInt16();
}
else
{
var type_id = reader.ReadInt32();
var class_id = Asset.Tree.ClassIds[type_id];
TypeId = class_id;
ClassId = class_id;
}
if (Asset.Format <= 10)
IsDestroyed = reader.ReadInt16() != 0;
if (Asset.Format >= 11 && Asset.Format < 17)
reader.ReadInt16();
if (Asset.Format >= 15 && Asset.Format < 17)
reader.ReadByte();
}
2018-10-04 11:54:36 +08:00
public string TypeName {
get {
2018-10-04 11:54:36 +08:00
var type = this.Type;
if (type != null)
return type.Type;
return string.Format ("[TypeId:{0}]", TypeId);
}
}
2018-10-04 11:54:36 +08:00
public TypeTree Type {
get {
TypeTree type;
Asset.Tree.TypeTrees.TryGetValue (TypeId, out type);
return type;
}
}
public override string ToString ()
{
return string.Format ("<{0} {1}>", Type, ClassId);
}
public IDictionary Deserialize (AssetReader input)
{
var type_tree = Asset.Tree.TypeTrees;
if (!type_tree.ContainsKey (TypeId))
return null;
var type_map = new Hashtable();
var type = type_tree[TypeId];
foreach (var node in type.Children)
{
type_map[node.Name] = DeserializeType (input, node);
}
return type_map;
}
object DeserializeType (AssetReader input, TypeTree node)
{
object obj = null;
if (node.IsArray)
{
int size = input.ReadInt32();
var data_field = node.Children.FirstOrDefault (n => n.Name == "data");
if (data_field != null)
{
if ("TypelessData" == node.Type)
obj = input.ReadBytes (size * data_field.Size);
else
obj = DeserializeArray (input, size, data_field);
}
}
else if (node.Size < 0)
{
if (node.Type == "string")
{
obj = input.ReadString();
if (node.Children[0].IsAligned)
input.Align();
}
else if (node.Type == "StreamingInfo")
{
var info = new StreamingInfo();
info.Load (input);
obj = info;
}
else
throw new NotImplementedException ("Unknown class encountered in asset deserialzation.");
}
else if ("int" == node.Type)
obj = input.ReadInt32();
2018-10-04 11:54:36 +08:00
else if ("unsigned int" == node.Type)
obj = input.ReadUInt32();
else if ("bool" == node.Type)
obj = input.ReadBool();
else
input.Position += node.Size;
if (node.IsAligned)
input.Align();
return obj;
}
object[] DeserializeArray (AssetReader input, int length, TypeTree elem)
{
var array = new object[length];
for (int i = 0; i < length; ++i)
array[i] = DeserializeType (input, elem);
return array;
}
}
internal class TypeTree
{
int m_format;
List<TypeTree> m_children = new List<TypeTree>();
public int Version;
public bool IsArray;
public string Type;
public string Name;
public int Size;
public uint Index;
public int Flags;
public IList<TypeTree> Children { get { return m_children; } }
public bool IsAligned { get { return (Flags & 0x4000) != 0; } }
static readonly string Null = "(null)";
static readonly Lazy<byte[]> StringsDat = new Lazy<byte[]> (() => LoadResource ("strings.dat"));
public TypeTree (int format)
{
m_format = format;
}
public void Load (AssetReader reader)
{
if (10 == m_format || m_format >= 12)
LoadBlob (reader);
else
LoadRaw (reader);
}
void LoadRaw (AssetReader reader)
{
2018-08-31 23:11:39 +08:00
Type = reader.ReadCString();
Name = reader.ReadCString();
Size = reader.ReadInt32();
Index = reader.ReadUInt32();
IsArray = reader.ReadInt32() != 0;
Version = reader.ReadInt32();
Flags = reader.ReadInt32();
int count = reader.ReadInt32();
for (int i = 0; i < count; ++i)
{
var child = new TypeTree (m_format);
child.Load (reader);
Children.Add (child);
}
}
byte[] m_data;
void LoadBlob (AssetReader reader)
{
int count = reader.ReadInt32();
int buffer_bytes = reader.ReadInt32();
var node_data = reader.ReadBytes (24 * count);
m_data = reader.ReadBytes (buffer_bytes);
var parents = new Stack<TypeTree>();
parents.Push (this);
using (var buf = new BinMemoryStream (node_data))
{
for (int i = 0; i < count; ++i)
{
int version = buf.ReadInt16();
int depth = buf.ReadUInt8();
TypeTree current;
if (0 == depth)
{
current = this;
}
else
{
while (parents.Count > depth)
parents.Pop();
current = new TypeTree (m_format);
parents.Peek().Children.Add (current);
parents.Push (current);
}
current.Version = version;
current.IsArray = buf.ReadUInt8() != 0;
current.Type = GetString (buf.ReadInt32());
current.Name = GetString (buf.ReadInt32());
current.Size = buf.ReadInt32();
current.Index = buf.ReadUInt32();
current.Flags = buf.ReadInt32();
}
}
}
string GetString (int offset)
{
byte[] strings;
if (offset < 0)
{
offset &= 0x7FFFFFFF;
strings = StringsDat.Value;
}
else if (offset < m_data.Length)
strings = m_data;
else
return Null;
return Binary.GetCString (strings, offset, strings.Length-offset, Encoding.UTF8);
}
internal static byte[] LoadResource (string name)
{
2018-04-11 02:16:23 +08:00
var res = EmbeddedResource.Load (name, typeof(TypeTree));
if (null == res)
throw new FileNotFoundException ("Resource not found.", name);
return res;
}
}
internal class UnityTypeData
{
string m_version;
List<int> m_class_ids = new List<int> ();
Dictionary<int, byte[]> m_hashes = new Dictionary<int, byte[]> ();
Dictionary<int, TypeTree> m_type_trees = new Dictionary<int, TypeTree> ();
public string Version { get { return m_version; } }
public IList<int> ClassIds { get { return m_class_ids; } }
public IDictionary<int, byte[]> Hashes { get { return m_hashes; } }
public IDictionary<int, TypeTree> TypeTrees { get { return m_type_trees; } }
public void Load (AssetReader reader)
{
int format = reader.Format;
m_version = reader.ReadCString();
var platform = reader.ReadInt32 ();
if (format >= 13)
{
bool has_type_trees = reader.ReadBool ();
int count = reader.ReadInt32 ();
for (int i = 0; i < count; ++i)
{
int class_id = reader.ReadInt32 ();
if (format >= 17)
{
reader.ReadByte ();
int script_id = reader.ReadInt16 ();
if (114 == class_id)
{
if (script_id >= 0)
class_id = -2 - script_id;
else
class_id = -1;
}
}
m_class_ids.Add (class_id);
byte[] hash = reader.ReadBytes (class_id < 0 ? 0x20 : 0x10);
m_hashes[class_id] = hash;
if (has_type_trees)
{
var tree = new TypeTree (format);
tree.Load (reader);
m_type_trees[class_id] = tree;
}
}
}
else
{
int count = reader.ReadInt32 ();
for (int i = 0; i < count; ++i)
{
int class_id = reader.ReadInt32 ();
var tree = new TypeTree (format);
tree.Load (reader);
m_type_trees[class_id] = tree;
}
}
}
}
}