From 42a5916cf742779d016eeefd1c59efbdfab64feb Mon Sep 17 00:00:00 2001 From: metamuffin Date: Mon, 10 Mar 2025 19:53:48 +0100 Subject: successfully read all objects of a file --- src/bin/debug.rs | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/bin/json.rs | 35 ++++++++++++++++++++++++ src/bin/parse.rs | 81 -------------------------------------------------------- src/helper.rs | 4 +++ src/object.rs | 42 +++++++++++++++++++++-------- 5 files changed, 147 insertions(+), 92 deletions(-) create mode 100644 src/bin/debug.rs create mode 100644 src/bin/json.rs delete mode 100644 src/bin/parse.rs (limited to 'src') diff --git a/src/bin/debug.rs b/src/bin/debug.rs new file mode 100644 index 0000000..5da7c03 --- /dev/null +++ b/src/bin/debug.rs @@ -0,0 +1,77 @@ +use log::debug; +use std::{ + env::args, + fs::File, + io::{BufReader, Seek, SeekFrom}, +}; +use unity_tools::{object::read_value, serialized_file::read_serialized_file, 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)?; + + 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 mut writer = File::create(format!("/tmp/{}", node.name))?; + // std::io::copy(&mut cab, &mut writer)?; + // continue; + + let file = read_serialized_file(&mut cab)?; + let e = file.endianness; + + for ob in file.objects { + cab.seek(SeekFrom::Start(ob.data_offset))?; + + // eprintln!("{:#?}", ob); + let typetree = if ob.type_id < 0 { + unimplemented!() + } else { + // file.types + // .iter() + // .find(|t| t.class_id == ob.type_id) + // .expect("unknown type") + &file.types[ob.type_id as usize] + }; + // fn print_types(tt: &TypeTreeNode) { + // println!("{}", tt.type_string); + // for c in &tt.children { + // print_types(&c); + // } + // } + // fn print_crit_types(tt: &TypeTreeNode) { + // let mut crit = tt.byte_size == -1 || tt.children.is_empty(); + // for c in &tt.children { + // print_crit_types(&c); + // crit &= c.byte_size != -1 + // } + // if crit { + // println!("{}", tt.type_string); + // } + // } + // if let Some(tree) = &typetree.type_tree { + // println!("{}", tree.type_string); + // print_crit_types(tree); + // print_types(tree); + // } + // eprintln!("{typetree:#?}"); + + let value = read_value(typetree.type_tree.as_ref().unwrap(), e, &mut cab)?; + + // if let Value::Object { class, .. } = &value { + // println!("{class}") + // } + + debug!( + "{}", + serde_json::to_string_pretty(&value.to_json()).unwrap() + ) + } + // eprintln!("{:#?}", file.types); + } + + Ok(()) +} diff --git a/src/bin/json.rs b/src/bin/json.rs new file mode 100644 index 0000000..a9685ed --- /dev/null +++ b/src/bin/json.rs @@ -0,0 +1,35 @@ +use std::{ + env::args, + fs::File, + io::{BufReader, Seek, SeekFrom, stdout}, +}; +use unity_tools::{object::read_value, serialized_file::read_serialized_file, 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)?; + + 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 e = file.endianness; + + 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] + }; + let value = read_value(typetree.type_tree.as_ref().unwrap(), e, &mut cab)?; + serde_json::to_writer(stdout(), &value.to_json()).unwrap(); + println!() + } + } + + Ok(()) +} diff --git a/src/bin/parse.rs b/src/bin/parse.rs deleted file mode 100644 index 273cffd..0000000 --- a/src/bin/parse.rs +++ /dev/null @@ -1,81 +0,0 @@ -use log::debug; -use std::{ - env::args, - fs::File, - io::{BufReader, Read, Seek, SeekFrom}, -}; -use unity_tools::{ - object::{Value, read_value}, - serialized_file::{TypeTreeNode, read_serialized_file}, - 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)?; - - 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 mut writer = File::create(format!("/tmp/{}", node.name))?; - // std::io::copy(&mut cab, &mut writer)?; - // continue; - - let file = read_serialized_file(&mut cab)?; - let e = file.endianness; - - for ob in file.objects { - cab.seek(SeekFrom::Start(ob.data_offset))?; - - // eprintln!("{:#?}", ob); - let typetree = if ob.type_id < 0 { - unimplemented!() - } else { - // file.types - // .iter() - // .find(|t| t.class_id == ob.type_id) - // .expect("unknown type") - &file.types[ob.type_id as usize] - }; - // fn print_types(tt: &TypeTreeNode) { - // println!("{}", tt.type_string); - // for c in &tt.children { - // print_types(&c); - // } - // } - // fn print_crit_types(tt: &TypeTreeNode) { - // let mut crit = tt.byte_size == -1; - // for c in &tt.children { - // print_crit_types(&c); - // crit &= c.byte_size != -1 - // } - // if crit { - // println!("{}", tt.type_string); - // } - // } - if let Some(tree) = &typetree.type_tree { - println!("{}", tree.type_string); - // print_crit_types(tree); - // print_types(tree); - } - // eprintln!("{typetree:#?}"); - - let value = read_value(typetree.type_tree.as_ref().unwrap(), e, &mut cab)?; - - // if let Value::Object { class, .. } = &value { - // println!("{class}") - // } - - debug!( - "{}", - serde_json::to_string_pretty(&value.to_json()).unwrap() - ) - } - // eprintln!("{:#?}", file.types); - } - - Ok(()) -} diff --git a/src/helper.rs b/src/helper.rs index 48f3d2d..0681b62 100644 --- a/src/helper.rs +++ b/src/helper.rs @@ -9,6 +9,7 @@ pub enum Endianness { pub trait ReadExt { fn read_u8(&mut self) -> Result; + fn read_i8(&mut self) -> Result; fn read_u16(&mut self, e: Endianness) -> Result; fn read_u16_le(&mut self) -> Result; fn read_u16_be(&mut self) -> Result; @@ -43,6 +44,9 @@ impl ReadExt for T { self.read_exact(&mut buf)?; Ok(buf[0]) } + fn read_i8(&mut self) -> Result { + Ok(self.read_u8()? as i8) + } fn read_u16(&mut self, e: Endianness) -> Result { match e { Endianness::Big => self.read_u16_be(), diff --git a/src/object.rs b/src/object.rs index bdaf3ec..be76c18 100644 --- a/src/object.rs +++ b/src/object.rs @@ -9,11 +9,13 @@ use std::{collections::BTreeMap, io::Read}; pub enum Value { Bool(bool), U8(u8), + I8(i8), U16(u16), I16(i16), U32(u32), I32(i32), F32(f32), + U64(u64), I64(i64), F64(f64), Array(Vec), @@ -21,6 +23,7 @@ pub enum Value { class: String, fields: BTreeMap, }, + Typeless(Vec), String(String), } @@ -32,12 +35,20 @@ pub fn read_value( let mut align = false; let pos_before = data.stream_position()?; let r = match ty.type_string.as_str() { - "char" => Ok(Value::U8(data.read_u8()?)), + "char" => { + assert_eq!(ty.byte_size, 1); + Ok(Value::U8(data.read_u8()?)) + } + "Type*" => Ok(Value::U32(data.read_u32(e)?)), "int" => Ok(Value::I32(data.read_i32(e)?)), "unsigned int" => Ok(Value::U32(data.read_u32(e)?)), "UInt8" => Ok(Value::U8(data.read_u8()?)), "UInt16" => Ok(Value::U16(data.read_u16(e)?)), + "UInt32" => Ok(Value::U32(data.read_u32(e)?)), + "UInt64" => Ok(Value::U64(data.read_u64(e)?)), + "SInt8" => Ok(Value::I8(data.read_i8()?)), "SInt16" => Ok(Value::I16(data.read_i16(e)?)), + "SInt32" => Ok(Value::I32(data.read_i32(e)?)), "SInt64" => Ok(Value::I64(data.read_i64(e)?)), "bool" => Ok(Value::Bool(data.read_u8()? != 0)), "float" => { @@ -54,33 +65,34 @@ pub fn read_value( }; let bytes = arr .into_iter() - .map(|e| { - if let Value::U8(x) = e { - x - } else { - unreachable!() - } + .map(|e| match e { + Value::U8(x) => x, + _ => unreachable!(), }) .collect::>(); Ok(Value::String(String::from_utf8(bytes)?)) } "Array" => { align |= ty.children[0].post_align(); + assert_eq!(ty.byte_size, -1); let Value::I32(size) = read_value(&ty.children[0], e, data)? else { unreachable!() }; trace!("array of size {size}"); - if size > 10000 { - eprintln!("{ty:#?}"); - } let mut elems = Vec::new(); for _ in 0..size { elems.push(read_value(&ty.children[1], e, data)?); } Ok(Value::Array(elems)) } + "TypelessData" => { + let len = data.read_u32(e)?; + let mut buf = vec![0u8; len as usize]; + data.read_exact(&mut buf)?; + Ok(Value::Typeless(buf)) + } _ => { - if ty.children.is_empty() && ty.byte_size != -1 { + if ty.children.is_empty() && ty.byte_size != 0 { todo!("need type {:?}", ty.type_string); } let mut fields = BTreeMap::new(); @@ -113,9 +125,11 @@ impl Value { match self { Value::Bool(x) => serde_json::Value::Bool(x), Value::U8(x) => serde_json::Value::Number(x.into()), + Value::I8(x) => serde_json::Value::Number(x.into()), Value::U16(x) => serde_json::Value::Number(x.into()), Value::I16(x) => serde_json::Value::Number(x.into()), Value::U32(x) => serde_json::Value::Number(x.into()), + Value::U64(x) => serde_json::Value::Number(x.into()), Value::I32(x) => serde_json::Value::Number(x.into()), Value::F32(x) => serde_json::Value::Number( serde_json::Number::from_f64(x as f64).unwrap_or(0.into()), @@ -123,6 +137,12 @@ impl Value { Value::I64(x) => serde_json::Value::Number(x.into()), Value::F64(x) => serde_json::Value::Number(serde_json::Number::from_f64(x).unwrap()), Value::String(x) => serde_json::Value::String(x), + Value::Typeless(values) => serde_json::Value::Array( + values + .into_iter() + .map(|e| serde_json::Value::Number(e.into())) + .collect(), + ), Value::Array(values) => { serde_json::Value::Array(values.into_iter().map(Value::to_json).collect()) } -- cgit v1.2.3-70-g09d2