start work on serialized files

1 files changed, 88 insertions, 5 deletions

diff --git a/src/main.rs b/src/main.rs
index a23bdcd..c1dcfd2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,9 +1,13 @@
+use log::debug;
 use std::{
     env::args,
     fs::File,
-    io::{BufReader, copy},
+    io::{BufReader, Read},
+};
+use unity_tools::{
+    helper::{Endianness, ReadExt},
+    unityfs::UnityFS,
 };
-use unity_tools::unityfs::UnityFS;
 
 fn main() -> anyhow::Result<()> {
     env_logger::init_from_env("LOG");
@@ -11,9 +15,88 @@ fn main() -> anyhow::Result<()> {
     let mut fs = UnityFS::open(file)?;
 
     for node in fs.nodes().to_vec() {
-        let mut reader = fs.read(&node)?;
-        let mut writer = File::create(format!("/tmp/{}", node.name))?;
-        copy(&mut reader, &mut writer)?;
+        if node.name.ends_with(".resource") || node.name.ends_with("resS") {
+            continue;
+        }
+        let mut cab = fs.read(&node)?;
+        // let mut writer = File::create(format!("/tmp/{}", node.name))?;
+        // copy(&mut cab, &mut writer)?;
+        // continue;
+
+        let mut metadata_size = cab.read_u32_be()?;
+        let mut file_size = cab.read_u32_be()? as u64;
+        let format = cab.read_u32_be()?;
+        let mut data_offset = cab.read_u32_be()? as u64;
+
+        debug!("format={format}");
+
+        assert!(format >= 9);
+        let e = match cab.read_u32_be()? {
+            0 => Endianness::Little,
+            _ => Endianness::Big,
+        };
+        debug!("endianess={e:?}");
+
+        if format >= 22 {
+            metadata_size = cab.read_u32(e)?;
+            file_size = cab.read_u64(e)?;
+            data_offset = cab.read_u64(e)?;
+            cab.read_u64(e)?;
+        }
+        debug!("metadata_size={metadata_size}");
+        debug!("file_size={file_size}");
+        debug!("data_offset={data_offset}");
+
+        let generator_version = cab.read_cstr()?;
+        let target_platform = cab.read_u32_le()?;
+        debug!("generator_version={generator_version:?}");
+        debug!("target_platform={target_platform}");
+
+        let has_type_trees = cab.read_u8()? != 0;
+        let num_types = cab.read_u32(e)?;
+
+        for _ in 0..num_types {
+            let mut class_id = cab.read_i32(e)?;
+            let stripped_type = cab.read_u8()? != 0;
+            let script_id = cab.read_i16(e)?;
+            if class_id == 114 {
+                if script_id >= 0 {
+                    class_id = -2 - script_id as i32;
+                } else {
+                    class_id = -1;
+                }
+            }
+            eprintln!("class_id={class_id}");
+            eprintln!("stripped_type={stripped_type}");
+            eprintln!("script_id={script_id}");
+
+            let hash = if class_id < 0 {
+                (cab.read_u128_be()?, cab.read_u128_be()?)
+            } else {
+                (cab.read_u128_be()?, 0)
+            };
+            eprintln!("{hash:032x?}");
+
+            if has_type_trees {
+                let num_nodes = cab.read_u32(e)?;
+                eprintln!("tree:num_nodes={num_nodes}");
+                let size = cab.read_u32(e)?;
+                assert!(format >= 19);
+                for _ in 0..num_nodes {
+                    cab.read_u32(e)?;
+                }
+                let mut data = vec![0u8; size as usize];
+                cab.read_exact(&mut data)?;
+            }
+
+            if format > 21 {
+                cab.read_u32_be()?;
+            }
+        }
+
+        // let num_objects = cab.read_u32_le()?;
+        // debug!("num_objects={num_objects}");
+        // for _ in 0..num_objects {}
     }
 
     Ok(())