read object abstraction

5 files changed, 82 insertions, 169 deletions

diff --git a/src/bin/gltf.rs b/src/bin/gltf.rs
index 07adec6..323b6d2 100644
--- a/src/bin/gltf.rs
+++ b/src/bin/gltf.rs
@@ -1,16 +1,7 @@
 #![feature(array_chunks)]
 use anyhow::anyhow;
-use std::{
-    env::args,
-    fs::{File, create_dir_all},
-    io::{BufReader, BufWriter, Seek, SeekFrom, Write},
-};
-use unity_tools::{
-    classes::mesh::{Mesh, VertexDataChannel},
-    object::{parser::FromValue, read::read_value},
-    serialized_file::SerializedFile,
-    unityfs::UnityFS,
-};
+use std::{env::args, fs::File, io::BufReader};
+use unity_tools::{serialized_file::SerializedFile, unityfs::UnityFS};
 
 fn main() -> anyhow::Result<()> {
     env_logger::init_from_env("LOG");
@@ -18,9 +9,6 @@ fn main() -> anyhow::Result<()> {
     let mut fs = UnityFS::open(file())?;
     // let mut fs2 = UnityFS::open(file())?;
 
-    let mut i = 0;
-    create_dir_all("/tmp/a").unwrap();
-
     let cabfile = fs
         .find_main_file()
         .ok_or(anyhow!("no CAB file found"))?
@@ -28,46 +16,7 @@ fn main() -> anyhow::Result<()> {
 
     let mut cab = fs.read(&cabfile)?;
     let file = SerializedFile::read(&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 typetree.type_string != "Mesh" {
-                continue;
-            }
-            let value = read_value(typetree, file.endianness, &mut cab)?;
-            let mesh = Mesh::from_value(value).unwrap();
-            // if mesh.stream_data.len() == 0 {
-            //     let ress = ress.as_mut().unwrap();
-            //     ress.seek(SeekFrom::Start(mesh.stream_data.offset))?;
-            //     ress.by_ref()
-            //         .take(mesh.stream_data.size as u64)
-            //         .read_to_end(&mut mesh.)?;
-            // }
-            let mut obj = BufWriter::new(File::create(format!(
-                "/tmp/a/{}_{i}.obj",
-                mesh.name.replace("/", "-").replace(".", "-")
-            ))?);
-
-            let (pos_dims, positions) = mesh
-                .vertex_data
-                .read_channel(VertexDataChannel::Position)
-                .unwrap();
-            assert_eq!(pos_dims, 3);
-
-            for [x, y, z] in positions.array_chunks() {
-                writeln!(obj, "v {x} {y} {z}")?;
-            }
-            for [a, b, c] in mesh.read_indecies() {
-                writeln!(obj, "f {} {} {}", a + 1, b + 1, c + 1)?;
-            }
-            i += 1;
-        }
-    }
+    for _ob in file.objects {}
 
     Ok(())
 }
diff --git a/src/bin/json.rs b/src/bin/json.rs
index 2d09306..dd83de6 100644
--- a/src/bin/json.rs
+++ b/src/bin/json.rs
@@ -1,9 +1,9 @@
 use std::{
     env::{args, var},
     fs::File,
-    io::{BufReader, Seek, SeekFrom, stdout},
+    io::{BufReader, stdout},
 };
-use unity_tools::{object::read::read_value, serialized_file::SerializedFile, unityfs::UnityFS};
+use unity_tools::{serialized_file::SerializedFile, unityfs::UnityFS};
 
 fn main() -> anyhow::Result<()> {
     env_logger::init_from_env("LOG");
@@ -14,28 +14,20 @@ 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)?;
-    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 mut file = SerializedFile::read(&mut cab)?;
+    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;
             }
-            println!()
         }
+        let value = file.read_object(ob)?;
+        if pretty {
+            serde_json::to_writer_pretty(stdout(), &value.to_json()).unwrap();
+        } else {
+            serde_json::to_writer(stdout(), &value.to_json()).unwrap();
+        }
+        println!()
     }
 
     Ok(())
diff --git a/src/bin/meshes.rs b/src/bin/meshes.rs
index f2b4edf..d59b496 100644
--- a/src/bin/meshes.rs
+++ b/src/bin/meshes.rs
@@ -3,11 +3,11 @@ use anyhow::anyhow;
 use std::{
     env::args,
     fs::{File, create_dir_all},
-    io::{BufReader, BufWriter, Seek, SeekFrom, Write},
+    io::{BufReader, BufWriter, Write},
 };
 use unity_tools::{
     classes::mesh::{Mesh, VertexDataChannel},
-    object::{parser::FromValue, read::read_value},
+    object::parser::FromValue,
     serialized_file::SerializedFile,
     unityfs::UnityFS,
 };
@@ -29,39 +29,31 @@ fn main() -> anyhow::Result<()> {
         .to_owned();
 
     let mut cab = fs.read(&cabfile)?;
-    let file = SerializedFile::read(&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 typetree.type_string != "Mesh" {
-                continue;
-            }
-            let value = read_value(typetree, file.endianness, &mut cab)?;
-            let mesh = Mesh::from_value(value).unwrap();
-            let mut obj = BufWriter::new(File::create(format!(
-                "/tmp/a/{}_{i}.obj",
-                mesh.name.replace("/", "-").replace(".", "-")
-            ))?);
+    let mut file = SerializedFile::read(&mut cab)?;
+    for ob in file.objects.clone() {
+        if file.get_object_type_tree(&ob)?.type_string != "Mesh" {
+            continue;
+        }
+        let value = file.read_object(ob)?;
+        let mesh = Mesh::from_value(value).unwrap();
+        let mut obj = BufWriter::new(File::create(format!(
+            "/tmp/a/{}_{i}.obj",
+            mesh.name.replace("/", "-").replace(".", "-")
+        ))?);
 
-            let (pos_dims, positions) = mesh
-                .vertex_data
-                .read_channel(VertexDataChannel::Position)
-                .unwrap();
-            assert_eq!(pos_dims, 3);
+        let (pos_dims, positions) = mesh
+            .vertex_data
+            .read_channel(VertexDataChannel::Position)
+            .unwrap();
+        assert_eq!(pos_dims, 3);
 
-            for [x, y, z] in positions.array_chunks() {
-                writeln!(obj, "v {x} {y} {z}")?;
-            }
-            for [a, b, c] in mesh.read_indecies() {
-                writeln!(obj, "f {} {} {}", a + 1, b + 1, c + 1)?;
-            }
-            i += 1;
+        for [x, y, z] in positions.array_chunks() {
+            writeln!(obj, "v {x} {y} {z}")?;
+        }
+        for [a, b, c] in mesh.read_indecies() {
+            writeln!(obj, "f {} {} {}", a + 1, b + 1, c + 1)?;
         }
+        i += 1;
     }
 
     Ok(())
diff --git a/src/bin/textures.rs b/src/bin/textures.rs
index 6ceabac..2e077fe 100644
--- a/src/bin/textures.rs
+++ b/src/bin/textures.rs
@@ -3,12 +3,10 @@ use log::warn;
 use std::{
     env::args,
     fs::{File, create_dir_all},
-    io::{BufReader, Seek, SeekFrom},
+    io::BufReader,
 };
 use unity_tools::{
-    classes::texture2d::Texture2D,
-    object::{parser::FromValue, read::read_value},
-    serialized_file::SerializedFile,
+    classes::texture2d::Texture2D, object::parser::FromValue, serialized_file::SerializedFile,
     unityfs::UnityFS,
 };
 
@@ -27,38 +25,30 @@ fn main() -> anyhow::Result<()> {
         .to_owned();
 
     let mut cab = fs.read(&cabfile)?;
-    let file = SerializedFile::read(&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 typetree.type_string != "Texture2D" {
-                continue;
-            }
-            let value = read_value(typetree, file.endianness, &mut cab)?;
-            let mut texture = Texture2D::from_value(value)?;
-            if texture.image_data.is_empty() {
-                texture.image_data = texture.stream_data.read(&mut fs2)?;
-            }
-            let path = format!(
-                "/tmp/a/{}_{i}.png",
-                texture.name.replace("/", "-").replace(".", "-")
-            );
-            match texture.to_image() {
-                Ok(im) => {
-                    if !im.as_rgba32f().is_some() {
-                        im.save(&path).unwrap();
-                        println!("{path}");
-                    }
+    let mut file = SerializedFile::read(&mut cab)?;
+    for ob in file.objects.clone() {
+        if file.get_object_type_tree(&ob)?.type_string != "Texture2D" {
+            continue;
+        }
+        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)?;
+        }
+        let path = format!(
+            "/tmp/a/{}_{i}.png",
+            texture.name.replace("/", "-").replace(".", "-")
+        );
+        match texture.to_image() {
+            Ok(im) => {
+                if !im.as_rgba32f().is_some() {
+                    im.save(&path).unwrap();
+                    println!("{path}");
                 }
-                Err(e) => warn!("{e}"),
             }
-            i += 1;
+            Err(e) => warn!("{e}"),
         }
+        i += 1;
     }
 
     Ok(())
diff --git a/src/bin/yaml.rs b/src/bin/yaml.rs
index fd3eec6..4ef8933 100644
--- a/src/bin/yaml.rs
+++ b/src/bin/yaml.rs
@@ -2,11 +2,9 @@ use serde_yml::Value;
 use std::{
     env::args,
     fs::File,
-    io::{BufReader, Seek, SeekFrom, stdout},
-};
-use unity_tools::{
-    classes::HValue, object::read::read_value, serialized_file::SerializedFile, unityfs::UnityFS,
+    io::{BufReader, stdout},
 };
+use unity_tools::{classes::HValue, serialized_file::SerializedFile, unityfs::UnityFS};
 
 fn main() -> anyhow::Result<()> {
     env_logger::init_from_env("LOG");
@@ -17,44 +15,36 @@ 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)?;
-    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 mut file = SerializedFile::read(&mut cab)?;
+    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 = read_value(typetree, file.endianness, &mut cab)?;
-            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)?;
-            reduce_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(())
 }
 
-fn reduce_large_arrays(v: &mut Value) {
+fn trim_large_arrays(v: &mut Value) {
     match v {
         Value::Sequence(values) => {
-            values.iter_mut().for_each(reduce_large_arrays);
+            values.iter_mut().for_each(trim_large_arrays);
             while values.len() > 32 {
                 values.pop();
             }
         }
-        Value::Mapping(mapping) => mapping.map.values_mut().for_each(reduce_large_arrays),
-        Value::Tagged(tagged_value) => reduce_large_arrays(&mut tagged_value.value),
+        Value::Mapping(mapping) => mapping.map.values_mut().for_each(trim_large_arrays),
+        Value::Tagged(tagged_value) => trim_large_arrays(&mut tagged_value.value),
         _ => (),
     }
 }