private void SetSerialized(AssetTypeTemplateField field, TypeDefinition type)
{
List <AssetTypeTemplateField> types = new List <AssetTypeTemplateField>();
RecursiveTypeLoad(type, types);
field.childrenCount = types.Count;
field.children = types.ToArray();
}
private AssetTypeTemplateField[] VECf()
{
AssetTypeTemplateField x = CreateTemplateField("x", "float", EnumValueTypes.ValueType_Float);
AssetTypeTemplateField y = CreateTemplateField("y", "float", EnumValueTypes.ValueType_Float);
AssetTypeTemplateField z = CreateTemplateField("z", "float", EnumValueTypes.ValueType_Float);
return(new AssetTypeTemplateField[] { x, y, z });
}
private void SetSerialized(AssetTypeTemplateField field, TypeDefinition type)
{
AssetTypeTemplateField[] types = new AssetTypeTemplateField[] { };
types = RecursiveTypeLoad(assembly.MainModule, type, types);
//AssetTypeTemplateField[] types = ReadTypes(type);
field.childrenCount = (uint)types.Length;
field.children = types;
}
private void RecurseTextDump(AssetTypeValueField field, int depth)
{
AssetTypeTemplateField template = field.GetTemplateField();
string align = template.align ? "1" : "0";
string typeName = template.type;
string fieldName = template.name;
bool isArray = template.isArray;
//string's field isn't aligned but its array is
if (template.valueType == EnumValueTypes.String)
{
align = "1";
}
if (isArray)
{
AssetTypeTemplateField sizeTemplate = template.children[0];
string sizeAlign = sizeTemplate.align ? "1" : "0";
string sizeTypeName = sizeTemplate.type;
string sizeFieldName = sizeTemplate.name;
int size = field.GetValue().AsArray().size;
sw.WriteLine($"{new string(' ', depth)}{align} {typeName} {fieldName} ({size} items)");
sw.WriteLine($"{new string(' ', depth+1)}{sizeAlign} {sizeTypeName} {sizeFieldName} = {size}");
for (int i = 0; i < field.childrenCount; i++)
{
sw.WriteLine($"{new string(' ', depth+1)}[{i}]");
RecurseTextDump(field.children[i], depth + 2);
}
}
else
{
string value = "";
if (field.GetValue() != null)
{
EnumValueTypes evt = field.GetValue().GetValueType();
if (evt == EnumValueTypes.String)
{
//only replace \ with \\ but not " with \" lol
//you just have to find the last "
string fixedStr = field.GetValue().AsString()
.Replace("\\", "\\\\")
.Replace("\r", "\\r")
.Replace("\n", "\\n");
value = $" = \"{fixedStr}\"";
}
else if (1 <= (int)evt && (int)evt <= 12)
{
value = $" = {field.GetValue().AsString()}";
}
}
sw.WriteLine($"{new string(' ', depth)}{align} {typeName} {fieldName}{value}");
for (int i = 0; i < field.childrenCount; i++)
{
RecurseTextDump(field.children[i], depth + 1);
}
}
}
private AssetTypeTemplateField[] RectOffset()
{
AssetTypeTemplateField m_Left = CreateTemplateField("m_Left", "int", EnumValueTypes.Int32);
AssetTypeTemplateField m_Right = CreateTemplateField("m_Right", "int", EnumValueTypes.Int32);
AssetTypeTemplateField m_Top = CreateTemplateField("m_Top", "int", EnumValueTypes.Int32);
AssetTypeTemplateField m_Bottom = CreateTemplateField("m_Bottom", "int", EnumValueTypes.Int32);
return(new AssetTypeTemplateField[] { m_Left, m_Right, m_Top, m_Bottom });
}
private void SetBitField(AssetTypeTemplateField field)
{
field.childrenCount = 1;
AssetTypeTemplateField m_Bits = CreateTemplateField("m_Bits", "unsigned int", EnumValueTypes.UInt32);
field.children = new AssetTypeTemplateField[] {
m_Bits
};
}
public AssetTypeInstance GetATI(AssetsFile file, AssetFileInfoEx info, bool forceFromCldb = false)
{
ushort scriptIndex = file.typeTree.unity5Types[info.curFileTypeOrIndex].scriptIndex;
//unity is wack
uint fixedId = info.curFileType;
if (fixedId == 0xf1) //AudioMixerController
{
fixedId = 0xf0; //AudioMixer
}
else if (fixedId == 0xf3) //AudioMixerGroupController
{
fixedId = 0x111; //AudioMixerGroup
}
else if (fixedId == 0xf5) //AudioMixerSnapshotController
{
fixedId = 0x110; //AudioMixerSnapshot
}
bool hasTypeTree = file.typeTree.hasTypeTree;
AssetTypeTemplateField baseField = null;
if (useTemplateFieldCache)
{
if (templateFieldCache.ContainsKey(fixedId))
{
baseField = templateFieldCache[fixedId];
}
else
{
baseField = new AssetTypeTemplateField();
if (hasTypeTree && !forceFromCldb)
{
baseField.From0D(file.typeTree.unity5Types.First(t => (t.classId == fixedId || t.classId == info.curFileType) && t.scriptIndex == scriptIndex), 0);
}
else
{
baseField.FromClassDatabase(classFile, AssetHelper.FindAssetClassByID(classFile, fixedId), 0);
}
templateFieldCache[fixedId] = baseField;
}
}
else
{
baseField = new AssetTypeTemplateField();
if (hasTypeTree && !forceFromCldb)
{
baseField.From0D(file.typeTree.unity5Types.First(t => (t.classId == fixedId || t.classId == info.curFileType) && t.scriptIndex == scriptIndex), 0);
}
else
{
baseField.FromClassDatabase(classFile, AssetHelper.FindAssetClassByID(classFile, fixedId), 0);
}
}
return(new AssetTypeInstance(baseField, file.reader, info.absoluteFilePos));
}
private void SetGradientRGBAb(AssetTypeTemplateField field)
{
field.childrenCount = 1;
AssetTypeTemplateField rgba = CreateTemplateField("rgba", "unsigned int", EnumValueTypes.UInt32);
field.children = new AssetTypeTemplateField[] {
rgba
};
}
private AssetTypeTemplateField[] RGBAf()
{
AssetTypeTemplateField r = CreateTemplateField("r", "float", EnumValueTypes.Float);
AssetTypeTemplateField g = CreateTemplateField("g", "float", EnumValueTypes.Float);
AssetTypeTemplateField b = CreateTemplateField("b", "float", EnumValueTypes.Float);
AssetTypeTemplateField a = CreateTemplateField("a", "float", EnumValueTypes.Float);
return(new AssetTypeTemplateField[] { r, g, b, a });
}
private void SetAABB(AssetTypeTemplateField field)
{
field.childrenCount = 2;
AssetTypeTemplateField m_Center = CreateTemplateField("m_Center", "Vector3f", EnumValueTypes.None, 3, Vec3f());
AssetTypeTemplateField m_Extent = CreateTemplateField("m_Extent", "Vector3f", EnumValueTypes.None, 3, Vec3f());
field.children = new AssetTypeTemplateField[] {
m_Center, m_Extent
};
}
static AssetTypeValueField StringField(string str, AssetTypeTemplateField template)
{
return(new AssetTypeValueField()
{
children = null,
childrenCount = 0,
templateField = template,
value = new AssetTypeValue(EnumValueTypes.ValueType_String, str)
});
}
private void SetVec2Int(AssetTypeTemplateField field)
{
field.childrenCount = 2;
AssetTypeTemplateField m_X = CreateTemplateField("m_X", "int", EnumValueTypes.Int32);
AssetTypeTemplateField m_Y = CreateTemplateField("m_Y", "int", EnumValueTypes.Int32);
field.children = new AssetTypeTemplateField[] {
m_X, m_Y
};
}
private AssetTypeTemplateField[] String()
{
AssetTypeTemplateField size = CreateTemplateField("size", "int", EnumValueTypes.Int32);
AssetTypeTemplateField data = CreateTemplateField("char", "data", EnumValueTypes.UInt8);
AssetTypeTemplateField Array = CreateTemplateField("Array", "Array", EnumValueTypes.Array, true, true, 2, new AssetTypeTemplateField[] {
size, data
});
return(new AssetTypeTemplateField[] { Array });
}
public static AssetTypeValueField DefaultValueFieldFromArrayTemplate(AssetTypeTemplateField arrayField)
{
if (!arrayField.isArray)
{
return(null);
}
AssetTypeTemplateField templateField = arrayField.children[1];
return(DefaultValueFieldFromTemplate(templateField));
}
private void SetRectf(AssetTypeTemplateField field)
{
field.childrenCount = 4;
AssetTypeTemplateField x = CreateTemplateField("x", "float", EnumValueTypes.Float);
AssetTypeTemplateField y = CreateTemplateField("y", "float", EnumValueTypes.Float);
AssetTypeTemplateField width = CreateTemplateField("width", "float", EnumValueTypes.Float);
AssetTypeTemplateField height = CreateTemplateField("height", "float", EnumValueTypes.Float);
field.children = new AssetTypeTemplateField[] {
x, y, width, height
};
}
public static AssetTypeValue DefaultValueFromTemplate(AssetTypeTemplateField templateField)
{
object obj;
switch (templateField.valueType)
{
case EnumValueTypes.Int8:
obj = (sbyte)0; break;
case EnumValueTypes.UInt8:
obj = (byte)0; break;
case EnumValueTypes.Bool:
obj = false; break;
case EnumValueTypes.Int16:
obj = (short)0; break;
case EnumValueTypes.UInt16:
obj = (ushort)0; break;
case EnumValueTypes.Int32:
obj = 0; break;
case EnumValueTypes.UInt32:
obj = 0u; break;
case EnumValueTypes.Int64:
obj = 0L; break;
case EnumValueTypes.UInt64:
obj = 0uL; break;
case EnumValueTypes.Float:
obj = 0f; break;
case EnumValueTypes.Double:
obj = 0d; break;
case EnumValueTypes.String:
obj = string.Empty; break;
case EnumValueTypes.Array:
obj = new AssetTypeArray(); break;
case EnumValueTypes.ByteArray:
obj = new AssetTypeByteArray(); break;
default:
obj = null; break;
}
return(new AssetTypeValue(templateField.valueType, obj));
}
public AssetTypeValueField GetMonoBaseFieldCached(AssetsFileInstance inst, AssetFileInfoEx info, string managedPath)
{
AssetsFile file = inst.file;
ushort scriptIndex = AssetHelper.GetScriptIndex(file, info);
if (scriptIndex == 0xFFFF)
{
return(null);
}
string scriptName;
if (!inst.monoIdToName.ContainsKey(scriptIndex))
{
AssetTypeInstance scriptAti = GetExtAsset(inst, GetTypeInstance(inst.file, info).GetBaseField().Get("m_Script")).instance;
//couldn't find asset
if (scriptAti == null)
{
return(null);
}
scriptName = scriptAti.GetBaseField().Get("m_Name").GetValue().AsString();
string scriptNamespace = scriptAti.GetBaseField().Get("m_Namespace").GetValue().AsString();
string assemblyName = scriptAti.GetBaseField().Get("m_AssemblyName").GetValue().AsString();
if (scriptNamespace == string.Empty)
{
scriptNamespace = "-";
}
scriptName = $"{assemblyName}.{scriptNamespace}.{scriptName}";
inst.monoIdToName[scriptIndex] = scriptName;
}
else
{
scriptName = inst.monoIdToName[scriptIndex];
}
if (monoTemplateFieldCache.ContainsKey(scriptName))
{
AssetTypeTemplateField baseTemplateField = monoTemplateFieldCache[scriptName];
AssetTypeInstance baseAti = new AssetTypeInstance(baseTemplateField, file.reader, info.absoluteFilePos);
return(baseAti.GetBaseField());
}
else
{
AssetTypeValueField baseValueField = MonoDeserializer.GetMonoBaseField(this, inst, info, managedPath);
monoTemplateFieldCache[scriptName] = baseValueField.templateField;
return(baseValueField);
}
}
public AssetTypeInstance(AssetTypeTemplateField[] baseFields, AssetsFileReader reader, long filePos)
{
reader.bigEndian = false;
reader.Position = filePos;
this.baseFieldCount = baseFields.Length;
this.baseFields = new AssetTypeValueField[baseFieldCount];
for (int i = 0; i < baseFieldCount; i++)
{
AssetTypeTemplateField templateBaseField = baseFields[i];
AssetTypeValueField atvf = templateBaseField.MakeValue(reader);
this.baseFields[i] = atvf;
}
}
public static AssetTypeValueField GetMonoBaseField(AssetsManager am, AssetsFileInstance inst, AssetFileInfoEx info, string managedPath, bool cached = true)
{
AssetsFile file = inst.file;
AssetTypeTemplateField baseField = new AssetTypeTemplateField();
baseField.FromClassDatabase(am.classFile, AssetHelper.FindAssetClassByID(am.classFile, info.curFileType), 0);
AssetTypeInstance mainAti = new AssetTypeInstance(baseField, file.reader, info.absoluteFilePos);
ushort scriptIndex = AssetHelper.GetScriptIndex(file, info);
if (scriptIndex != 0xFFFF)
{
AssetTypeInstance scriptAti = am.GetExtAsset(inst, mainAti.GetBaseField().Get("m_Script")).instance;
string scriptName = scriptAti.GetBaseField().Get("m_ClassName").GetValue().AsString();
string scriptNamespace = scriptAti.GetBaseField().Get("m_Namespace").GetValue().AsString();
string assemblyName = scriptAti.GetBaseField().Get("m_AssemblyName").GetValue().AsString();
string assemblyPath = Path.Combine(managedPath, assemblyName);
if (scriptNamespace != string.Empty)
{
scriptName = scriptNamespace + "." + scriptName;
}
if (File.Exists(assemblyPath))
{
AssemblyDefinition asmDef;
if (cached)
{
if (!loadedAssemblies.ContainsKey(assemblyName))
{
loadedAssemblies.Add(assemblyName, GetAssemblyWithDependencies(assemblyPath));
}
asmDef = loadedAssemblies[assemblyName];
}
else
{
asmDef = GetAssemblyWithDependencies(assemblyPath);
}
MonoDeserializer mc = new MonoDeserializer();
mc.Read(scriptName, asmDef, inst.file.header.format);
List <AssetTypeTemplateField> monoTemplateFields = mc.children;
AssetTypeTemplateField[] templateField = baseField.children.Concat(monoTemplateFields).ToArray();
baseField.children = templateField;
baseField.childrenCount = baseField.children.Length;
mainAti = new AssetTypeInstance(baseField, file.reader, info.absoluteFilePos);
}
}
return(mainAti.GetBaseField());
}
public AssetTypeValueField GetMonoBaseField(AssetContainer cont, string managedPath)
{
var file = cont.FileInstance.file;
var item = cont.Item;
var baseTemp = new AssetTypeTemplateField();
baseTemp.FromClassDatabase(Am.classFile, AssetHelper.FindAssetClassByID(Am.classFile, item.TypeID), 0);
var mainAti = new AssetTypeInstance(baseTemp, cont.FileReader, item.Position);
var scriptIndex = item.MonoID;
if (scriptIndex != 0xFFFF)
{
var monoScriptCont = GetAssetContainer(mainAti.GetBaseField().Get("m_Script"));
if (monoScriptCont == null)
{
return(null);
}
var scriptBaseField = monoScriptCont.TypeInstance.GetBaseField();
var scriptName = scriptBaseField.Get("m_Name").GetValue().AsString();
var scriptNamespace = scriptBaseField.Get("m_Namespace").GetValue().AsString();
var assemblyName = scriptBaseField.Get("m_AssemblyName").GetValue().AsString();
var assemblyPath = Path.Combine(managedPath, assemblyName);
if (scriptNamespace != string.Empty)
{
scriptName = scriptNamespace + "." + scriptName;
}
if (File.Exists(assemblyPath))
{
if (!LoadedAssemblies.ContainsKey(assemblyName))
{
LoadedAssemblies.Add(assemblyName, MonoDeserializer.GetAssemblyWithDependencies(assemblyPath));
}
var asmDef = LoadedAssemblies[assemblyName];
var mc = new MonoDeserializer();
mc.Read(scriptName, asmDef, file.header.format);
var monoTemplateFields = mc.children;
var templateField = baseTemp.children.Concat(monoTemplateFields).ToArray();
baseTemp.children = templateField;
baseTemp.childrenCount = baseTemp.children.Length;
mainAti = new AssetTypeInstance(baseTemp, cont.FileReader, item.Position);
}
}
return(mainAti.GetBaseField());
}
public static AssetTypeInstance GetByteArrayTexture(AssetWorkspace workspace, AssetContainer tex)
{
AssetTypeTemplateField textureTemp = workspace.GetTemplateField(tex.FileInstance.file, tex.ClassId, tex.MonoId);
AssetTypeTemplateField image_data = textureTemp.children.FirstOrDefault(f => f.name == "image data");
if (image_data == null)
{
return(null);
}
image_data.valueType = EnumValueTypes.ByteArray;
AssetTypeInstance textureTypeInstance = new AssetTypeInstance(new[] { textureTemp }, tex.FileReader, tex.FilePosition);
return(textureTypeInstance);
}
public AssetTypeInstance(uint baseFieldCount, AssetTypeTemplateField[] ppBaseFields, AssetsFileReader reader, bool bigEndian, ulong filePos = 0)
{
this.baseFieldCount = baseFieldCount;
reader.bigEndian = false;
reader.BaseStream.Position = (long)filePos;
baseFields = new AssetTypeValueField[this.baseFieldCount];
for (int i = 0; i < baseFieldCount; i++)
{
AssetTypeTemplateField templateBaseField = ppBaseFields[i];
AssetTypeValueField atvf;
templateBaseField.MakeValue(reader, reader.Position, out atvf, reader.bigEndian);
baseFields[i] = atvf;
}
}
private void SetSpecialUnity(AssetTypeTemplateField field, TypeDefWithSelfRef type)
{
switch (type.typeDef.Name)
{
case "Gradient":
SetGradient(field);
break;
case "AnimationCurve":
SetAnimationCurve(field);
break;
case "LayerMask":
SetBitField(field);
break;
case "Bounds":
SetAABB(field);
break;
case "Rect":
SetRectf(field);
break;
case "Color32":
SetGradientRGBAb(field);
break;
case "GUIStyle":
SetGUIStyle(field);
break;
case "BoundsInt":
SetAABBInt(field);
break;
case "Vector2Int":
SetVec2Int(field);
break;
case "Vector3Int":
SetVec3Int(field);
break;
default:
SetSerialized(field, type);
break;
}
}
private AssetTypeTemplateField CreateTemplateField(string name, string type, EnumValueTypes valueType, bool isArray, bool align, int childrenCount, AssetTypeTemplateField[] children)
{
AssetTypeTemplateField field = new AssetTypeTemplateField();
field.name = name;
field.type = type;
field.valueType = valueType;
field.isArray = isArray;
field.align = align;
field.hasValue = valueType != EnumValueTypes.None;
field.childrenCount = childrenCount;
field.children = children;
return(field);
}
public AssetTypeTemplateField CreateTemplateField(string name, string type, EnumValueTypes valueType, bool isArray, bool align, uint childrenCount, AssetTypeTemplateField[] children)
{
AssetTypeTemplateField field = new AssetTypeTemplateField();
field.name = name;
field.type = type;
field.valueType = valueType;
field.isArray = isArray;
field.align = align;
field.hasValue = (valueType == EnumValueTypes.ValueType_None) ? false : true;
field.childrenCount = childrenCount;
field.children = children;
return(field);
}
private void GameObjectViewer_Load(object sender, EventArgs e)
{
//mono won't be able to do this so ignore it
if (Type.GetType("Mono.Runtime") == null)
{
PInvoke.SetWindowTheme(goTree.Handle, "explorer", null);
}
valueGrid.PropertySort = PropertySort.Categorized;
ClassDatabaseFile classFile = helper.classFile;
AssetFileInfoEx info = inst.table.GetAssetInfo(selectedId);
AssetTypeTemplateField typeTemplate = helper.GetTemplateBaseField(inst.file, info);
string typeName = typeTemplate.type;
if (typeName == "GameObject")
{
selectedGameObjectId = selectedId;
AssetExternal firstExt = helper.GetExtAsset(inst, 0, selectedId);
AssetExternal rootExt = GetRootGameObject(firstExt);
PopulateHierarchyTree(null, rootExt);
}
else
{
bool hasGameObjectField = typeTemplate.children.Any(f => f.name == "m_GameObject");
if (hasGameObjectField)
{
AssetTypeValueField firstBaseField = helper.GetTypeInstance(inst.file, info).GetBaseField();
AssetExternal firstExt = helper.GetExtAsset(inst, firstBaseField.Get("m_GameObject"));
if (firstExt.info != null)
{
selectedGameObjectId = firstExt.info.index;
AssetExternal rootExt = GetRootGameObject(firstExt);
PopulateHierarchyTree(null, rootExt);
}
else
{
TreeNode node = goTree.Nodes.Add($"[{typeName} (parentless)]");
node.Tag = helper.GetExtAsset(inst, 0, info.index);
}
}
else
{
TreeNode node = goTree.Nodes.Add($"[{typeName}]");
node.Tag = helper.GetExtAsset(inst, 0, info.index);
}
}
GetSelectedNodeData();
}
public static AssetTypeValueField GetMonoBaseFieldCached(this AssetsManager am, AssetsFileInstance inst, AssetFileInfoEx info, string managedPath, List <string> fileNames, Dictionary <AssetID, long> aidToPid)
{
AssetsFile file = inst.file;
ushort scriptIndex = file.typeTree.unity5Types[info.curFileTypeOrIndex].scriptIndex;
if (scriptIndex != 0xFFFF && inst.templateFieldCache.ContainsKey(scriptIndex))
{
AssetTypeTemplateField baseTemplateField = inst.templateFieldCache[scriptIndex];
AssetTypeInstance baseAti = new AssetTypeInstance(baseTemplateField, file.reader, info.absoluteFilePos);
return(baseAti.GetBaseField());
}
else
{
AssetTypeTemplateField baseField = new AssetTypeTemplateField();
baseField.FromClassDatabase(am.classFile, AssetHelper.FindAssetClassByID(am.classFile, info.curFileType), 0);
AssetTypeInstance mainAti = new AssetTypeInstance(baseField, file.reader, info.absoluteFilePos);
if (file.typeTree.unity5Types[info.curFileTypeOrIndex].scriptIndex != 0xFFFF)
{
AssetTypeValueField m_Script = mainAti.GetBaseField().Get("m_Script");
int m_ScriptFileId = m_Script.Get("m_FileID").GetValue().AsInt();
long m_ScriptPathId = m_Script.Get("m_PathID").GetValue().AsInt64();
AssetID id = new AssetID(fileNames[-m_ScriptFileId], m_ScriptPathId);
long m_ScriptRealPathId = aidToPid[id];
AssetTypeInstance scriptAti = am.GetExtAsset(inst, 0, m_ScriptRealPathId).instance;
string scriptName = scriptAti.GetBaseField().Get("m_Name").GetValue().AsString();
string assemblyName = scriptAti.GetBaseField().Get("m_AssemblyName").GetValue().AsString();
string assemblyPath = Path.Combine(managedPath, assemblyName);
Console.WriteLine("checking " + scriptName + " in " + assemblyName + " from id " + info.index);
if (File.Exists(assemblyPath))
{
MonoDeserializer mc = new MonoDeserializer();
mc.Read(scriptName, assemblyPath, inst.file.header.format);
List <AssetTypeTemplateField> monoTemplateFields = mc.children;
AssetTypeTemplateField[] templateField = baseField.children.Concat(monoTemplateFields).ToArray();
baseField.children = templateField;
baseField.childrenCount = baseField.children.Length;
mainAti = new AssetTypeInstance(baseField, file.reader, info.absoluteFilePos);
}
}
AssetTypeValueField baseValueField = mainAti.GetBaseField();
inst.templateFieldCache[scriptIndex] = baseValueField.templateField;
return(baseValueField);
}
}
public AssetTypeInstance GetATI(AssetsFile file, AssetFileInfoEx info, bool forceFromCldb = false)
{
ushort scriptIndex = AssetHelper.GetScriptIndex(file, info);
uint fixedId = AssetHelper.FixAudioID(info.curFileType);
bool hasTypeTree = file.typeTree.hasTypeTree;
AssetTypeTemplateField baseField;
if (useTemplateFieldCache && templateFieldCache.ContainsKey(fixedId))
{
baseField = templateFieldCache[fixedId];
}
else
{
baseField = new AssetTypeTemplateField();
if (hasTypeTree && !forceFromCldb)
{
if (file.header.format < 0x10)
{
if (scriptIndex == 0xFFFF)
{
baseField.From0D(AssetHelper.FindTypeTreeTypeByID(file.typeTree, fixedId), 0);
}
else
{
baseField.From0D(AssetHelper.FindTypeTreeTypeByScriptIndex(file.typeTree, scriptIndex), 0);
}
}
else
{
baseField.From0D(AssetHelper.FindTypeTreeTypeByID(file.typeTree, fixedId), 0);
}
}
else
{
baseField.FromClassDatabase(classFile, AssetHelper.FindAssetClassByID(classFile, fixedId), 0);
}
if (useTemplateFieldCache)
{
templateFieldCache[fixedId] = baseField;
}
}
return(new AssetTypeInstance(baseField, file.reader, info.absoluteFilePos));
}
public AssetTypeValueField GetConcatMonoBaseField(AssetContainer cont, string managedPath)
{
AssetsFile file = cont.FileInstance.file;
AssetTypeTemplateField baseTemp = new AssetTypeTemplateField();
baseTemp.FromClassDatabase(am.classFile, AssetHelper.FindAssetClassByID(am.classFile, cont.ClassId), 0);
AssetTypeInstance mainAti = new AssetTypeInstance(baseTemp, cont.FileReader, cont.FilePosition);
ushort scriptIndex = cont.MonoId;
if (scriptIndex != 0xFFFF)
{
AssetContainer monoScriptCont = GetAssetContainer(cont.FileInstance, mainAti.GetBaseField().Get("m_Script"), false);
if (monoScriptCont == null)
return null;
AssetTypeValueField scriptBaseField = monoScriptCont.TypeInstance.GetBaseField();
string scriptName = scriptBaseField.Get("m_Name").GetValue().AsString();
string scriptNamespace = scriptBaseField.Get("m_Namespace").GetValue().AsString();
string assemblyName = scriptBaseField.Get("m_AssemblyName").GetValue().AsString();
string assemblyPath = Path.Combine(managedPath, assemblyName);
if (scriptNamespace != string.Empty)
scriptName = scriptNamespace + "." + scriptName;
if (File.Exists(assemblyPath))
{
AssemblyDefinition asmDef;
if (!LoadedAssemblies.ContainsKey(assemblyName))
{
LoadedAssemblies.Add(assemblyName, MonoDeserializer.GetAssemblyWithDependencies(assemblyPath));
}
asmDef = LoadedAssemblies[assemblyName];
MonoDeserializer mc = new MonoDeserializer();
mc.Read(scriptName, asmDef, file.header.format);
List<AssetTypeTemplateField> monoTemplateFields = mc.children;
AssetTypeTemplateField[] templateField = baseTemp.children.Concat(monoTemplateFields).ToArray();
baseTemp.children = templateField;
baseTemp.childrenCount = baseTemp.children.Length;
mainAti = new AssetTypeInstance(baseTemp, cont.FileReader, cont.FilePosition);
}
}
return mainAti.GetBaseField();
}
private void SetPPtr(AssetTypeTemplateField field, bool dollar)
{
if (dollar)
{
field.type = $"PPtr<${field.type}>";
}
else
{
field.type = $"PPtr<{field.type}>";
}
field.childrenCount = 2;
AssetTypeTemplateField fileID = new AssetTypeTemplateField();
fileID.name = "m_FileID";
fileID.type = "int";
fileID.valueType = EnumValueTypes.Int32;
fileID.isArray = false;
fileID.align = false;
fileID.hasValue = true;
fileID.childrenCount = 0;
fileID.children = new AssetTypeTemplateField[] { };
AssetTypeTemplateField pathID = new AssetTypeTemplateField();
pathID.name = "m_PathID";
if (format < 0x0E)
{
pathID.type = "int";
pathID.valueType = EnumValueTypes.Int32;
}
else
{
pathID.type = "SInt64";
pathID.valueType = EnumValueTypes.Int64;
}
pathID.isArray = false;
pathID.align = false;
pathID.hasValue = true;
pathID.childrenCount = 0;
pathID.children = new AssetTypeTemplateField[] { };
field.children = new AssetTypeTemplateField[] {
fileID, pathID
};
}
