fix seeking nodeready and more helpers

6 files changed, 75 insertions, 5 deletions

diff --git a/exporter/src/bin/debug.rs b/exporter/src/bin/debug.rs
index 867f6ea..3f87ccf 100644
--- a/exporter/src/bin/debug.rs
+++ b/exporter/src/bin/debug.rs
@@ -9,6 +9,11 @@ fn main() -> anyhow::Result<()> {
     let node = fs.find_main_file().unwrap().to_owned();
     let mut cab = fs.read(&node)?;
     let file = SerializedFile::read(&mut cab)?;
+    let shared_assets = if let Some(n) = file.find_fs_shared_assets(&fs) {
+        Some(SerializedFile::read(fs.read(&n)?)?)
+    } else {
+        None
+    };
 
     for ob in file.objects {
         // eprintln!("{:#?}", ob);
@@ -55,7 +60,20 @@ fn main() -> anyhow::Result<()> {
         //     serde_json::to_string_pretty(&value.to_json()).unwrap()
         // )
     }
-    // eprintln!("{:#?}", file.types);
+    eprintln!("{:#?}", file.externals);
+    if let Some(shared_assets) = shared_assets {
+        eprintln!("{:#?}", shared_assets);
+        for ob in shared_assets.objects {
+            let typetree = if ob.type_id < 0 {
+                unimplemented!()
+            } else {
+                &file.types[ob.type_id as usize]
+            };
 
+            if let Some(tree) = &typetree.type_tree {
+                println!("{}", tree.type_string);
+            }
+        }
+    }
     Ok(())
 }
diff --git a/src/assetbundle.rs b/src/assetbundle.rs
index e10a8f3..db7ad97 100644
--- a/src/assetbundle.rs
+++ b/src/assetbundle.rs
@@ -4,6 +4,7 @@ use crate::{
     unityfs::{NodeReader, UnityFS, block_reader::BlockReader, multi_reader::MultiReader},
 };
 use anyhow::{Context, Result, anyhow};
+use log::debug;
 use std::{
     io::{Read, Seek},
     marker::PhantomData,
@@ -22,8 +23,10 @@ impl<T: Read + Seek> AssetBundle<T> {
         let main_ni = fs
             .find_main_file()
             .ok_or(anyhow!("AssetBundle seems to lack main file"))?;
+        debug!("detected {:?} as main file", main_ni.name);
         let main = SerializedFile::read(fs.read(main_ni)?)?;
         let shared_assets = if let Some(n) = main.find_fs_shared_assets(&fs) {
+            debug!("detect {:?} as shared assets", n.name);
             Some(SerializedFile::read(fs.read(&n)?)?)
         } else {
             None
@@ -35,6 +38,26 @@ impl<T: Read + Seek> AssetBundle<T> {
         })
     }
 
+    pub fn all_toplevel(&self) -> impl Iterator<Item = PPtr> {
+        self.main
+            .objects
+            .iter()
+            .map(|o| (0, o))
+            .chain(
+                self.shared_assets
+                    .as_ref()
+                    .map(|e| e.objects.iter().map(|o| (1, o)))
+                    .into_iter()
+                    .flatten(),
+            )
+            .map(|(fi, o)| PPtr {
+                class: "".to_string(),
+                file_id: fi,
+                path_id: o.path_id,
+                _class: PhantomData,
+            })
+    }
+
     pub fn all_toplevel_of_class(&self, class_name: &str) -> impl Iterator<Item = PPtr> {
         self.main
             .all_objects_of_class(class_name)
diff --git a/src/classes/mesh.rs b/src/classes/mesh.rs
index f828b7c..348c61c 100644
--- a/src/classes/mesh.rs
+++ b/src/classes/mesh.rs
@@ -1,7 +1,7 @@
 use super::streaminginfo::StreamingInfo;
 use crate::object::{Value, parser::FromValue};
 use anyhow::{Result, anyhow, bail};
-use glam::{Mat4, Vec3, Vec3A};
+use glam::{Mat4, Vec2, Vec3, Vec3A, Vec4};
 use log::debug;
 use serde::Serialize;
 use std::mem::transmute;
@@ -216,6 +216,18 @@ impl VectorType for Vec3 {
         a.into_iter().array_chunks().map(Vec3::from_array).collect()
     }
 }
+impl VectorType for Vec2 {
+    const DIM: usize = 2;
+    fn convert_array(a: Vec<f32>) -> Vec<Self> {
+        a.into_iter().array_chunks().map(Vec2::from_array).collect()
+    }
+}
+impl VectorType for Vec4 {
+    const DIM: usize = 4;
+    fn convert_array(a: Vec<f32>) -> Vec<Self> {
+        a.into_iter().array_chunks().map(Vec4::from_array).collect()
+    }
+}
 
 impl FromValue for ChannelInfo {
     fn from_value(v: Value) -> Result<Self> {
diff --git a/src/classes/transform.rs b/src/classes/transform.rs
index 880eb9a..ed04d35 100644
--- a/src/classes/transform.rs
+++ b/src/classes/transform.rs
@@ -16,7 +16,10 @@ pub struct Transform {
 
 impl FromValue for Transform {
     fn from_value(v: Value) -> Result<Self> {
-        let mut fields = v.as_class("Transform").unwrap();
+        let mut fields = v
+            .clone()
+            .as_class("RectTransform")
+            .or(v.as_class("Transform"))?;
         Ok(Self {
             father: fields.field("m_Father")?,
             gameobject: fields.field("m_GameObject")?,
diff --git a/src/serialized_file.rs b/src/serialized_file.rs
index aba72b9..1e11947 100644
--- a/src/serialized_file.rs
+++ b/src/serialized_file.rs
@@ -56,7 +56,6 @@ pub struct External {
     pub path_name: String,
 }
 
-#[derive(Debug)]
 pub struct SerializedFile<T> {
     pub file: T,
     pub header: SerializedFileHeader,
@@ -68,6 +67,20 @@ pub struct SerializedFile<T> {
     pub endianness: Endianness,
 }
 
+impl<T> std::fmt::Debug for SerializedFile<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SerializedFile")
+            .field("header", &self.header)
+            .field("types", &self.types)
+            .field("externals", &self.externals)
+            .field("scripts", &self.scripts)
+            .field("objects", &self.objects)
+            .field("user_string", &self.user_string)
+            .field("endianness", &self.endianness)
+            .finish()
+    }
+}
+
 #[derive(Debug)]
 pub struct SerializedFileHeader {
     _metadata_size: u32,
diff --git a/src/unityfs/mod.rs b/src/unityfs/mod.rs
index 16e4283..c9921c3 100644
--- a/src/unityfs/mod.rs
+++ b/src/unityfs/mod.rs
@@ -49,7 +49,8 @@ impl<T: Read + Seek> UnityFS<T> {
     pub fn read<'a>(&'a self, node: &NodeInfo) -> Result<NodeReader<BlockReader<MultiReader<T>>>> {
         let mut inner = self.reader.clone();
         inner.seek(SeekFrom::Start(self.inner_seek_offset))?;
-        let br = BlockReader::new(self.blocks.clone(), inner, self.inner_seek_offset);
+        let mut br = BlockReader::new(self.blocks.clone(), inner, self.inner_seek_offset);
+        br.seek(SeekFrom::Start(node.offset))?;
         Ok(NodeReader {
             size: node.size,
             offset: node.offset,