main file finder helper

7 files changed, 104 insertions, 120 deletions

diff --git a/src/bin/gltf.rs b/src/bin/gltf.rs
index c6ce39d..18d406a 100644
--- a/src/bin/gltf.rs
+++ b/src/bin/gltf.rs
@@ -22,19 +22,11 @@ fn main() -> anyhow::Result<()> {
     create_dir_all("/tmp/a").unwrap();
 
     let cabfile = fs
-        .nodes()
-        .iter()
-        .find(|n| !n.name.ends_with(".resource") && !n.name.ends_with(".resS"))
+        .find_main_file()
         .ok_or(anyhow!("no CAB file found"))?
         .to_owned();
-    // let ressfile = fs2
-    //     .nodes()
-    //     .iter()
-    //     .find(|n| n.name.ends_with(".resS"))
-    //     .cloned();
 
     let mut cab = fs.read(&cabfile)?;
-    // let mut ress = ressfile.map(|p| fs2.read(&p)).transpose()?;
     let file = read_serialized_file(&mut cab)?;
     for ob in file.objects {
         cab.seek(SeekFrom::Start(ob.data_offset))?;
diff --git a/src/bin/json.rs b/src/bin/json.rs
index b969beb..d669148 100644
--- a/src/bin/json.rs
+++ b/src/bin/json.rs
@@ -14,33 +14,29 @@ fn main() -> anyhow::Result<()> {
     let filter = args().nth(2);
     let pretty = var("PRETTY").is_ok();
 
-    for node in fs.nodes().to_vec() {
-        if node.name.ends_with(".resource") || node.name.ends_with(".resS") {
-            continue;
-        }
-        let mut cab = fs.read(&node)?;
-        let file = read_serialized_file(&mut cab)?;
-        for ob in file.objects {
-            cab.seek(SeekFrom::Start(ob.data_offset))?;
-            let typetree = if ob.type_id < 0 {
-                unimplemented!()
-            } else {
-                &file.types[ob.type_id as usize]
-            };
-            if let Some(typetree) = &typetree.type_tree {
-                if let Some(f) = &filter {
-                    if typetree.type_string != *f && ob.path_id.to_string() != *f {
-                        continue;
-                    }
-                }
-                let value = read_value(typetree, file.endianness, &mut cab)?;
-                if pretty {
-                    serde_json::to_writer_pretty(stdout(), &value.to_json()).unwrap();
-                } else {
-                    serde_json::to_writer(stdout(), &value.to_json()).unwrap();
+    let node = fs.find_main_file().unwrap().to_owned();
+    let mut cab = fs.read(&node)?;
+    let file = read_serialized_file(&mut cab)?;
+    for ob in file.objects {
+        cab.seek(SeekFrom::Start(ob.data_offset))?;
+        let typetree = if ob.type_id < 0 {
+            unimplemented!()
+        } else {
+            &file.types[ob.type_id as usize]
+        };
+        if let Some(typetree) = &typetree.type_tree {
+            if let Some(f) = &filter {
+                if typetree.type_string != *f && ob.path_id.to_string() != *f {
+                    continue;
                 }
-                println!()
             }
+            let value = read_value(typetree, file.endianness, &mut cab)?;
+            if pretty {
+                serde_json::to_writer_pretty(stdout(), &value.to_json()).unwrap();
+            } else {
+                serde_json::to_writer(stdout(), &value.to_json()).unwrap();
+            }
+            println!()
         }
     }
 
diff --git a/src/bin/probe.rs b/src/bin/probe.rs
index 85b2a7a..6f46c0a 100644
--- a/src/bin/probe.rs
+++ b/src/bin/probe.rs
@@ -6,19 +6,15 @@ fn main() -> Result<()> {
     let file = BufReader::new(File::open(args().nth(1).unwrap())?);
     let mut fs = UnityFS::open(file)?;
 
-    for node in fs.nodes().to_vec() {
-        if node.name.ends_with(".resource") || node.name.ends_with(".resS") {
-            continue;
-        }
-        let mut cab = fs.read(&node)?;
-        let ch = read_serialized_file_header(&mut cab)?;
+    let node = fs.find_main_file().unwrap().to_owned();
+    let mut cab = fs.read(&node)?;
+    let ch = read_serialized_file_header(&mut cab)?;
 
-        if fs.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
-            );
-        }
+    if fs.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
+        );
     }
 
     Ok(())
diff --git a/src/bin/textures.rs b/src/bin/textures.rs
index 6cd9577..209e23c 100644
--- a/src/bin/textures.rs
+++ b/src/bin/textures.rs
@@ -22,9 +22,7 @@ fn main() -> anyhow::Result<()> {
     create_dir_all("/tmp/a").unwrap();
 
     let cabfile = fs
-        .nodes()
-        .iter()
-        .find(|n| !n.name.ends_with(".resource") && !n.name.ends_with(".resS"))
+        .find_main_file()
         .ok_or(anyhow!("no CAB file found"))?
         .to_owned();
 
diff --git a/src/bin/typegraph.rs b/src/bin/typegraph.rs
index 79c096b..b8e26d2 100644
--- a/src/bin/typegraph.rs
+++ b/src/bin/typegraph.rs
@@ -17,58 +17,54 @@ fn main() -> anyhow::Result<()> {
     let filter_prims = args().any(|a| a == "no_primitives");
 
     let mut edges = BTreeSet::new();
-    for node in fs.nodes().to_vec() {
-        if node.name.ends_with(".resource") || node.name.ends_with(".resS") {
-            continue;
-        }
-        let mut cab = fs.read(&node)?;
-        let file = read_serialized_file(&mut cab)?;
+    let node = fs.find_main_file().unwrap().to_owned();
+    let mut cab = fs.read(&node)?;
+    let file = read_serialized_file(&mut cab)?;
 
-        for ob in file.objects {
-            let typetree = if ob.type_id < 0 {
-                unimplemented!()
-            } else {
-                &file.types[ob.type_id as usize]
-            };
-            fn print_types(
-                edges: &mut BTreeSet<(String, String)>,
-                filter_prims: bool,
-                tt: TypeTreeNode,
-            ) {
-                for c in tt.children {
-                    let mut c = vec![c];
-                    loop {
-                        let mut nc = Vec::new();
-                        let mut f = false;
-                        for mut c in c {
-                            if let Some(inner) = c.type_string.strip_prefix("PPtr<") {
-                                c.type_string = inner.strip_suffix(">").unwrap().to_owned();
-                                f = true;
-                            } else if matches!(c.type_string.as_str(), "Array" | "pair" | "map") {
-                                nc.extend(c.children);
-                                f = true
-                            } else {
-                                nc.push(c);
-                            };
-                        }
-                        c = nc;
-                        if !f {
-                            break;
-                        }
+    for ob in file.objects {
+        let typetree = if ob.type_id < 0 {
+            unimplemented!()
+        } else {
+            &file.types[ob.type_id as usize]
+        };
+        fn print_types(
+            edges: &mut BTreeSet<(String, String)>,
+            filter_prims: bool,
+            tt: TypeTreeNode,
+        ) {
+            for c in tt.children {
+                let mut c = vec![c];
+                loop {
+                    let mut nc = Vec::new();
+                    let mut f = false;
+                    for mut c in c {
+                        if let Some(inner) = c.type_string.strip_prefix("PPtr<") {
+                            c.type_string = inner.strip_suffix(">").unwrap().to_owned();
+                            f = true;
+                        } else if matches!(c.type_string.as_str(), "Array" | "pair" | "map") {
+                            nc.extend(c.children);
+                            f = true
+                        } else {
+                            nc.push(c);
+                        };
+                    }
+                    c = nc;
+                    if !f {
+                        break;
                     }
-                    for c in c {
-                        if filter_prims && is_primitive(&c.type_string) {
-                            continue;
-                        }
-                        edges.insert((tt.type_string.to_owned(), c.type_string.to_owned()));
-                        print_types(edges, filter_prims, c);
+                }
+                for c in c {
+                    if filter_prims && is_primitive(&c.type_string) {
+                        continue;
                     }
+                    edges.insert((tt.type_string.to_owned(), c.type_string.to_owned()));
+                    print_types(edges, filter_prims, c);
                 }
             }
+        }
 
-            if let Some(tree) = &typetree.type_tree {
-                print_types(&mut edges, filter_prims, tree.clone());
-            }
+        if let Some(tree) = &typetree.type_tree {
+            print_types(&mut edges, filter_prims, tree.clone());
         }
     }
     let nodes = edges
diff --git a/src/bin/yaml.rs b/src/bin/yaml.rs
index e3b1df8..2899c4c 100644
--- a/src/bin/yaml.rs
+++ b/src/bin/yaml.rs
@@ -15,34 +15,31 @@ fn main() -> anyhow::Result<()> {
     let mut fs = UnityFS::open(file)?;
     let filter = args().nth(2);
 
-    for node in fs.nodes().to_vec() {
-        if node.name.ends_with(".resource") || node.name.ends_with(".resS") {
-            continue;
-        }
-        let mut cab = fs.read(&node)?;
-        let file = read_serialized_file(&mut cab)?;
-        for ob in file.objects {
-            cab.seek(SeekFrom::Start(ob.data_offset))?;
-            let typetree = if ob.type_id < 0 {
-                unimplemented!()
-            } else {
-                &file.types[ob.type_id as usize]
-            };
-            if let Some(typetree) = &typetree.type_tree {
-                if let Some(f) = &filter {
-                    if typetree.type_string != *f && ob.path_id.to_string() != *f {
-                        continue;
-                    }
+    let node = fs.find_main_file().unwrap().to_owned();
+    let mut cab = fs.read(&node)?;
+
+    let file = read_serialized_file(&mut cab)?;
+    for ob in file.objects {
+        cab.seek(SeekFrom::Start(ob.data_offset))?;
+        let typetree = if ob.type_id < 0 {
+            unimplemented!()
+        } else {
+            &file.types[ob.type_id as usize]
+        };
+        if let Some(typetree) = &typetree.type_tree {
+            if let Some(f) = &filter {
+                if typetree.type_string != *f && ob.path_id.to_string() != *f {
+                    continue;
                 }
-                let value = read_value(typetree, file.endianness, &mut cab)?;
-                let hvalue = HValue::from_value(value)?;
+            }
+            let value = read_value(typetree, file.endianness, &mut cab)?;
+            let hvalue = HValue::from_value(value)?;
 
-                let mut hvalue = serde_yml::to_value(hvalue)?;
-                reduce_large_arrays(&mut hvalue);
+            let mut hvalue = serde_yml::to_value(hvalue)?;
+            reduce_large_arrays(&mut hvalue);
 
-                serde_yml::to_writer(stdout(), &hvalue).unwrap();
-                println!()
-            }
+            serde_yml::to_writer(stdout(), &hvalue).unwrap();
+            println!()
         }
     }
 
diff --git a/src/unityfs.rs b/src/unityfs.rs
index 0f3cab6..a23114d 100644
--- a/src/unityfs.rs
+++ b/src/unityfs.rs
@@ -142,6 +142,15 @@ impl<T: Read + Seek> UnityFS<T> {
     pub fn nodes(&self) -> &[NodeInfo] {
         &self.nodes
     }
+
+    pub fn find_main_file(&self) -> Option<&NodeInfo> {
+        self.nodes().iter().find(|n| {
+            !n.name.ends_with(".resource")
+                && !n.name.ends_with(".resS")
+                && !n.name.ends_with(".sharedAssets")
+        })
+    }
+
     pub fn read<'a>(&'a mut self, node: &NodeInfo) -> std::io::Result<NodeReader<'a, T>> {
         self.reader.seek(SeekFrom::Start(node.offset))?;
         Ok(NodeReader {