Refactor SceneManager / Transform; fix a number of bugs in scene/game object traversal

.gitignore

@@ -1,3 +1,4 @@
 /target
 /Cargo.lock
 .idea
+**/.DS_Store

src/game_engine/unity/il2cpp/class.rs

@@ -13,7 +13,20 @@
 }
 
 impl Class {
-    pub(super) fn get_name<const N: usize>(
+    pub fn get_from_component(
+        process: &Process,
+        module: &Module,
+        component: Address,
+    ) -> Result<Self, Error> {
+        process
+            .read_pointer(component, module.pointer_size)
+            .ok()
+            .filter(|val| !val.is_null())
+            .map(|class| Class { class })
+            .ok_or(Error {})
+    }
+
+    pub fn get_name<const N: usize>(
         &self,
         process: &Process,
         module: &Module,

src/game_engine/unity/mod.rs

@@ -83,6 +83,9 @@
 // https://github.com/Unity-Technologies/mono
 // https://github.com/CryZe/lunistice-auto-splitter/blob/b8c01031991783f7b41044099ee69edd54514dba/asr-dotnet/src/lib.rs
 
+use crate::file_format::{elf, macho, pe};
+use crate::{Error, PointerSize, Process};
+
 pub mod il2cpp;
 pub mod mono;
 pub mod scene_manager;
@@ -91,9 +94,15 @@ const CSTR: usize = 128;
 
 #[derive(Copy, Clone, PartialEq, Hash, Debug)]
 #[non_exhaustive]
+/// The file format of a given executable / binary - different per operating system.
+/// See https://en.wikipedia.org/wiki/Comparison_of_executable_file_formats
 enum BinaryFormat {
+    /// [Portable Executable](https://en.wikipedia.org/wiki/Portable_Executable), for Windows.
     PE,
+    /// [Executable and Linkable Format](https://en.wikipedia.org/wiki/Executable_and_Linkable_Format),
+    /// for Linux.
     ELF,
+    /// [Mach-O](https://en.wikipedia.org/wiki/Mach-O) (Mach object), for Mac.
     MachO,
 }
 
@@ -103,3 +112,22 @@ fn get_backing_name(name: &str) -> Option<&str> {
     let end = name[start + 1..].find('>')?;
     Some(&name[start + 1..start + 1 + end])
 }
+
+impl Process {
+    /// Get the [BinaryFormat](BinaryFormat) and pointer size of the main module of the Process
+    // FIXME: BinaryFormat and this function should probably be widely available (rather
+    //   than gated by Unity)
+    fn get_format_and_pointer_size(&self) -> Result<(BinaryFormat, PointerSize), Error> {
+        let main_module = self.get_main_module_range()?;
+
+        if let Some(x) = pe::MachineType::read(self, main_module.0) {
+            Ok((BinaryFormat::PE, x.pointer_size().ok_or(Error {})?))
+        } else if let Some(pointer_size) = elf::pointer_size(self, main_module.0) {
+            Ok((BinaryFormat::ELF, pointer_size))
+        } else if let Some(pointer_size) = macho::pointer_size(self, main_module) {
+            Ok((BinaryFormat::MachO, pointer_size))
+        } else {
+            Err(Error {})
+        }
+    }
+}

src/game_engine/unity/mono/class.rs

@@ -7,13 +7,15 @@ use crate::{future::retry, string::ArrayCString, Address, Error, Process};
 pub use asr_derive::MonoClass as Class;
 
 /// A .NET class that is part of an [`Image`](Image).
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 pub struct Class {
-    pub(super) class: Address,
+    /// The address of the class
+    pub class: Address,
 }
 
 impl Class {
-    pub(super) fn get_name<const N: usize>(
+    /// Get the name of the class
+    pub fn get_name<const N: usize>(
         &self,
         process: &Process,
         module: &Module,
@@ -215,3 +217,32 @@ impl Class {
         retry(|| self.get_parent(process, module)).await
     }
 }
+
+/** Represents a MonoObject, which is an instantiation of a MonoVTable (and therefore MonoClass). It
+ * is where the actual fields of the class live.
+ *
+ * See https://github.com/mono/mono/blob/0f53e9e151d92944cacab3e24ac359410c606df6/mono/metadata/object.h#L31.
+ */
+#[derive(Debug, Clone)]
+pub struct Object {
+    /// The address of the Mono object.
+    pub address: Address,
+}
+
+impl Object {
+    /** Get the Mono [class](Class) of this object. */
+    pub fn get_class(&self, process: &Process, module: &Module) -> Result<Class, Error> {
+        process
+            // MonoVTable *vtable
+            // See https://github.com/mono/mono/blob/0f53e9e151d92944cacab3e24ac359410c606df6/mono/metadata/object.h#L32
+            .read_pointer(self.address, module.pointer_size)
+            .ok()
+            .filter(|val| !val.is_null())
+            // MonoClass *klass
+            // See https://github.com/mono/mono/blob/0f53e9e151d92944cacab3e24ac359410c606df6/mono/metadata/class-internals.h#L360
+            .and_then(|addr| process.read_pointer(addr, module.pointer_size).ok())
+            .filter(|val| !val.is_null())
+            .map(|class| Class { class })
+            .ok_or(Error {})
+    }
+}

src/game_engine/unity/mono/mod.rs

@@ -16,7 +16,7 @@ use assembly::Assembly;
 mod image;
 pub use image::Image;
 mod class;
-pub use class::Class;
+pub use class::{Class, Object};
 mod field;
 use field::Field;
 mod version;
@@ -193,12 +193,12 @@ impl Module {
     }
 
     /// Retrieve the [Mono version](Version) of the module.
-    pub fn get_version(&self) -> Version {
+    pub const fn get_version(&self) -> Version {
         self.version
     }
 
     /// Retrieve the [pointer size](PointerSize) of the process/module.
-    pub fn get_pointer_size(&self) -> PointerSize {
+    pub const fn get_pointer_size(&self) -> PointerSize {
         self.pointer_size
     }
 

src/game_engine/unity/mono/offsets.rs

@@ -241,118 +241,126 @@ impl MonoOffsets {
                 },
                 v_table: MonoVTableOffsets { vtable: 0x28 },
             }),
-            (BinaryFormat::ELF | BinaryFormat::MachO, Version::V3, PointerSize::Bit64) => Some(&Self {
-                assembly: AssemblyOffsets {
-                    aname: 0x10,
-                    image: 0x60,
-                },
-                image: ImageOffsets { class_cache: 0x4D0 },
-                hash_table: HashTableOffsets {
-                    size: 0x18,
-                    table: 0x20,
-                },
-                class: ClassOffsets {
-                    parent: 0x28,
-                    image: 0x38,
-                    name: 0x40,
-                    namespace: 0x48,
-                    vtable_size: 0x54,
-                    fields: 0x90,
-                    runtime_info: 0xC8,
-                    field_count: 0xF8,
-                    next_class_cache: 0x100,
-                },
-                field: FieldInfoOffsets {
-                    name: 0x8,
-                    offset: 0x18,
-                    alignment: 0x20,
-                },
-                v_table: MonoVTableOffsets { vtable: 0x48 },
-            }),
-            (BinaryFormat::ELF | BinaryFormat::MachO, Version::V2, PointerSize::Bit64) => Some(&Self {
-                assembly: AssemblyOffsets {
-                    aname: 0x10,
-                    image: 0x60,
-                },
-                image: ImageOffsets { class_cache: 0x4C0 },
-                hash_table: HashTableOffsets {
-                    size: 0x18,
-                    table: 0x20,
-                },
-                class: ClassOffsets {
-                    parent: 0x28,
-                    image: 0x38,
-                    name: 0x40,
-                    namespace: 0x48,
-                    vtable_size: 0x54,
-                    fields: 0x90,
-                    runtime_info: 0xC8,
-                    field_count: 0xF8,
-                    next_class_cache: 0x100,
-                },
-                field: FieldInfoOffsets {
-                    name: 0x8,
-                    offset: 0x18,
-                    alignment: 0x20,
-                },
-                v_table: MonoVTableOffsets { vtable: 0x40 },
-            }),
-            (BinaryFormat::ELF | BinaryFormat::MachO, Version::V1Cattrs, PointerSize::Bit64) => Some(&Self {
-                assembly: AssemblyOffsets {
-                    aname: 0x10,
-                    image: 0x58,
-                },
-                image: ImageOffsets { class_cache: 0x3D0 },
-                hash_table: HashTableOffsets {
-                    size: 0x18,
-                    table: 0x20,
-                },
-                class: ClassOffsets {
-                    parent: 0x28,
-                    image: 0x40,
-                    name: 0x48,
-                    namespace: 0x50,
-                    vtable_size: 0x18,
-                    fields: 0xA8,
-                    runtime_info: 0xF8,
-                    field_count: 0x94,
-                    next_class_cache: 0x100,
-                },
-                field: FieldInfoOffsets {
-                    name: 0x8,
-                    offset: 0x18,
-                    alignment: 0x20,
-                },
-                v_table: MonoVTableOffsets { vtable: 0x48 },
-            }),
-            (BinaryFormat::ELF | BinaryFormat::MachO, Version::V1, PointerSize::Bit64) => Some(&Self {
-                assembly: AssemblyOffsets {
-                    aname: 0x10,
-                    image: 0x58,
-                },
-                image: ImageOffsets { class_cache: 0x3D0 },
-                hash_table: HashTableOffsets {
-                    size: 0x18,
-                    table: 0x20,
-                },
-                class: ClassOffsets {
-                    parent: 0x28,
-                    image: 0x38,
-                    name: 0x40,
-                    namespace: 0x48,
-                    vtable_size: 0x18,
-                    fields: 0xA0,
-                    runtime_info: 0xF0,
-                    field_count: 0x8C,
-                    next_class_cache: 0xF8,
-                },
-                field: FieldInfoOffsets {
-                    name: 0x8,
-                    offset: 0x18,
-                    alignment: 0x20,
-                },
-                v_table: MonoVTableOffsets { vtable: 0x48 },
-            }),
+            (BinaryFormat::ELF | BinaryFormat::MachO, Version::V3, PointerSize::Bit64) => {
+                Some(&Self {
+                    assembly: AssemblyOffsets {
+                        aname: 0x10,
+                        image: 0x60,
+                    },
+                    image: ImageOffsets { class_cache: 0x4D0 },
+                    hash_table: HashTableOffsets {
+                        size: 0x18,
+                        table: 0x20,
+                    },
+                    class: ClassOffsets {
+                        parent: 0x28,
+                        image: 0x38,
+                        name: 0x40,
+                        namespace: 0x48,
+                        vtable_size: 0x54,
+                        fields: 0x90,
+                        runtime_info: 0xC8,
+                        field_count: 0xF8,
+                        next_class_cache: 0x100,
+                    },
+                    field: FieldInfoOffsets {
+                        name: 0x8,
+                        offset: 0x18,
+                        alignment: 0x20,
+                    },
+                    v_table: MonoVTableOffsets { vtable: 0x48 },
+                })
+            }
+            (BinaryFormat::ELF | BinaryFormat::MachO, Version::V2, PointerSize::Bit64) => {
+                Some(&Self {
+                    assembly: AssemblyOffsets {
+                        aname: 0x10,
+                        image: 0x60,
+                    },
+                    image: ImageOffsets { class_cache: 0x4C0 },
+                    hash_table: HashTableOffsets {
+                        size: 0x18,
+                        table: 0x20,
+                    },
+                    class: ClassOffsets {
+                        parent: 0x28,
+                        image: 0x38,
+                        name: 0x40,
+                        namespace: 0x48,
+                        vtable_size: 0x54,
+                        fields: 0x90,
+                        runtime_info: 0xC8,
+                        field_count: 0xF8,
+                        next_class_cache: 0x100,
+                    },
+                    field: FieldInfoOffsets {
+                        name: 0x8,
+                        offset: 0x18,
+                        alignment: 0x20,
+                    },
+                    v_table: MonoVTableOffsets { vtable: 0x40 },
+                })
+            }
+            (BinaryFormat::ELF | BinaryFormat::MachO, Version::V1Cattrs, PointerSize::Bit64) => {
+                Some(&Self {
+                    assembly: AssemblyOffsets {
+                        aname: 0x10,
+                        image: 0x58,
+                    },
+                    image: ImageOffsets { class_cache: 0x3D0 },
+                    hash_table: HashTableOffsets {
+                        size: 0x18,
+                        table: 0x20,
+                    },
+                    class: ClassOffsets {
+                        parent: 0x28,
+                        image: 0x40,
+                        name: 0x48,
+                        namespace: 0x50,
+                        vtable_size: 0x18,
+                        fields: 0xA8,
+                        runtime_info: 0xF8,
+                        field_count: 0x94,
+                        next_class_cache: 0x100,
+                    },
+                    field: FieldInfoOffsets {
+                        name: 0x8,
+                        offset: 0x18,
+                        alignment: 0x20,
+                    },
+                    v_table: MonoVTableOffsets { vtable: 0x48 },
+                })
+            }
+            (BinaryFormat::ELF | BinaryFormat::MachO, Version::V1, PointerSize::Bit64) => {
+                Some(&Self {
+                    assembly: AssemblyOffsets {
+                        aname: 0x10,
+                        image: 0x58,
+                    },
+                    image: ImageOffsets { class_cache: 0x3D0 },
+                    hash_table: HashTableOffsets {
+                        size: 0x18,
+                        table: 0x20,
+                    },
+                    class: ClassOffsets {
+                        parent: 0x28,
+                        image: 0x38,
+                        name: 0x40,
+                        namespace: 0x48,
+                        vtable_size: 0x18,
+                        fields: 0xA0,
+                        runtime_info: 0xF0,
+                        field_count: 0x8C,
+                        next_class_cache: 0xF8,
+                    },
+                    field: FieldInfoOffsets {
+                        name: 0x8,
+                        offset: 0x18,
+                        alignment: 0x20,
+                    },
+                    v_table: MonoVTableOffsets { vtable: 0x48 },
+                })
+            }
             _ => None,
         }
     }