chore: use new objreader syntax

Author: K0lb3

UnityPy/export/MeshRendererExporter.py

@@ -25,9 +25,9 @@ class Renderer(Renderer):
 def get_mesh(meshR: Renderer) -> Optional[Mesh]:
     if isinstance(meshR, SkinnedMeshRenderer):
         if meshR.m_Mesh:
-            return meshR.m_Mesh.read()
+            return meshR.m_Mesh.deref_parse_as_object()
     else:
-        m_GameObject = meshR.m_GameObject.read()
+        m_GameObject = meshR.m_GameObject.deref_parse_as_object()
         for comp in m_GameObject.m_Component:
             if isinstance(comp, tuple):
                 pptr = comp[1]
@@ -39,9 +39,9 @@ def get_mesh(meshR: Renderer) -> Optional[Mesh]:
             if not obj:
                 continue
             if obj.type.name == "MeshFilter":
-                filter: MeshFilter = pptr.read()
+                filter: MeshFilter = pptr.deref_parse_as_object()
                 if filter.m_Mesh:
-                    return filter.m_Mesh.read()
+                    return filter.m_Mesh.deref_parse_as_object()
     return None
 
 
@@ -66,7 +66,7 @@ def export_mesh_renderer(renderer: Renderer, export_dir: str) -> None:
             continue
         matPtr: Optional[PPtr[Material]] = renderer.m_Materials[i - firstSubMesh]
         if matPtr:
-            mat: Material = matPtr.read()
+            mat: Material = matPtr.deref_parse_as_object()
         else:
             material_names.append(None)
             continue
@@ -79,10 +79,10 @@ def export_mesh_renderer(renderer: Renderer, export_dir: str) -> None:
             if not isinstance(key, str):
                 # FastPropertyName
                 key = key.name
-            tex: Texture2D = texEnv.m_Texture.read()
+            tex: Texture2D = texEnv.m_Texture.deref_parse_as_object()
             texName = f"{tex.m_Name if tex.m_Name else key}.png"
             with env.fs.open(env.fs.sep.join([export_dir, texName]), "wb") as f:
-                tex.read().image.save(f)
+                tex.image.save(f)
 
     # save .obj
     with env.fs.open(
@@ -172,7 +172,7 @@ def properties_to_dict(properties):
             # FastPropertyName
             key = key.name
 
-        tex: Texture2D = texEnv.m_Texture.read()
+        tex: Texture2D = texEnv.m_Texture.deref_parse_as_object()
         texName = f"{tex.m_Name if tex.m_Name else key}.png"
         if key == "_MainTex":
             sb.append(f"map_Kd {texName}")

UnityPy/export/SpriteHelper.py

@@ -47,29 +47,30 @@ def get_image(sprite: Sprite, texture: PPtr[Texture2D], alpha_texture: Optional[
     if alpha_texture:
         cache_id = (texture.path_id, alpha_texture.path_id)
         if cache_id not in cache:
-            original_image = get_image_from_texture2d(texture.read(), False)
-            alpha_image = get_image_from_texture2d(alpha_texture.read(), False)
+            original_image = get_image_from_texture2d(texture.deref_parse_as_object(), False)
+            alpha_image = get_image_from_texture2d(alpha_texture.deref_parse_as_object(), False)
             original_image = Image.merge("RGBA", (*original_image.split()[:3], alpha_image.split()[0]))
             cache[cache_id] = original_image
     else:
         cache_id = texture.path_id
         if cache_id not in cache:
-            original_image = get_image_from_texture2d(texture.read(), False)
+            original_image = get_image_from_texture2d(texture.deref_parse_as_object(), False)
             cache[cache_id] = original_image
     return cache[cache_id]
 
 
 def get_image_from_sprite(m_Sprite: Sprite) -> Image.Image:
     atlas = None
     if m_Sprite.m_SpriteAtlas:
-        atlas = m_Sprite.m_SpriteAtlas.read()
+        atlas = m_Sprite.m_SpriteAtlas.deref_parse_as_object()
     elif m_Sprite.m_AtlasTags:
         # looks like the direct pointer is empty, let's try to find the Atlas via its name
         assert m_Sprite.assets_file, "Sprite assets file is not set!"
         for obj in m_Sprite.assets_file.objects.values():
             if obj.type == ClassIDType.SpriteAtlas:
-                atlas = obj.read()
-                if atlas.m_Name == m_Sprite.m_AtlasTags[0]:
+                name = obj.peek_name()
+                if name == m_Sprite.m_AtlasTags[0]:
+                    atlas = obj.parse_as_object()
                     break
                 atlas = None
 

UnityPy/files/SerializedFile.py

@@ -315,7 +315,7 @@ def __init__(self, reader: EndianBinaryReader, parent=None, name=None, **kwargs)
         # read the asset_bundles to get the containers
         for obj in self.objects.values():
             if obj.type == ClassIDType.AssetBundle:
-                self.assetbundle = obj.read()
+                self.assetbundle = obj.parse_as_object()
                 self._container = ContainerHelper(self.assetbundle)
                 break
         else:

UnityPy/tools/extractor.py

@@ -19,12 +19,12 @@
     Texture2D,
 )
 from UnityPy.enums.ClassIDType import ClassIDType
-from UnityPy.files import SerializedFile
+from UnityPy.files import ObjectReader, SerializedFile
 
 
 def export_obj(
-    obj: Union[Object, PPtr],
-    fp: Path,
+    obj: Union[ObjectReader, PPtr],
+    fp: str,
     append_name: bool = False,
     append_path_id: bool = False,
     export_unknown_as_typetree: bool = False,
@@ -53,25 +53,29 @@ def export_obj(
             return []
 
     # set filepath
-    obj = obj.read()
+    if isinstance(obj, PPtr):
+        obj = obj.deref()
+
+    instance = obj.parse_as_object()
 
     # a filter that returned True during an earlier extract_assets check can return False now with more info from read()
-    if asset_filter and not asset_filter(obj):
+    if asset_filter and not asset_filter(instance):
         return []
 
     if append_name:
+        name = getattr(instance, "m_Name", obj.type.name)
         fp = os.path.join(
             fp,
-            obj.m_Name if getattr(obj, "m_Name") else obj.object_reader.type.name,  # noqa: B009
+            name,
         )
 
     fp, extension = os.path.splitext(fp)
 
     if append_path_id:
-        fp = f"{fp}_{obj.object_reader.path_id}"
+        fp = f"{fp}_{obj.m_PathID}"
 
     # export
-    return export_func(obj, fp, extension)
+    return export_func(instance, fp, extension)
 
 
 def extract_assets(
@@ -158,15 +162,21 @@ def defaulted_export_index(type: ClassIDType):
 ###############################################################################
 
 
-def exportTextAsset(obj: TextAsset, fp: str, extension: str = ".txt") -> List[Tuple[SerializedFile, int]]:
+def exportTextAsset(
+    obj: Union[TextAsset, ObjectReader], fp: str, extension: str = ".txt"
+) -> List[Tuple[SerializedFile, int]]:
+    if isinstance(obj, ObjectReader):
+        obj = obj.parse_as_object()
     if not extension:
         extension = ".txt"
     with open(f"{fp}{extension}", "wb") as f:
         f.write(obj.m_Script.encode("utf-8", "surrogateescape"))
     return [(obj.assets_file, obj.object_reader.path_id)]
 
 
-def exportFont(obj: Font, fp: str, extension: str = "") -> List[Tuple[SerializedFile, int]]:
+def exportFont(obj: Union[Font, ObjectReader], fp: str, extension: str = "") -> List[Tuple[SerializedFile, int]]:
+    if isinstance(obj, ObjectReader):
+        obj = obj.parse_as_object()
     # TODO - export glyphs
     if obj.m_FontData:
         extension = ".ttf"
@@ -177,15 +187,19 @@ def exportFont(obj: Font, fp: str, extension: str = "") -> List[Tuple[Serialized
     return [(obj.assets_file, obj.object_reader.path_id)]
 
 
-def exportMesh(obj: Mesh, fp: str, extension=".obj") -> List[Tuple[SerializedFile, int]]:
+def exportMesh(obj: Union[Mesh, ObjectReader], fp: str, extension=".obj") -> List[Tuple[SerializedFile, int]]:
+    if isinstance(obj, ObjectReader):
+        obj = obj.parse_as_object()
     if not extension:
         extension = ".obj"
     with open(f"{fp}{extension}", "wt", encoding="utf8", newline="") as f:
         f.write(obj.export())
     return [(obj.assets_file, obj.object_reader.path_id)]
 
 
-def exportShader(obj: Shader, fp: str, extension=".txt") -> List[Tuple[SerializedFile, int]]:
+def exportShader(obj: Union[Shader, ObjectReader], fp: str, extension=".txt") -> List[Tuple[SerializedFile, int]]:
+    if isinstance(obj, ObjectReader):
+        obj = obj.parse_as_object()
     if not extension:
         extension = ".txt"
     with open(f"{fp}{extension}", "wt", encoding="utf8", newline="") as f:
@@ -194,39 +208,32 @@ def exportShader(obj: Shader, fp: str, extension=".txt") -> List[Tuple[Serialize
 
 
 def exportMonoBehaviour(
-    obj: Union[MonoBehaviour, Object], fp: str, extension: str = ""
+    obj: Union[MonoBehaviour, ObjectReader], fp: str, extension: str = ""
 ) -> List[Tuple[SerializedFile, int]]:
-    export = None
-
-    if obj.object_reader.serialized_type.node:
-        # a typetree is available from the SerializedFile for this object
-        export = obj.object_reader.read_typetree()
-    elif isinstance(obj, MonoBehaviour):
-        # try to get the typetree from the MonoBehavior script
-        script_ptr = obj.m_Script
-        if script_ptr:
-            # looks like we have a script
-            script = script_ptr.read()
-            # check if there is a locally stored typetree for it
-            nodes = MONOBEHAVIOUR_TYPETREES.get(script.m_AssemblyName, {}).get(script.m_ClassName, None)
-            if nodes:
-                export = obj.object_reader.read_typetree(nodes)
-    else:
-        export = obj.object_reader.read_typetree()
+    reader = obj.object_reader if isinstance(obj, MonoBehaviour) else obj
 
-    if not export:
-        extension = ".bin"
-        export = obj.object_reader.raw_data
-    else:
+    try:
+        export = reader.parse_as_dict()
         extension = ".json"
         export = json.dumps(export, indent=4, ensure_ascii=False).encode("utf8", errors="surrogateescape")
+    except Exception:
+        extension = ".bin"
+        export = reader.get_raw_data()
     with open(f"{fp}{extension}", "wb") as f:
         f.write(export)
-    return [(obj.assets_file, obj.object_reader.path_id)]
+    return [(obj.assets_file, obj.path_id)]
 
 
-def exportAudioClip(obj: AudioClip, fp: str, extension: str = "") -> List[Tuple[SerializedFile, int]]:
-    samples = obj.samples
+def exportAudioClip(
+    obj: Union[AudioClip, ObjectReader], fp: str, extension: str = ""
+) -> List[Tuple[SerializedFile, int]]:
+    if isinstance(obj, ObjectReader):
+        clip = obj.parse_as_object()
+    else:
+        clip = obj
+        obj = clip.object_reader
+
+    samples = clip.samples
     if len(samples) == 0:
         pass
     elif len(samples) == 1:
@@ -237,25 +244,35 @@ def exportAudioClip(obj: AudioClip, fp: str, extension: str = "") -> List[Tuple[
         for name, clip_data in samples.items():
             with open(os.path.join(fp, f"{name}.wav"), "wb") as f:
                 f.write(clip_data)
-    return [(obj.assets_file, obj.object_reader.path_id)]
+    return [(obj.assets_file, obj.path_id)]
 
 
-def exportSprite(obj: Sprite, fp: str, extension: str = ".png") -> List[Tuple[SerializedFile, int]]:
-    if not extension:
-        extension = ".png"
-    obj.image.save(f"{fp}{extension}")
+def exportSprite(
+    obj: Union[Sprite, ObjectReader], fp: str, extension: str = ".png"
+) -> List[Tuple[SerializedFile, int]]:
+    if isinstance(obj, ObjectReader):
+        sprite = obj.parse_as_object()
+    else:
+        sprite = obj
+        obj = sprite.object_reader
+
+    sprite.image.save(f"{fp}{extension}")
     exported = [
-        (obj.assets_file, obj.object_reader.path_id),
-        (obj.m_RD.texture.assetsfile, obj.m_RD.texture.path_id),
+        (obj.assets_file, obj.path_id),
+        (sprite.m_RD.texture.assetsfile, sprite.m_RD.texture.path_id),
     ]
-    alpha_assets_file = getattr(obj.m_RD.alphaTexture, "assets_file", None)
-    alpha_path_id = getattr(obj.m_RD.alphaTexture, "path_id", None)
+    alpha_assets_file = getattr(sprite.m_RD.alphaTexture, "assets_file", None)
+    alpha_path_id = getattr(sprite.m_RD.alphaTexture, "path_id", None)
     if alpha_path_id and alpha_assets_file:
         exported.append((alpha_assets_file, alpha_path_id))
     return exported
 
 
-def exportTexture2D(obj: Texture2D, fp: str, extension: str = ".png") -> List[Tuple[SerializedFile, int]]:
+def exportTexture2D(
+    obj: Union[Texture2D, ObjectReader], fp: str, extension: str = ".png"
+) -> List[Tuple[SerializedFile, int]]:
+    if isinstance(obj, ObjectReader):
+        obj = obj.parse_as_object()
     if not extension:
         extension = ".png"
     if obj.m_Width:
@@ -264,7 +281,11 @@ def exportTexture2D(obj: Texture2D, fp: str, extension: str = ".png") -> List[Tu
     return [(obj.assets_file, obj.object_reader.path_id)]
 
 
-def exportGameObject(obj: GameObject, fp: str, extension: str = "") -> List[Tuple[SerializedFile, int]]:
+def exportGameObject(
+    obj: Union[GameObject, ObjectReader], fp: str, extension: str = ""
+) -> List[Tuple[SerializedFile, int]]:
+    if isinstance(obj, ObjectReader):
+        obj = obj.parse_as_object()
     exported = [(obj.assets_file, obj.object_reader.path_id)]
     refs = crawl_obj(obj)
     if refs:
@@ -303,34 +324,34 @@ def exportGameObject(obj: GameObject, fp: str, extension: str = "") -> List[Tupl
 MONOBEHAVIOUR_TYPETREES: Dict[ASSEMBLY_NAME_DLL, Dict[CLASS_NAME, List[Dict]]] = {}
 
 
-def crawl_obj(obj: Object, ret: Optional[dict] = None) -> Dict[int, Union[Object, PPtr]]:
+def crawl_obj(obj: Union[Object, ObjectReader, PPtr], ret: Optional[dict] = None) -> Dict[int, Union[Object, PPtr]]:
     """Crawls through the data struture of the object
     and returns a list of all the components.
     """
     if not ret:
         ret = {}
 
+    values: Sequence
     if isinstance(obj, PPtr):
-        if obj.path_id == 0 and obj.file_id == 0 and obj.index == -2:
+        if obj.m_PathID == 0 and obj.m_FileID == 0 and obj.m_Index == -2:
             return ret
         try:
-            obj = obj.read()
+            instance = obj.deref_parse_as_dict()
+            values = instance.values()
         except AttributeError:
             return ret
+    elif isinstance(obj, Object):
+        values = obj.__dict__.values()
+    elif isinstance(obj, ObjectReader):
+        values = obj.parse_as_dict().values()
     else:
         return ret
-    ret[obj.path_id] = obj
 
-    # MonoBehaviour really on their typetree
-    # while Object denotes that the class of the object isn't implemented yet
-    if isinstance(obj, (MonoBehaviour, Object)):
-        data = obj.read_typetree().__dict__.values()
-    else:
-        data = obj.__dict__.values()
+    ret[obj.m_PathID] = obj
 
-    for value in flatten(data):
+    for value in flatten(values):
         if isinstance(value, (Object, PPtr)):
-            if value.path_id in ret:
+            if value.m_PathID in ret:
                 continue
             crawl_obj(value, ret)