Added CafeCharStoreData

Cargo.lock

···
 checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
 
 [[package]]
+name = "arbitrary-int"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "825297538d77367557b912770ca3083f778a196054b3ee63b22673c4a3cae0a5"
+
+[[package]]
 name = "arg_enum_proc_macro"
 version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
+[[package]]
+name = "bilge"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc707ed8ebf81de5cd6c7f48f54b4c8621760926cdf35a57000747c512e67b57"
+dependencies = [
+ "arbitrary-int",
+ "bilge-impl",
+]
+
+[[package]]
+name = "bilge-impl"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "feb11e002038ad243af39c2068c8a72bcf147acf05025dcdb916fcc000adb2d8"
+dependencies = [
+ "itertools 0.11.0",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
 name = "binrw"
···
 
 [[package]]
 name = "itertools"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
 version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
···
 ]
 
 [[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
 name = "proc-macro2"
 version = "1.0.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "built",
  "cfg-if",
  "interpolate_name",
- "itertools",
+ "itertools 0.12.1",
  "libc",
  "libfuzzer-sys",
  "log",
···
 name = "vee_parse"
 version = "0.1.1"
 dependencies = [
+ "bilge",
  "binrw",
+ "vee_parse_macros",
+]
+
+[[package]]
+name = "vee_parse_macros"
+version = "0.1.1"
+dependencies = [
+ "quote",
+ "syn",
 ]
 
 [[package]]

Cargo.toml

···
     # bevy viewer is on the backburner
     # "crates/bevy_viewer",
     "crates/lightweight_viewer", "crates/vee_models",
-    "crates/vee_parse", "crates/vee_resources",
+    "crates/vee_parse", "crates/vee_parse_macros", "crates/vee_resources",
     "crates/vee_wgpu",
     "crates/vfl",
     "crates/vfl-cli",

crates/vee_parse/Cargo.toml

···
 description = "Parsing Mii save structures. Part of `vfl`."
 
 [dependencies]
+bilge = "0.2.0"
 binrw = "0.15.0"
+vee_parse_macros = { path = "../vee_parse_macros" }
 
 [lints]
 workspace = true

crates/vee_parse/src/cafe.rs

···
+use crate::FixedLengthWideString;
+use std::{fmt::Display, fs::read, io::Cursor};
+
+use bilge::prelude::*;
+use binrw::{BinRead, BinWrite, NullWideString, binrw};
+use vee_parse_macros::bitfield;
+
+#[bitfield(32)]
+pub struct CharDataField {
+    pub char_version: u8,
+    pub copyable: u1,
+    pub ng_word: u1,
+    pub region_move: u2,
+    pub font_region: u2,
+    pub reserved_0: u2,
+    pub room_index: u4,
+    pub position_in_room: u4,
+    pub author_type: u4,
+    pub birth_platform: u3,
+    pub reserved_1: u1,
+}
+
+#[bitfield(16)]
+pub struct PersonalInfoField {
+    pub gender: u1,
+    pub birth_month: u4,
+    pub birth_day: u5,
+    pub favorite_color: u4,
+    pub favorite: u1,
+    pub padding: u1,
+}
+
+#[bitfield(16)]
+pub struct FaceField {
+    pub local_only: u1,
+    pub face_type: u4,
+    pub face_color: u3,
+    pub face_texture: u4,
+    pub face_makeup: u4,
+}
+
+#[bitfield(16)]
+pub struct HairField {
+    pub hair_type: u8,
+    pub hair_color: u3,
+    pub hair_flip: u1,
+    pub padding: u4,
+}
+
+#[bitfield(16)]
+pub struct EyeField {
+    pub eye_type: u6,
+    pub eye_color: u3,
+    pub eye_scale: u4,
+    pub eye_aspect: u3,
+}
+
+#[bitfield(16)]
+pub struct EyePositionField {
+    pub eye_rotate: u5,
+    pub eye_x: u4,
+    pub eye_y: u5,
+    pub padding: u2,
+}
+
+#[bitfield(16)]
+pub struct EyebrowField {
+    pub eyebrow_type: u5,
+    pub eyebrow_color: u3,
+    pub eyebrow_scale: u4,
+    pub eyebrow_aspect: u3,
+    pub padding_3: u1,
+}
+
+#[bitfield(16)]
+pub struct EyebrowPositionField {
+    pub eyebrow_rotate: u5,
+    pub eyebrow_x: u4,
+    pub eyebrow_y: u5,
+    pub padding: u2,
+}
+
+#[bitfield(16)]
+pub struct NoseField {
+    pub nose_type: u5,
+    pub nose_scale: u4,
+    pub nose_y: u5,
+    pub padding: u2,
+}
+
+#[bitfield(16)]
+pub struct MouthField {
+    pub mouth_type: u6,
+    pub mouth_color: u3,
+    pub mouth_scale: u4,
+    pub mouth_aspect: u3,
+}
+
+#[bitfield(16)]
+pub struct MouthPositionField {
+    pub mouth_y: u5,
+    pub mustache_type: u3,
+    pub padding: u8,
+}
+
+#[bitfield(16)]
+pub struct BeardField {
+    pub beard_type: u3,
+    pub beard_color: u3,
+    pub beard_scale: u4,
+    pub beard_y: u5,
+    pub padding_7: u1,
+}
+
+#[bitfield(16)]
+pub struct GlassField {
+    pub glass_type: u4,
+    pub glass_color: u3,
+    pub glass_scale: u4,
+    pub glass_y: u5,
+}
+
+#[bitfield(16)]
+pub struct MoleField {
+    pub mole_type: u1,
+    pub mole_scale: u4,
+    pub mole_x: u5,
+    pub mole_y: u5,
+    pub padding_8: u1,
+}
+
+#[binrw]
+#[derive(Debug)]
+pub struct CafeAuthorId {
+    pub data: [u8; 8],
+}
+
+#[binrw]
+#[derive(Debug)]
+pub struct CafeCreateId {
+    pub data: [u8; 10],
+}
+
+/// A packed character info format.
+/// This structure has a lot of bitfields.
+/// These fields have been given speculative names.
+///
+/// This format is commonly known as `.ffsd`.
+#[binrw]
+#[brw(little)]
+#[derive(Debug)]
+pub struct CafeCharStoreData {
+    pub char_data: CharDataField,
+    pub author_id: CafeAuthorId,
+    pub create_id: CafeCreateId,
+    pub reserved: [u8; 2],
+    pub personal_info: PersonalInfoField,
+    pub name: FixedLengthWideString<10>,
+    pub height: u8,
+    pub build: u8,
+    pub face: FaceField,
+    pub hair: HairField,
+    pub eye: EyeField,
+    pub eye_position: EyePositionField,
+    pub eyebrow: EyebrowField,
+    pub eyebrow_position: EyebrowPositionField,
+    pub nose: NoseField,
+    pub mouth: MouthField,
+    pub mouth_position: MouthPositionField,
+    pub beard: BeardField,
+    pub glass: GlassField,
+    pub mole: MoleField,
+    pub creator_name: FixedLengthWideString<10>,
+    pub padding: u16,
+    pub crc: u16,
+}

crates/vee_parse/src/lib.rs

···
 //! In the future, multiple formats will be supported and a trait will allow
 //! for being generic over formats.
 
-pub use binrw::{binrw, BinRead, NullWideString};
+pub mod cafe;
+pub mod nx;
 
-/// Wrapper for nn::mii color index.
-#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Default)]
+pub use cafe::CafeCharStoreData;
+pub use nx::NxCharInfo;
+
+pub use binrw::{BinRead, NullWideString, binrw};
+
+/// A UTF-16 String with a fixed length and non-enforced null termination.
+/// The string is allowed to reach the maximum length without a null terminator,
+/// and any nulls are stripped.
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
 #[binrw]
 #[repr(transparent)]
-pub struct NxColor(pub u8);
+pub struct FixedLengthWideString<const CHARS: usize>(pub [u16; CHARS]);
 
-/// Simple UuidV4. No logic provided as create info is not useful for anything... yet.
-#[derive(Debug, Copy, Clone)]
-#[binrw]
-#[brw(little)]
-pub struct UuidVer4 {
-    idc: [u8; 16],
+impl<const N: usize> std::fmt::Debug for FixedLengthWideString<N> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "FixedLengthWideString(\"{}\")", self)
+    }
 }
 
-/// Bindings to the `.charinfo` format.
-/// This format is not used in transmission,
-/// so is not packed like other formats (e.g. Cafe, Revolution)
-#[derive(Debug, Clone)]
-#[binrw]
-#[brw(little, assert(nickname.len() <= 22))]
-pub struct NxCharInfo {
-    create_info: UuidVer4,
-    #[brw(pad_size_to = 0x16)]
-    pub nickname: NullWideString,
-    pub font_region: u8,
-    pub favorite_color: NxColor,
-    pub gender: u8,
-    pub height: u8,
-    pub build: u8,
-    pub is_special: u8,
-    pub region_move: u8,
-    pub faceline_type: u8,
-    pub faceline_color: NxColor,
-    pub faceline_wrinkle: u8,
-    pub faceline_make: u8,
-    pub hair_type: u8,
-    pub hair_color: NxColor,
-    pub hair_flip: u8,
-    pub eye_type: u8,
-    pub eye_color: NxColor,
-    pub eye_scale: u8,
-    pub eye_aspect: u8,
-    pub eye_rotate: u8,
-    pub eye_x: u8,
-    pub eye_y: u8,
-    pub eyebrow_type: u8,
-    pub eyebrow_color: NxColor,
-    pub eyebrow_scale: u8,
-    pub eyebrow_aspect: u8,
-    pub eyebrow_rotate: u8,
-    pub eyebrow_x: u8,
-    pub eyebrow_y: u8,
-    pub nose_type: u8,
-    pub nose_scale: u8,
-    pub nose_y: u8,
-    pub mouth_type: u8,
-    pub mouth_color: NxColor,
-    pub mouth_scale: u8,
-    pub mouth_aspect: u8,
-    pub mouth_y: u8,
-    pub beard_color: NxColor,
-    pub beard_type: u8,
-    pub mustache_type: u8,
-    pub mustache_scale: u8,
-    pub mustache_y: u8,
-    pub glass_type: u8,
-    pub glass_color: NxColor,
-    pub glass_scale: u8,
-    pub glass_y: u8,
-    pub mole_type: u8,
-    pub mole_scale: u8,
-    pub mole_x: u8,
-    pub mole_y: u8,
-    reserved: u8, /* always zero */
+impl<const N: usize> std::fmt::Display for FixedLengthWideString<N> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.parse_utf16())
+    }
+}
+
+impl<const N: usize> FixedLengthWideString<N> {
+    /// Will fail on big endian hardware. Wait for `str_from_utf16_endian` to drop.
+    fn parse_utf16(self) -> String {
+        String::from_utf16(&self.0[..])
+            .expect(
+                "UTF-16 string parse error. Parsing little endian string on big endian hardware?",
+            )
+            .replace("\0", "")
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::NxCharInfo;
+    use crate::{CafeCharStoreData, NxCharInfo};
     use binrw::BinRead;
     use std::{error::Error, fs::File};
 
     type R = Result<(), Box<dyn Error>>;
 
     #[test]
-    fn mii_deser() -> R {
-        let mut mii = File::open(concat!(
-            std::env::var("CARGO_WORKSPACE_DIR").unwrap(),
-            "/resources_here/j0.charinfo"
+    fn nx_deser() -> R {
+        let mut mii = File::open(format!(
+            "{}/resources_here/j0.charinfo",
+            std::env::var("CARGO_WORKSPACE_DIR").unwrap()
         ))?;
 
         let mii = NxCharInfo::read(&mut mii)?;
 
+        assert_eq!(mii.nickname.to_string(), "Jo Null".to_string());
+
         assert_eq!(mii.glass_color.0, 17);
         assert_eq!(mii.reserved, 0);
+
+        Ok(())
+    }
+
+    #[test]
+    fn cafe_deser() -> R {
+        let mut mii = File::open(format!(
+            "{}/resources_here/j0.ffsd",
+            std::env::var("CARGO_WORKSPACE_DIR").unwrap()
+        ))?;
+
+        let mii = CafeCharStoreData::read(&mut mii)?;
+
+        assert_eq!(mii.name.to_string(), "Jo Null".to_string());
+        assert_eq!(mii.personal_info.favorite_color().value(), 8);
 
         Ok(())
     }

crates/vee_parse/src/nx.rs

···
+use binrw::NullWideString;
+use binrw::binrw;
+
+use crate::FixedLengthWideString;
+
+/// Wrapper for nn::mii color index.
+#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Default)]
+#[binrw]
+#[repr(transparent)]
+pub struct NxColor(pub u8);
+
+/// Simple UuidV4. No logic provided as create info is not useful for anything... yet.
+#[derive(Debug, Copy, Clone)]
+#[binrw]
+#[brw(little)]
+pub struct UuidVer4 {
+    idc: [u8; 16],
+}
+
+/// Bindings to the `.charinfo` format.
+/// This format is not used in transmission,
+/// so is not packed like other formats (e.g. Cafe, Revolution.)
+#[derive(Debug, Clone)]
+#[binrw]
+#[brw(little)]
+pub struct NxCharInfo {
+    pub create_info: UuidVer4,
+    pub nickname: FixedLengthWideString<11>,
+    pub font_region: u8,
+    pub favorite_color: NxColor,
+    pub gender: u8,
+    pub height: u8,
+    pub build: u8,
+    pub is_special: u8,
+    pub region_move: u8,
+    pub faceline_type: u8,
+    pub faceline_color: NxColor,
+    pub faceline_wrinkle: u8,
+    pub faceline_make: u8,
+    pub hair_type: u8,
+    pub hair_color: NxColor,
+    pub hair_flip: u8,
+    pub eye_type: u8,
+    pub eye_color: NxColor,
+    pub eye_scale: u8,
+    pub eye_aspect: u8,
+    pub eye_rotate: u8,
+    pub eye_x: u8,
+    pub eye_y: u8,
+    pub eyebrow_type: u8,
+    pub eyebrow_color: NxColor,
+    pub eyebrow_scale: u8,
+    pub eyebrow_aspect: u8,
+    pub eyebrow_rotate: u8,
+    pub eyebrow_x: u8,
+    pub eyebrow_y: u8,
+    pub nose_type: u8,
+    pub nose_scale: u8,
+    pub nose_y: u8,
+    pub mouth_type: u8,
+    pub mouth_color: NxColor,
+    pub mouth_scale: u8,
+    pub mouth_aspect: u8,
+    pub mouth_y: u8,
+    pub beard_color: NxColor,
+    pub beard_type: u8,
+    pub mustache_type: u8,
+    pub mustache_scale: u8,
+    pub mustache_y: u8,
+    pub glass_type: u8,
+    pub glass_color: NxColor,
+    pub glass_scale: u8,
+    pub glass_y: u8,
+    pub mole_type: u8,
+    pub mole_scale: u8,
+    pub mole_x: u8,
+    pub mole_y: u8,
+    pub reserved: u8, /* always zero */
+}

crates/vee_parse_macros/Cargo.toml

···
+[lib]
+proc-macro = true
+
+[package]
+name = "vee_parse_macros"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+exclude.workspace = true
+license.workspace = true
+repository.workspace = true
+readme.workspace = true
+
+[dependencies]
+quote = "1"
+syn = "2"
+
+[lints]
+workspace = true

crates/vee_parse_macros/src/lib.rs

···
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{ItemStruct, LitInt, parse_macro_input};
+
+/// For internal use. Annotates a bitfield so I don't have to do a bunch of boilerplate.
+/// Defaults to 32 if you don't pass it an integer n ∈ `[8, 16, 32, 64]`
+#[proc_macro_attribute]
+pub fn bitfield(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let bit_size = parse_macro_input!(attr as LitInt)
+        .base10_parse::<u32>()
+        .unwrap_or(32);
+
+    let bit_type = match bit_size {
+        8 => quote! { u8 },
+        16 => quote! { u16 },
+        32 => quote! { u32 },
+        64 => quote! { u64 },
+        _ => quote! { u32 },
+    };
+
+    // Parse the struct
+    let input = parse_macro_input!(item as ItemStruct);
+
+    // Extract fields and generate layout doc string
+    let mut layout_lines = Vec::new();
+    layout_lines.push("struct BitField {".to_string());
+    for field in input.fields.iter() {
+        let ident = &field.ident;
+        let ident = quote! {#ident}.to_string();
+
+        let ty = &field.ty;
+        let ty = quote! {#ty}.to_string();
+
+        layout_lines.push(format!("    {ident}: {ty}"));
+    }
+    layout_lines.push("}".to_string());
+
+    let layout_doc = layout_lines.join("\n");
+
+    let struct_name = &input.ident;
+    let vis = &input.vis;
+    let attrs = &input.attrs;
+    let fields = &input.fields;
+
+    let expanded = quote! {
+        #(#attrs)*
+        #[doc = "A bit field."]
+        #[doc = "```rs"]
+        #[doc = #layout_doc]
+        #[doc = "```"]
+        #[bitsize(#bit_size)]
+        #[derive(FromBits, DebugBits, BinRead, BinWrite, PartialEq, Clone, Copy)]
+        #[br(map = #bit_type::into)]
+        #[bw(map = |&x| #bit_type::from(x))]
+        #vis struct #struct_name #fields
+    };
+
+    TokenStream::from(expanded)
+}

testbed/ffl_res_high.hexpat

···
+struct ResourcePartsInfo {
+    u32 dataPos;
+    u32 dataSize;
+    u32 compressedSize;
+    u8 compressLevel;
+    u8 windowBits;
+    u8 memoryLevel;
+    u8 strategy;
+};
+
+struct ResourceShapeHeader {
+    u32 maxSize[12];
+    ResourcePartsInfo beard[4];
+    ResourcePartsInfo hatNormal[132];
+    ResourcePartsInfo hatCap[132];
+    ResourcePartsInfo faceline[12];
+    ResourcePartsInfo glass[1];
+    ResourcePartsInfo mask[12];
+    ResourcePartsInfo noseline[18];
+    ResourcePartsInfo nose[18];
+    ResourcePartsInfo hairNormal[132];
+    ResourcePartsInfo hairCap[132];
+    ResourcePartsInfo foreheadNormal[132];
+    ResourcePartsInfo foreheadCap[132];
+};
+
+struct ResourceTextureHeader {
+    u32 maxSize[11];
+    ResourcePartsInfo beard[3];
+    ResourcePartsInfo hat[132];
+    ResourcePartsInfo eye[62];     // [80] in AFL
+    ResourcePartsInfo eyebrow[24]; // [28] in AFL
+    ResourcePartsInfo faceline[12];
+    ResourcePartsInfo faceMakeup[12];
+    ResourcePartsInfo glass[9]; // [20] in AFL
+    ResourcePartsInfo mole[2];
+    ResourcePartsInfo mouth[37]; // [52] in AFL
+    ResourcePartsInfo mustache[6];
+    ResourcePartsInfo noseline[18];
+};
+
+struct ResourceHeader { 
+    u32 signature; // "FFRA"
+    u32 version;
+    u32 uncompressedBufferSize;
+    u32 expandedBufferSize;
+    u32 expanded;
+    ResourceTextureHeader textureHeader;
+    ResourceShapeHeader shapeHeader;
+    u32 unknown[12]; // Always 0x0?
+};
+
+
+ResourceHeader resourceheader_at_0x00 @ 0x00;
+
+// struct Vec3 {
+//     float x;
+//     float y;
+//     float z;
+// };
+
+// struct BoundingBox {
+//     Vec3 min;
+//     Vec3 max;
+// };
+
+// struct ResourceShapeDataHeader {
+//     u32 elementPos[6];
+//     u32 elementSize[6];
+//     BoundingBox boundingBox;
+//     float transform[144]; // resshapehairtransform.size / 4
+// };