more abstraction around unityfs to read multiple files from a single reader

9 files changed, 71 insertions, 19 deletions

diff --git a/exporter/src/bin/debug.rs b/exporter/src/bin/debug.rs
index 92713ba..867f6ea 100644
--- a/exporter/src/bin/debug.rs
+++ b/exporter/src/bin/debug.rs
@@ -4,7 +4,7 @@ use unity_tools::{serialized_file::SerializedFile, unityfs::UnityFS};
 fn main() -> anyhow::Result<()> {
     env_logger::init_from_env("LOG");
     let file = BufReader::new(File::open(args().nth(1).unwrap())?);
-    let mut fs = UnityFS::open(file)?;
+    let fs = UnityFS::open(file)?;
 
     let node = fs.find_main_file().unwrap().to_owned();
     let mut cab = fs.read(&node)?;
diff --git a/exporter/src/bin/gltf.rs b/exporter/src/bin/gltf.rs
index 86f48b4..544bd6f 100644
--- a/exporter/src/bin/gltf.rs
+++ b/exporter/src/bin/gltf.rs
@@ -23,8 +23,8 @@ use unity_tools::{
 
 fn main() -> anyhow::Result<()> {
     env_logger::init_from_env("LOG");
-    let file = || BufReader::new(File::open(args().nth(1).unwrap()).unwrap());
-    let mut fs = UnityFS::open(file())?;
+    let file = BufReader::new(File::open(args().nth(1).unwrap()).unwrap());
+    let fs = UnityFS::open(file)?;
 
     let cabfile = fs
         .find_main_file()
@@ -54,7 +54,7 @@ fn main() -> anyhow::Result<()> {
         let go = file.read_object(ob)?.parse::<GameObject>()?;
         let mut global_transform = Affine3A::default();
         for comp in go.components {
-            let ob = comp.load(&mut file)?;
+            let ob = comp.load(&mut file, None)?;
             match ob.class_name().unwrap().as_str() {
                 "Transform" => {
                     let mut tr = ob.parse::<Transform>()?;
@@ -68,7 +68,7 @@ fn main() -> anyhow::Result<()> {
                         if tr.father.is_null() {
                             break;
                         } else {
-                            tr = tr.father.load(&mut file)?;
+                            tr = tr.father.load(&mut file, None)?;
                         }
                     }
                     global_transform =
@@ -79,7 +79,7 @@ fn main() -> anyhow::Result<()> {
                     let mesh = import_mesh(
                         &mut root,
                         &mut buffer,
-                        smr.mesh_renderer.mesh.load(&mut file)?,
+                        smr.mesh_renderer.mesh.load(&mut file, None)?,
                     )?;
                     nodes.push(root.push(Node {
                         mesh: Some(mesh),
@@ -112,7 +112,7 @@ fn main() -> anyhow::Result<()> {
         bin: Some(Cow::Owned(buffer)),
         json: Cow::Owned(json_string.into_bytes()),
     };
-    let writer = std::fs::File::create("triangle.glb").expect("I/O error");
+    let writer = std::fs::File::create("/tmp/a.glb").expect("I/O error");
     glb.to_writer(writer).expect("glTF binary output error");
 
     Ok(())
diff --git a/exporter/src/bin/json.rs b/exporter/src/bin/json.rs
index dd83de6..e03642b 100644
--- a/exporter/src/bin/json.rs
+++ b/exporter/src/bin/json.rs
@@ -8,7 +8,7 @@ use unity_tools::{serialized_file::SerializedFile, unityfs::UnityFS};
 fn main() -> anyhow::Result<()> {
     env_logger::init_from_env("LOG");
     let file = BufReader::new(File::open(args().nth(1).unwrap())?);
-    let mut fs = UnityFS::open(file)?;
+    let fs = UnityFS::open(file)?;
     let filter = args().nth(2);
     let pretty = var("PRETTY").is_ok();
 
diff --git a/exporter/src/bin/material_stats.rs b/exporter/src/bin/material_stats.rs
new file mode 100644
index 0000000..3eb4dc0
--- /dev/null
+++ b/exporter/src/bin/material_stats.rs
@@ -0,0 +1,52 @@
+use anyhow::anyhow;
+use std::{env::args, fs::File, io::BufReader};
+use unity_tools::{classes::material::Material, serialized_file::SerializedFile, unityfs::UnityFS};
+
+fn main() -> anyhow::Result<()> {
+    env_logger::init_from_env("LOG");
+    let file = BufReader::new(File::open(args().nth(1).unwrap()).unwrap());
+    let fs = UnityFS::open(file)?;
+
+    let mode = args().nth(2).unwrap();
+
+    let cabfile = fs
+        .find_main_file()
+        .ok_or(anyhow!("no CAB file found"))?
+        .to_owned();
+
+    let cab = fs.read(&cabfile)?;
+    let mut file = SerializedFile::read(cab)?;
+    let mut sharedassets = file
+        .find_fs_shared_assets(&fs)
+        .map(|n| {
+            let f = fs.read(&n)?;
+            let f = SerializedFile::read(f)?;
+            Ok::<_, anyhow::Error>(f)
+        })
+        .transpose()?;
+
+    for ob in file.objects.clone() {
+        if file.get_object_type_tree(&ob)?.type_string != "Material" {
+            continue;
+        }
+        let mat = file.read_object(ob)?.parse::<Material>()?;
+
+        match mode.as_str() {
+            "material" => {
+                println!("{}", mat.name)
+            }
+            "shader" => {
+                println!(
+                    "{}",
+                    mat.shader
+                        .load(&mut file, sharedassets.as_mut())?
+                        .parsed
+                        .name
+                )
+            }
+            x => panic!("unknown mode {x:?}"),
+        }
+    }
+
+    Ok(())
+}
diff --git a/exporter/src/bin/meshes.rs b/exporter/src/bin/meshes.rs
index e3758c4..db8f2f8 100644
--- a/exporter/src/bin/meshes.rs
+++ b/exporter/src/bin/meshes.rs
@@ -14,13 +14,14 @@ use unity_tools::{
 
 fn main() -> anyhow::Result<()> {
     env_logger::init_from_env("LOG");
-    let file = || BufReader::new(File::open(args().nth(1).unwrap()).unwrap());
-    let mut fs = UnityFS::open(file())?;
+    let file = BufReader::new(File::open(args().nth(1).unwrap()).unwrap());
+    let fs = UnityFS::open(file)?;
 
     let mut i = 0;
     create_dir_all("/tmp/a").unwrap();
 
     let cabfile = fs
+        .header
         .nodes()
         .iter()
         .find(|n| !n.name.ends_with(".resource") && !n.name.ends_with(".resS"))
diff --git a/exporter/src/bin/probe.rs b/exporter/src/bin/probe.rs
index feca633..043444d 100644
--- a/exporter/src/bin/probe.rs
+++ b/exporter/src/bin/probe.rs
@@ -4,16 +4,16 @@ use unity_tools::{serialized_file::SerializedFileHeader, unityfs::UnityFS};
 
 fn main() -> Result<()> {
     let file = BufReader::new(File::open(args().nth(1).unwrap())?);
-    let mut fs = UnityFS::open(file)?;
+    let fs = UnityFS::open(file)?;
 
     let node = fs.find_main_file().unwrap().to_owned();
     let mut cab = fs.read(&node)?;
     let ch = SerializedFileHeader::read(&mut cab)?;
 
-    if fs.unity_version.is_ascii() && ch.generator_version.is_ascii() && ch.format < 100 {
+    if fs.header.unity_version.is_ascii() && ch.generator_version.is_ascii() && ch.format < 100 {
         println!(
             "{}\t{}\t{}\t{}",
-            fs.file_version, fs.unity_version, ch.format, ch.generator_version
+            fs.header.file_version, fs.header.unity_version, ch.format, ch.generator_version
         );
     }
 
diff --git a/exporter/src/bin/textures.rs b/exporter/src/bin/textures.rs
index 2e077fe..a3b6cec 100644
--- a/exporter/src/bin/textures.rs
+++ b/exporter/src/bin/textures.rs
@@ -12,9 +12,8 @@ use unity_tools::{
 
 fn main() -> anyhow::Result<()> {
     env_logger::init_from_env("LOG");
-    let file = || BufReader::new(File::open(args().nth(1).unwrap()).unwrap());
-    let mut fs = UnityFS::open(file())?;
-    let mut fs2 = UnityFS::open(file())?;
+    let file = BufReader::new(File::open(args().nth(1).unwrap()).unwrap());
+    let mut fs = UnityFS::open(file)?;
 
     let mut i = 0;
     create_dir_all("/tmp/a").unwrap();
@@ -33,7 +32,7 @@ fn main() -> anyhow::Result<()> {
         let value = file.read_object(ob)?;
         let mut texture = Texture2D::from_value(value)?;
         if texture.image_data.is_empty() {
-            texture.image_data = texture.stream_data.read(&mut fs2)?;
+            texture.image_data = texture.stream_data.read(&mut fs)?;
         }
         let path = format!(
             "/tmp/a/{}_{i}.png",
diff --git a/exporter/src/bin/typegraph.rs b/exporter/src/bin/typegraph.rs
index ea55e05..0d6568a 100644
--- a/exporter/src/bin/typegraph.rs
+++ b/exporter/src/bin/typegraph.rs
@@ -13,7 +13,7 @@ use unity_tools::{
 fn main() -> anyhow::Result<()> {
     env_logger::init_from_env("LOG");
     let file = BufReader::new(File::open(args().nth(1).unwrap())?);
-    let mut fs = UnityFS::open(file)?;
+    let fs = UnityFS::open(file)?;
     let filter_prims = args().any(|a| a == "no_primitives");
 
     let mut edges = BTreeSet::new();
diff --git a/exporter/src/bin/yaml.rs b/exporter/src/bin/yaml.rs
index 4ef8933..bc9e57e 100644
--- a/exporter/src/bin/yaml.rs
+++ b/exporter/src/bin/yaml.rs
@@ -9,7 +9,7 @@ use unity_tools::{classes::HValue, serialized_file::SerializedFile, unityfs::Uni
 fn main() -> anyhow::Result<()> {
     env_logger::init_from_env("LOG");
     let file = BufReader::new(File::open(args().nth(1).unwrap())?);
-    let mut fs = UnityFS::open(file)?;
+    let fs = UnityFS::open(file)?;
     let filter = args().nth(2);
 
     let node = fs.find_main_file().unwrap().to_owned();