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

@@ -5,15 +5,43 @@ use crate::{future::retry, string::ArrayCString, Address, Error, Process};
 
 #[cfg(feature = "derive")]
 pub use asr_derive::MonoClass as Class;
+use bytemuck::CheckedBitPattern;
+
+/// The kind of MonoClass.
+/// See https://github.com/mono/mono/blob/0f53e9e151d92944cacab3e24ac359410c606df6/mono/metadata/class-internals.h#L267
+#[derive(CheckedBitPattern, Copy, Clone, Debug, Default, PartialEq, Eq)]
+#[repr(u8)]
+#[allow(unused)]
+enum MonoTypeKind {
+    /// Non-generic type
+    Def = 1,
+    /// Generic type definition
+    Gtd = 2,
+    /// Generic instantiation
+    GInst = 3,
+    /// Generic parameter
+    GParam = 4,
+    /// vector or array
+    Array = 5,
+    /// pointer or function pointer
+    Pointer = 6,
+    /// Not a real class kind, internal to Mono
+    GcFiller = 0xAC,
+
+    #[default]
+    Unknown,
+}
 
 /// 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,
@@ -36,6 +64,61 @@ impl Class {
             .and_then(|addr| process.read(addr))
     }
 
+    fn class_kind(&self, process: &Process, module: &Module) -> Result<MonoTypeKind, Error> {
+        match module.version {
+            // See https://github.com/mono/mono/blob/337052f86112fc0dc8435c5c4a2de43b399a14bb/mono/metadata/class-internals.h#L327
+            Version::V2 => {
+                let byte =
+                    process.read::<u8>(self.class + module.offsets.class.class_kind)? & 0x7u8;
+
+                if !MonoTypeKind::is_valid_bit_pattern(&byte) {
+                    return Err(Error {});
+                }
+
+                // SAFETY: We just checked if this was valid
+                let kind: MonoTypeKind = unsafe { (&raw const byte).cast::<MonoTypeKind>().read() };
+
+                Ok(kind)
+            }
+            // See https://github.com/mono/mono/blob/0f53e9e151d92944cacab3e24ac359410c606df6/mono/metadata/class-private-definition.h#L28
+            Version::V3 => {
+                process.read::<MonoTypeKind>(self.class + module.offsets.class.class_kind)
+            }
+            _ => Err(Error {}),
+        }
+    }
+
+    fn field_count(&self, process: &Process, module: &Module) -> Result<i32, Error> {
+        match module.version {
+            Version::V1 | Version::V1Cattrs => {
+                process.read::<i32>(self.class + module.offsets.class.field_count)
+            }
+            Version::V2 | Version::V3 => {
+                let class_kind = self.class_kind(process, module)?;
+
+                // See https://github.com/mono/mono/blob/0f53e9e151d92944cacab3e24ac359410c606df6/mono/metadata/class-accessors.c#L216
+                match class_kind {
+                    MonoTypeKind::Def | MonoTypeKind::Gtd => {
+                        process.read::<i32>(self.class + module.offsets.class.field_count)
+                    }
+                    MonoTypeKind::GInst => {
+                        let generic_class = process.read_pointer(
+                            self.class + module.offsets.class.generic_class,
+                            module.get_pointer_size(),
+                        )?;
+                        let container_class = Class {
+                            class: process
+                                .read_pointer(generic_class + 0x0, module.get_pointer_size())?,
+                        };
+
+                        container_class.field_count(process, module)
+                    }
+                    _ => Ok(0),
+                }
+            }
+        }
+    }
+
     fn fields<'a>(
         &'a self,
         process: &'a Process,
@@ -61,8 +144,8 @@ impl Class {
             // Prepare for next iteration
             this_class = class.get_parent(process, module);
 
-            let field_count = process
-                .read::<i32>(class.class + module.offsets.class.field_count)
+            let field_count = class
+                .field_count(process, module)
                 .ok()
                 .filter(|&val| val > 0)
                 .unwrap_or_default();
@@ -215,3 +298,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;
@@ -146,6 +146,7 @@ impl Module {
                     check_pos: Some(7),
                     check_byte: 0xF9,
                 };
+
                 if let Some(scan_address) = SIG_MONO_X86_64_MACHO
                     .scan_process_range(process, (root_domain_function_address, 0x100))
                     .map(|a| a + 3)
@@ -193,12 +194,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
     }