From 7ff78cff53eba1da60b8beb851732e2f8197c221 Mon Sep 17 00:00:00 2001 From: metamuffin Date: Fri, 14 Mar 2025 14:58:38 +0100 Subject: move files around --- Cargo.lock | 18 +++++- Cargo.toml | 7 ++- exporter/Cargo.toml | 16 ++++++ exporter/src/bin/debug.rs | 61 +++++++++++++++++++++ exporter/src/bin/gltf.rs | 99 +++++++++++++++++++++++++++++++++ exporter/src/bin/json.rs | 34 ++++++++++++ exporter/src/bin/meshes.rs | 59 ++++++++++++++++++++ exporter/src/bin/probe.rs | 21 +++++++ exporter/src/bin/textures.rs | 55 +++++++++++++++++++ exporter/src/bin/typegraph.rs | 124 ++++++++++++++++++++++++++++++++++++++++++ exporter/src/bin/yaml.rs | 50 +++++++++++++++++ exporter/src/main.rs | 3 + src/bin/gltf.rs | 22 -------- src/bin/json.rs | 34 ------------ src/bin/meshes.rs | 59 -------------------- src/bin/probe.rs | 21 ------- src/bin/textures.rs | 55 ------------------- src/bin/typegraph.rs | 124 ------------------------------------------ src/bin/yaml.rs | 50 ----------------- src/classes/mesh_renderer.rs | 62 +++++++++++++++++++++ src/classes/mod.rs | 1 + 21 files changed, 606 insertions(+), 369 deletions(-) create mode 100644 exporter/Cargo.toml create mode 100644 exporter/src/bin/debug.rs create mode 100644 exporter/src/bin/gltf.rs create mode 100644 exporter/src/bin/json.rs create mode 100644 exporter/src/bin/meshes.rs create mode 100644 exporter/src/bin/probe.rs create mode 100644 exporter/src/bin/textures.rs create mode 100644 exporter/src/bin/typegraph.rs create mode 100644 exporter/src/bin/yaml.rs create mode 100644 exporter/src/main.rs delete mode 100644 src/bin/gltf.rs delete mode 100644 src/bin/json.rs delete mode 100644 src/bin/meshes.rs delete mode 100644 src/bin/probe.rs delete mode 100644 src/bin/textures.rs delete mode 100644 src/bin/typegraph.rs delete mode 100644 src/bin/yaml.rs create mode 100644 src/classes/mesh_renderer.rs diff --git a/Cargo.lock b/Cargo.lock index 13a06e1..6870611 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -305,6 +305,22 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" +[[package]] +name = "exporter" +version = "0.1.0" +dependencies = [ + "anyhow", + "bytemuck", + "env_logger", + "glam", + "gltf", + "gltf-json", + "log", + "serde_json", + "serde_yml", + "unity-tools", +] + [[package]] name = "exr" version = "1.73.0" @@ -1191,7 +1207,6 @@ dependencies = [ "anyhow", "env_logger", "glam", - "gltf", "humansize", "image", "log", @@ -1199,7 +1214,6 @@ dependencies = [ "lzma", "serde", "serde_json", - "serde_yml", "texpresso", "texture2ddecoder", ] diff --git a/Cargo.toml b/Cargo.toml index ecd0a2f..e148c96 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,3 +1,8 @@ +[workspace] +resolver = "3" +members = [".", "exporter"] +default-members = ["exporter"] + [package] name = "unity-tools" version = "0.1.0" @@ -12,9 +17,7 @@ lzma = "0.2.2" serde_json = "1.0.139" humansize = "2.1.3" serde = { version = "1.0.219", features = ["derive"] } -serde_yml = "0.0.12" glam = { version = "0.30.0", features = ["serde"] } texpresso = "2.0.1" image = "0.25.5" texture2ddecoder = { git = "https://github.com/UniversalGameExtraction/texture2ddecoder", rev = "d2b4653fda298f1da39917da86bc509b17879808" } -gltf = "1.4.1" diff --git a/exporter/Cargo.toml b/exporter/Cargo.toml new file mode 100644 index 0000000..1894e52 --- /dev/null +++ b/exporter/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "exporter" +version = "0.1.0" +edition = "2024" + +[dependencies] +unity-tools = { path = ".." } +serde_yml = "0.0.12" +log = "0.4.25" +env_logger = "0.11.6" +serde_json = "1.0.139" +anyhow = "1.0.95" +glam = { version = "0.30.0", features = ["serde"] } +gltf-json = "1.4.1" +gltf = "1.4.1" +bytemuck = "1.22.0" diff --git a/exporter/src/bin/debug.rs b/exporter/src/bin/debug.rs new file mode 100644 index 0000000..92713ba --- /dev/null +++ b/exporter/src/bin/debug.rs @@ -0,0 +1,61 @@ +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"); + let file = BufReader::new(File::open(args().nth(1).unwrap())?); + let mut fs = UnityFS::open(file)?; + + 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 { + // 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/exporter/src/bin/gltf.rs b/exporter/src/bin/gltf.rs new file mode 100644 index 0000000..fb6b72d --- /dev/null +++ b/exporter/src/bin/gltf.rs @@ -0,0 +1,99 @@ +#![feature(array_chunks)] +use anyhow::anyhow; +use glam::{Affine3A, Mat4}; +use gltf::Glb; +use log::warn; +use std::{borrow::Cow, env::args, fs::File, io::BufReader}; +use unity_tools::{ + classes::{ + gameobject::GameObject, + mesh_renderer::{MeshRenderer, SkinnedMeshRenderer}, + transform::Transform, + }, + serialized_file::SerializedFile, + unityfs::UnityFS, +}; + +fn main() -> anyhow::Result<()> { + env_logger::init_from_env("LOG"); + let file = || BufReader::new(File::open(args().nth(1).unwrap()).unwrap()); + let mut fs = UnityFS::open(file())?; + + let cabfile = fs + .find_main_file() + .ok_or(anyhow!("no CAB file found"))? + .to_owned(); + + let mut cab = fs.read(&cabfile)?; + let mut file = SerializedFile::read(&mut cab)?; + let gameobjects = file + .objects + .iter() + .filter(|ob| file.get_object_type_tree(ob).unwrap().type_string == "GameObject") + .cloned() + .collect::>(); + + // let mut root_tr = Transform::from_value(file.read_object(ob)?)?; + // while !root_tr.father.is_null() { + // root_tr = root_tr.father.load(&mut file)?; + // } + // eprintln!("{root_tr:?}"); + + let mut root = gltf_json::Root::default(); + + for ob in gameobjects { + let go = file.read_object(ob)?.parse::()?; + for comp in go.components { + let ob = comp.load(&mut file)?; + let mut global_transform = Affine3A::default(); + match ob.class_name().unwrap().as_str() { + "Transform" => { + let mut tr = ob.parse::()?; + let mut transforms = Vec::new(); + loop { + transforms.push( + Mat4::from_translation(tr.local_position) + * Mat4::from_scale(tr.local_scale) + * Mat4::from_quat(tr.local_rotation), + ); + if tr.father.is_null() { + break; + } else { + tr = tr.father.load(&mut file)?; + } + } + global_transform = + Affine3A::from_mat4(transforms.into_iter().reduce(|a, b| a * b).unwrap()) + } + "SkinnedMeshRenderer" => { + let mr = ob.parse::()?; + } + "MeshRenderer" => { + let mr = ob.parse::()?; + } + x => warn!("unknown component {x:?}"), + } + } + } + + let json_string = gltf_json::serialize::to_string(&root).expect("Serialization error"); + let mut json_offset = json_string.len(); + align_to_multiple_of_four(&mut json_offset); + let glb = Glb { + header: gltf::binary::Header { + magic: *b"glTF", + version: 2, + length: json_offset as u32, + }, + bin: None, + json: Cow::Owned(json_string.into_bytes()), + }; + let writer = std::fs::File::create("triangle.glb").expect("I/O error"); + glb.to_writer(writer).expect("glTF binary output error"); + + Ok(()) +} + +fn align_to_multiple_of_four(n: &mut usize) { + *n = (*n + 3) & !3; +} diff --git a/exporter/src/bin/json.rs b/exporter/src/bin/json.rs new file mode 100644 index 0000000..dd83de6 --- /dev/null +++ b/exporter/src/bin/json.rs @@ -0,0 +1,34 @@ +use std::{ + env::{args, var}, + fs::File, + io::{BufReader, stdout}, +}; +use unity_tools::{serialized_file::SerializedFile, 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)?; + let filter = args().nth(2); + let pretty = var("PRETTY").is_ok(); + + let node = fs.find_main_file().unwrap().to_owned(); + let mut cab = fs.read(&node)?; + 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 = 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/exporter/src/bin/meshes.rs b/exporter/src/bin/meshes.rs new file mode 100644 index 0000000..e3758c4 --- /dev/null +++ b/exporter/src/bin/meshes.rs @@ -0,0 +1,59 @@ +#![feature(array_chunks)] +use anyhow::anyhow; +use std::{ + env::args, + fs::{File, create_dir_all}, + io::{BufReader, BufWriter, Write}, +}; +use unity_tools::{ + classes::mesh::{Mesh, VertexDataChannel}, + object::parser::FromValue, + serialized_file::SerializedFile, + unityfs::UnityFS, +}; + +fn main() -> anyhow::Result<()> { + env_logger::init_from_env("LOG"); + let file = || BufReader::new(File::open(args().nth(1).unwrap()).unwrap()); + let mut fs = UnityFS::open(file())?; + + let mut i = 0; + create_dir_all("/tmp/a").unwrap(); + + let cabfile = fs + .nodes() + .iter() + .find(|n| !n.name.ends_with(".resource") && !n.name.ends_with(".resS")) + .ok_or(anyhow!("no CAB file found"))? + .to_owned(); + + let mut cab = fs.read(&cabfile)?; + 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); + + 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/exporter/src/bin/probe.rs b/exporter/src/bin/probe.rs new file mode 100644 index 0000000..feca633 --- /dev/null +++ b/exporter/src/bin/probe.rs @@ -0,0 +1,21 @@ +use anyhow::Result; +use std::{env::args, fs::File, io::BufReader}; +use unity_tools::{serialized_file::SerializedFileHeader, unityfs::UnityFS}; + +fn main() -> Result<()> { + let file = BufReader::new(File::open(args().nth(1).unwrap())?); + let mut fs = UnityFS::open(file)?; + + let node = fs.find_main_file().unwrap().to_owned(); + let mut cab = fs.read(&node)?; + let ch = SerializedFileHeader::read(&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 + ); + } + + Ok(()) +} diff --git a/exporter/src/bin/textures.rs b/exporter/src/bin/textures.rs new file mode 100644 index 0000000..2e077fe --- /dev/null +++ b/exporter/src/bin/textures.rs @@ -0,0 +1,55 @@ +use anyhow::anyhow; +use log::warn; +use std::{ + env::args, + fs::{File, create_dir_all}, + io::BufReader, +}; +use unity_tools::{ + classes::texture2d::Texture2D, object::parser::FromValue, serialized_file::SerializedFile, + unityfs::UnityFS, +}; + +fn main() -> anyhow::Result<()> { + env_logger::init_from_env("LOG"); + let file = || BufReader::new(File::open(args().nth(1).unwrap()).unwrap()); + 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"))? + .to_owned(); + + let mut cab = fs.read(&cabfile)?; + 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; + } + + Ok(()) +} diff --git a/exporter/src/bin/typegraph.rs b/exporter/src/bin/typegraph.rs new file mode 100644 index 0000000..ea55e05 --- /dev/null +++ b/exporter/src/bin/typegraph.rs @@ -0,0 +1,124 @@ +#![feature(random)] +use std::{ + collections::{BTreeMap, BTreeSet}, + env::args, + fs::File, + io::BufReader, +}; +use unity_tools::{ + serialized_file::{SerializedFile, TypeTreeNode}, + 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)?; + let filter_prims = args().any(|a| a == "no_primitives"); + + 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)?; + + 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 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()); + } + } + let nodes = edges + .iter() + .flat_map(|(k, v)| [k, v]) + .collect::>(); + let ids = nodes + .into_iter() + .enumerate() + .map(|(i, n)| (n, i)) + .collect::>(); + + println!("digraph {{"); + for (name, id) in &ids { + println!("t{id} [label={name:?}]"); + } + for (a, b) in &edges { + println!("t{} -> t{}", ids[a], ids[b]); + } + println!("}}"); + + Ok(()) +} + +fn is_primitive(s: &str) -> bool { + matches!( + s, + "Type*" + | "int" + | "unsigned int" + | "UInt8" + | "UInt16" + | "UInt32" + | "UInt64" + | "SInt8" + | "SInt16" + | "SInt32" + | "SInt64" + | "bool" + | "float" + | "string" + | "float3" + | "float4" + | "float2" + | "Vector2f" + | "Vector3f" + | "Vector4f" + | "Matrix4x4f" + | "ColorRGBA" + | "Rectf" + | "Quaternionf" + | "xform" + ) +} diff --git a/exporter/src/bin/yaml.rs b/exporter/src/bin/yaml.rs new file mode 100644 index 0000000..4ef8933 --- /dev/null +++ b/exporter/src/bin/yaml.rs @@ -0,0 +1,50 @@ +use serde_yml::Value; +use std::{ + env::args, + fs::File, + io::{BufReader, stdout}, +}; +use unity_tools::{classes::HValue, serialized_file::SerializedFile, 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)?; + 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)?; + 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 mut hvalue = serde_yml::to_value(hvalue)?; + trim_large_arrays(&mut hvalue); + + serde_yml::to_writer(stdout(), &hvalue).unwrap(); + println!() + } + + Ok(()) +} + +fn trim_large_arrays(v: &mut Value) { + match v { + Value::Sequence(values) => { + values.iter_mut().for_each(trim_large_arrays); + while values.len() > 32 { + values.pop(); + } + } + Value::Mapping(mapping) => mapping.map.values_mut().for_each(trim_large_arrays), + Value::Tagged(tagged_value) => trim_large_arrays(&mut tagged_value.value), + _ => (), + } +} diff --git a/exporter/src/main.rs b/exporter/src/main.rs new file mode 100644 index 0000000..e7a11a9 --- /dev/null +++ b/exporter/src/main.rs @@ -0,0 +1,3 @@ +fn main() { + println!("Hello, world!"); +} diff --git a/src/bin/gltf.rs b/src/bin/gltf.rs deleted file mode 100644 index 323b6d2..0000000 --- a/src/bin/gltf.rs +++ /dev/null @@ -1,22 +0,0 @@ -#![feature(array_chunks)] -use anyhow::anyhow; -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"); - let file = || BufReader::new(File::open(args().nth(1).unwrap()).unwrap()); - let mut fs = UnityFS::open(file())?; - // let mut fs2 = UnityFS::open(file())?; - - let cabfile = fs - .find_main_file() - .ok_or(anyhow!("no CAB file found"))? - .to_owned(); - - let mut cab = fs.read(&cabfile)?; - let file = SerializedFile::read(&mut cab)?; - for _ob in file.objects {} - - Ok(()) -} diff --git a/src/bin/json.rs b/src/bin/json.rs deleted file mode 100644 index dd83de6..0000000 --- a/src/bin/json.rs +++ /dev/null @@ -1,34 +0,0 @@ -use std::{ - env::{args, var}, - fs::File, - io::{BufReader, stdout}, -}; -use unity_tools::{serialized_file::SerializedFile, 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)?; - let filter = args().nth(2); - let pretty = var("PRETTY").is_ok(); - - let node = fs.find_main_file().unwrap().to_owned(); - let mut cab = fs.read(&node)?; - 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 = 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 deleted file mode 100644 index e3758c4..0000000 --- a/src/bin/meshes.rs +++ /dev/null @@ -1,59 +0,0 @@ -#![feature(array_chunks)] -use anyhow::anyhow; -use std::{ - env::args, - fs::{File, create_dir_all}, - io::{BufReader, BufWriter, Write}, -}; -use unity_tools::{ - classes::mesh::{Mesh, VertexDataChannel}, - object::parser::FromValue, - serialized_file::SerializedFile, - unityfs::UnityFS, -}; - -fn main() -> anyhow::Result<()> { - env_logger::init_from_env("LOG"); - let file = || BufReader::new(File::open(args().nth(1).unwrap()).unwrap()); - let mut fs = UnityFS::open(file())?; - - let mut i = 0; - create_dir_all("/tmp/a").unwrap(); - - let cabfile = fs - .nodes() - .iter() - .find(|n| !n.name.ends_with(".resource") && !n.name.ends_with(".resS")) - .ok_or(anyhow!("no CAB file found"))? - .to_owned(); - - let mut cab = fs.read(&cabfile)?; - 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); - - 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/probe.rs b/src/bin/probe.rs deleted file mode 100644 index feca633..0000000 --- a/src/bin/probe.rs +++ /dev/null @@ -1,21 +0,0 @@ -use anyhow::Result; -use std::{env::args, fs::File, io::BufReader}; -use unity_tools::{serialized_file::SerializedFileHeader, unityfs::UnityFS}; - -fn main() -> Result<()> { - let file = BufReader::new(File::open(args().nth(1).unwrap())?); - let mut fs = UnityFS::open(file)?; - - let node = fs.find_main_file().unwrap().to_owned(); - let mut cab = fs.read(&node)?; - let ch = SerializedFileHeader::read(&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 - ); - } - - Ok(()) -} diff --git a/src/bin/textures.rs b/src/bin/textures.rs deleted file mode 100644 index 2e077fe..0000000 --- a/src/bin/textures.rs +++ /dev/null @@ -1,55 +0,0 @@ -use anyhow::anyhow; -use log::warn; -use std::{ - env::args, - fs::{File, create_dir_all}, - io::BufReader, -}; -use unity_tools::{ - classes::texture2d::Texture2D, object::parser::FromValue, serialized_file::SerializedFile, - unityfs::UnityFS, -}; - -fn main() -> anyhow::Result<()> { - env_logger::init_from_env("LOG"); - let file = || BufReader::new(File::open(args().nth(1).unwrap()).unwrap()); - 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"))? - .to_owned(); - - let mut cab = fs.read(&cabfile)?; - 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; - } - - Ok(()) -} diff --git a/src/bin/typegraph.rs b/src/bin/typegraph.rs deleted file mode 100644 index ea55e05..0000000 --- a/src/bin/typegraph.rs +++ /dev/null @@ -1,124 +0,0 @@ -#![feature(random)] -use std::{ - collections::{BTreeMap, BTreeSet}, - env::args, - fs::File, - io::BufReader, -}; -use unity_tools::{ - serialized_file::{SerializedFile, TypeTreeNode}, - 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)?; - let filter_prims = args().any(|a| a == "no_primitives"); - - 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)?; - - 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 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()); - } - } - let nodes = edges - .iter() - .flat_map(|(k, v)| [k, v]) - .collect::>(); - let ids = nodes - .into_iter() - .enumerate() - .map(|(i, n)| (n, i)) - .collect::>(); - - println!("digraph {{"); - for (name, id) in &ids { - println!("t{id} [label={name:?}]"); - } - for (a, b) in &edges { - println!("t{} -> t{}", ids[a], ids[b]); - } - println!("}}"); - - Ok(()) -} - -fn is_primitive(s: &str) -> bool { - matches!( - s, - "Type*" - | "int" - | "unsigned int" - | "UInt8" - | "UInt16" - | "UInt32" - | "UInt64" - | "SInt8" - | "SInt16" - | "SInt32" - | "SInt64" - | "bool" - | "float" - | "string" - | "float3" - | "float4" - | "float2" - | "Vector2f" - | "Vector3f" - | "Vector4f" - | "Matrix4x4f" - | "ColorRGBA" - | "Rectf" - | "Quaternionf" - | "xform" - ) -} diff --git a/src/bin/yaml.rs b/src/bin/yaml.rs deleted file mode 100644 index 4ef8933..0000000 --- a/src/bin/yaml.rs +++ /dev/null @@ -1,50 +0,0 @@ -use serde_yml::Value; -use std::{ - env::args, - fs::File, - io::{BufReader, stdout}, -}; -use unity_tools::{classes::HValue, serialized_file::SerializedFile, 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)?; - 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)?; - 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 mut hvalue = serde_yml::to_value(hvalue)?; - trim_large_arrays(&mut hvalue); - - serde_yml::to_writer(stdout(), &hvalue).unwrap(); - println!() - } - - Ok(()) -} - -fn trim_large_arrays(v: &mut Value) { - match v { - Value::Sequence(values) => { - values.iter_mut().for_each(trim_large_arrays); - while values.len() > 32 { - values.pop(); - } - } - Value::Mapping(mapping) => mapping.map.values_mut().for_each(trim_large_arrays), - Value::Tagged(tagged_value) => trim_large_arrays(&mut tagged_value.value), - _ => (), - } -} diff --git a/src/classes/mesh_renderer.rs b/src/classes/mesh_renderer.rs new file mode 100644 index 0000000..94d6fd7 --- /dev/null +++ b/src/classes/mesh_renderer.rs @@ -0,0 +1,62 @@ +use super::{gameobject::GameObject, mesh::Mesh, pptr::PPtr, transform::Transform}; +use crate::object::{ + Value, + parser::{Fields, FromValue}, +}; +use anyhow::Result; + +pub struct MeshRenderer { + pub enabled: bool, + pub mesh: PPtr, + pub cast_shadows: u8, + pub game_object: PPtr, + pub materials: Vec, +} + +pub struct SkinnedMeshRenderer { + pub mesh_renderer: MeshRenderer, + pub bones: Vec>, + pub root_bone: PPtr, +} + +impl FromValue for MeshRenderer { + fn from_value(v: Value) -> Result { + Self::from_fields(v.as_class("MeshRenderer")?) + } +} +impl MeshRenderer { + pub fn from_fields(mut fields: Fields) -> Result { + Ok(Self { + enabled: fields.field("m_Enabled")?, + mesh: fields.field("m_Mesh")?, + cast_shadows: fields.field("m_CastShadows")?, + game_object: fields.field("m_GameObject")?, + materials: fields + .remove("m_Materials") + .unwrap() + .as_vector() + .unwrap() + .into_iter() + .map(|e| e.parse().unwrap()) + .collect(), + }) + } +} + +impl FromValue for SkinnedMeshRenderer { + fn from_value(v: Value) -> Result { + let mut fields = v.as_class("SkinnedMeshRenderer")?; + Ok(Self { + root_bone: fields.field("m_RootBone")?, + bones: fields + .remove("m_Bones") + .unwrap() + .as_vector() + .unwrap() + .into_iter() + .map(|e| e.parse().unwrap()) + .collect(), + mesh_renderer: MeshRenderer::from_fields(fields)?, + }) + } +} diff --git a/src/classes/mod.rs b/src/classes/mod.rs index 52ed401..b4fbe91 100644 --- a/src/classes/mod.rs +++ b/src/classes/mod.rs @@ -7,6 +7,7 @@ pub mod streaminginfo; pub mod texture2d; pub mod transform; pub mod vectors; +pub mod mesh_renderer; use crate::object::{Value, parser::FromValue}; use anyhow::Result; -- cgit v1.2.3-70-g09d2