allow preloading files

2 files changed, 73 insertions, 59 deletions

diff --git a/exporter/src/bin/typegraph.rs b/exporter/src/bin/typegraph.rs
index d1e7629..44e395b 100644
--- a/exporter/src/bin/typegraph.rs
+++ b/exporter/src/bin/typegraph.rs
@@ -18,56 +18,63 @@ fn main() -> anyhow::Result<()> {
 
     let mut edges = BTreeSet::new();
     let node = fs.find_main_file().unwrap().to_owned();
-    let mut cab = fs.read(&node)?;
-    let file = SerializedFile::read(&mut cab, node.name)?;
+    let cab = fs.read(&node)?;
+    let file = SerializedFile::read(cab, node.name)?;
+    let mut shared = None;
+    if let Some(ni) = file.find_fs_shared_assets(&fs) {
+        let cab = fs.read(&ni)?;
+        shared = Some(SerializedFile::read(cab, ni.name)?);
+    }
 
-    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" | "vector"
-                        ) {
-                            nc.extend(c.children);
-                            f = true
-                        } else {
-                            nc.push(c);
-                        };
-                    }
-                    c = nc;
-                    if !f {
-                        break;
+    for file in [file].into_iter().chain(shared) {
+        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;
+                                nc.push(c);
+                            } else if matches!(
+                                c.type_string.as_str(),
+                                "Array" | "pair" | "map" | "vector"
+                            ) {
+                                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;
+                    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);
                     }
-                    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/exporter/src/bin/yaml.rs b/exporter/src/bin/yaml.rs
index afa016a..a63164a 100644
--- a/exporter/src/bin/yaml.rs
+++ b/exporter/src/bin/yaml.rs
@@ -13,24 +13,31 @@ fn main() -> anyhow::Result<()> {
     let filter = args().nth(2);
 
     let node = fs.find_main_file().unwrap().to_owned();
-    let mut cab = fs.read(&node)?;
-    let mut file = SerializedFile::read(&mut cab, node.name)?;
-    for ob in file.objects.clone() {
-        if let Some(f) = &filter {
-            if file.get_object_type_tree(&ob)?.type_string != *f && ob.path_id.to_string() != *f {
-                continue;
+    let cab = fs.read(&node)?;
+    let file = SerializedFile::read(cab, node.name)?;
+    let mut shared = None;
+    if let Some(ni) = file.find_fs_shared_assets(&fs) {
+        let cab = fs.read(&ni)?;
+        shared = Some(SerializedFile::read(cab, ni.name)?);
+    }
+    for mut file in [file].into_iter().chain(shared) {
+        for ob in file.objects.clone() {
+            if let Some(f) = &filter {
+                if file.get_object_type_tree(&ob)?.type_string != *f && ob.path_id.to_string() != *f
+                {
+                    continue;
+                }
             }
-        }
-        let value = file.read_object(ob)?;
-        let hvalue = HValue::from_value(value)?;
+            let value = file.read_object(ob)?;
+            let hvalue = HValue::from_value(value)?;
 
-        let mut hvalue = serde_yml::to_value(hvalue)?;
-        trim_large_arrays(&mut hvalue);
+            let mut hvalue = serde_yml::to_value(hvalue)?;
+            trim_large_arrays(&mut hvalue);
 
-        serde_yml::to_writer(stdout(), &hvalue).unwrap();
-        println!()
+            serde_yml::to_writer(stdout(), &hvalue).unwrap();
+            println!()
+        }
     }
-
     Ok(())
 }