diff --git a/crates/abr/src/descriptor.rs b/crates/abr/src/descriptor.rs index d03cc44..71161ed 100644 --- a/crates/abr/src/descriptor.rs +++ b/crates/abr/src/descriptor.rs @@ -809,6 +809,73 @@ fn parse_txtr(cursor: &mut Cursor<&[u8]>) -> io::Result { Ok(Txtr { name, id }) } +const LAYER_KEY_TO_BLNM_ID: [([u8; 4], &str); 27] = [ + (*b"norm", "Nrml"), + (*b"diss", "Dslv"), + (*b"dark", "Drkn"), + (*b"mul ", "Mltp"), + (*b"idiv", "CBrn"), + (*b"lbrn", "linearBurn"), + (*b"dkCl", "darkerColor"), + (*b"lite", "Lghn"), + (*b"scrn", "Scrn"), + (*b"div ", "CDdg"), + (*b"lddg", "linearDodge"), + (*b"lgCl", "lighterColor"), + (*b"over", "Ovrl"), + (*b"sLit", "SftL"), + (*b"hLit", "HrdL"), + (*b"vLit", "vividLight"), + (*b"lLit", "linearLight"), + (*b"pLit", "pinLight"), + (*b"hMix", "hardMix"), + (*b"diff", "Dfrn"), + (*b"smud", "Xclu"), + (*b"fsub", "blendSubtraction"), + (*b"fdiv", "blendDivide"), + (*b"hue ", "H "), + (*b"sat ", "Strt"), + (*b"colr", "Clr "), + (*b"lum ", "Lmns"), +]; + +struct MdSl { + blend_mode: Option, + opacity_pct: Option, +} + +fn parse_mdsl(cursor: &mut Cursor<&[u8]>) -> io::Result { + let _class_name = read_unicode_string(cursor)?; + let _class_id = read_id(cursor)?; + let item_count = cursor.read_u32::()?; + + let mut mdsl = MdSl { + blend_mode: None, + opacity_pct: None, + }; + for _ in 0..item_count { + let key = read_id(cursor)?; + let type_tag = read_type_tag(cursor)?; + match (key.as_str(), type_tag.as_str()) { + ("Ky ", "long") => { + let layer_key = cursor.read_i32::()?.to_be_bytes(); + mdsl.blend_mode = Some( + LAYER_KEY_TO_BLNM_ID + .iter() + .find(|(k, _)| *k == layer_key) + .map_or_else( + || String::from_utf8_lossy(&layer_key).into_owned(), + |(_, id)| id.to_string(), + ), + ); + } + ("Opct", "long") => mdsl.opacity_pct = Some(cursor.read_i32::()?), + _ => skip_descriptor_value(cursor, &type_tag, 0)?, + } + } + Ok(mdsl) +} + fn parse_tool_options(cursor: &mut Cursor<&[u8]>) -> io::Result { let _class_name = read_unicode_string(cursor)?; let mut options = crate::ToolOptions { @@ -816,6 +883,7 @@ fn parse_tool_options(cursor: &mut Cursor<&[u8]>) -> io::Result()?; + let mut mdsl = None; for _ in 0..item_count { let key = read_id(cursor)?; @@ -834,6 +902,10 @@ fn parse_tool_options(cursor: &mut Cursor<&[u8]>) -> io::Result options.wetness_pct = Some(cursor.read_f64::()?), ("dryness", "doub") => options.dryness_pct = Some(cursor.read_f64::()?), ("mix", "doub") => options.mix_pct = Some(cursor.read_f64::()?), + ("MdSl", "Objc") => match parse_mdsl(cursor) { + Ok(parsed) => mdsl = Some(parsed), + Err(_) => break, + }, _ => { if skip_descriptor_value(cursor, &type_tag, 0).is_err() { break; @@ -841,6 +913,10 @@ fn parse_tool_options(cursor: &mut Cursor<&[u8]>) -> io::Result Vec { + let mut buf = Vec::new(); + + buf.write_u32::(16).unwrap(); + buf.write_u32::(1).unwrap(); + buf.write_u16::(0).unwrap(); + buf.write_u32::(0).unwrap(); + buf.extend_from_slice(b"null"); + buf.write_u32::(1).unwrap(); + + buf.write_u32::(0).unwrap(); + buf.extend_from_slice(b"Brsh"); + buf.extend_from_slice(b"VlLs"); + buf.write_u32::(1).unwrap(); + + buf.extend_from_slice(b"Objc"); + buf.write_u32::(1).unwrap(); + buf.write_u16::(0).unwrap(); + buf.write_u32::(11).unwrap(); + buf.extend_from_slice(b"brushPreset"); + buf.write_u32::(2).unwrap(); + + write_text(&mut buf, b"Nm ", "Oval Multiply"); + + write_key(&mut buf, b"toolOptions"); + buf.extend_from_slice(b"Objc"); + buf.write_u32::(1).unwrap(); + buf.write_u16::(0).unwrap(); + write_key(&mut buf, b"PbTl"); + let count = items + .iter() + .map(|i| match i { + ToolItem::TopLevelModeAndOpacity => 2, + _ => 1, + }) + .sum::(); + buf.write_u32::(count).unwrap(); + for item in items { + match item { + ToolItem::Flow => write_long(&mut buf, b"flow", 50), + ToolItem::MdSl(layer_key) => { + write_key(&mut buf, b"MdSl"); + buf.extend_from_slice(b"Objc"); + buf.write_u32::(1).unwrap(); + buf.write_u16::(0).unwrap(); + write_key(&mut buf, b"MdSC"); + buf.write_u32::(4).unwrap(); + write_long(&mut buf, b"Sgnt", i32::from_be_bytes(*b"8BIM")); + write_long(&mut buf, b"Ky ", i32::from_be_bytes(**layer_key)); + write_long(&mut buf, b"Opct", 35); + write_bool(&mut buf, b"Clpp", false); + } + ToolItem::MalformedMdSl => { + write_key(&mut buf, b"MdSl"); + buf.extend_from_slice(b"Objc"); + buf.write_u32::(1).unwrap(); + buf.write_u16::(0).unwrap(); + write_key(&mut buf, b"MdSC"); + buf.write_u32::(2).unwrap(); + write_long(&mut buf, b"Ky ", i32::from_be_bytes(*b"mul ")); + write_key(&mut buf, b"Clpp"); + buf.extend_from_slice(b"zzzz"); + } + ToolItem::TopLevelModeAndOpacity => { + write_enum(&mut buf, b"Md ", b"BlnM", b"Scrn"); + write_long(&mut buf, b"Opct", 80); + } + } + } + + buf + } + fn mixer_tool_options() -> crate::ToolOptions { crate::ToolOptions { tool: "MixB".to_string(), @@ -1904,6 +2061,45 @@ mod tests { ); } + fn mdsl_tool_options(items: &[ToolItem]) -> crate::ToolOptions { + let infos = extract_all_brush_info(&build_mdsl_desc_block(items)); + assert_eq!(infos.len(), 1); + infos[0].descriptor.tool_options.clone().unwrap() + } + + #[test] + fn mdsl_supplies_blend_mode_and_opacity() { + let options = mdsl_tool_options(&[ToolItem::Flow, ToolItem::MdSl(b"mul ")]); + assert_eq!(options.blend_mode.as_deref(), Some("Mltp")); + assert_eq!(options.opacity_pct, Some(35)); + assert_eq!(options.flow_pct, Some(50)); + } + + #[test] + fn top_level_md_and_opct_win_over_mdsl_in_either_order() { + let mdsl = ToolItem::MdSl(b"mul "); + let top = ToolItem::TopLevelModeAndOpacity; + for items in [[mdsl, top], [top, mdsl]] { + let options = mdsl_tool_options(&items); + assert_eq!(options.blend_mode.as_deref(), Some("Scrn")); + assert_eq!(options.opacity_pct, Some(80)); + } + } + + #[test] + fn unknown_mdsl_layer_key_reads_raw() { + let options = mdsl_tool_options(&[ToolItem::MdSl(b"zzz ")]); + assert_eq!(options.blend_mode.as_deref(), Some("zzz ")); + assert_eq!(options.opacity_pct, Some(35)); + } + + #[test] + fn malformed_mdsl_keeps_the_preset_and_earlier_tool_options() { + let options = mdsl_tool_options(&[ToolItem::Flow, ToolItem::MalformedMdSl]); + assert_eq!(options.flow_pct, Some(50)); + assert_eq!(options.blend_mode, None); + } + #[test] fn opacity_jitter_is_parsed() { let data = build_dynamics_desc_block("Paint", false, false, true, 0, 0); diff --git a/crates/abr/src/lib.rs b/crates/abr/src/lib.rs index 3e82400..37c6953 100644 --- a/crates/abr/src/lib.rs +++ b/crates/abr/src/lib.rs @@ -486,12 +486,15 @@ pub struct ToolOptions { /// The object's class id, which names the tool the preset was saved for /// (e.g. "PbTl", "MixB"). pub tool: String, - /// `toolOptions/Opct` (`long`) — opacity percent. + /// `toolOptions/Opct` (`long`) — opacity percent. Without it, + /// `toolOptions/MdSl/Opct` (`long`). pub opacity_pct: Option, /// `toolOptions/flow` (`long`) — flow percent. pub flow_pct: Option, /// `toolOptions/Md ` (`enum` `BlnM`, key = "Md" + two spaces) — the raw - /// blend-mode value id (e.g. "Nrml"). + /// blend-mode value id (e.g. "Nrml"). Without it, the `BlnM` value id of + /// the layer blend key in `toolOptions/MdSl/Ky ` (`long`, e.g. `mul ` → + /// "Mltp"), or the raw four-byte key when it has no known `BlnM` id. pub blend_mode: Option, /// `toolOptions/smoothing` (`bool`). pub smoothing: Option, diff --git a/crates/abr/tests/corpus_smoke.rs b/crates/abr/tests/corpus_smoke.rs index 3d3279c..b70adf8 100644 --- a/crates/abr/tests/corpus_smoke.rs +++ b/crates/abr/tests/corpus_smoke.rs @@ -463,3 +463,87 @@ fn corpus_sets_a_non_default_tilt_scale_on_size_on_pen_tilt() { "no corpus preset with Size on Pen Tilt reads a tilt_scale_pct other than 200 %" ); } + +fn tool_options_items( + items: &[brushkit_abr::dump::DumpItem], +) -> Option<&[brushkit_abr::dump::DumpItem]> { + items.iter().find_map(|item| match &item.value { + brushkit_abr::dump::DumpValue::Objc { items, .. } if item.key == "toolOptions" => { + Some(items.as_slice()) + } + _ => None, + }) +} + +fn mdsl_only_layer_key_and_opacity( + items: &[brushkit_abr::dump::DumpItem], +) -> Option<(String, i32)> { + let options = tool_options_items(items)?; + if options.iter().any(|i| i.key == "Md " || i.key == "Opct") { + return None; + } + let mdsl = options.iter().find_map(|item| match &item.value { + brushkit_abr::dump::DumpValue::Objc { items, .. } if item.key == "MdSl" => Some(items), + _ => None, + })?; + let long = |key: &str| { + mdsl.iter().find_map(|i| match i.value { + brushkit_abr::dump::DumpValue::Long(v) if i.key == key => Some(v), + _ => None, + }) + }; + let layer_key = String::from_utf8_lossy(&long("Ky ")?.to_be_bytes()).into_owned(); + Some((layer_key, long("Opct")?)) +} + +#[test] +fn every_corpus_mdsl_preset_reads_its_blend_mode_and_opacity() { + let Some((root, files)) = corpus() else { + println!("skip: BRUSHKIT_CORPUS_DIR unset"); + return; + }; + let mut checked = 0; + for path in &files { + let bytes = std::fs::read(path).expect("corpus file is readable"); + let name = path.strip_prefix(&root).unwrap_or(path).display(); + let pack = brushkit_abr::parse_abr(&bytes).unwrap_or_else(|e| panic!("{name}: {e}")); + let presets = pack + .raw_desc_block + .as_deref() + .map(|desc| brushkit_abr::dump::dump_descriptors(desc).presets) + .unwrap_or_default(); + let descriptors = pack + .brushes + .iter() + .map(|b| (&b.descriptor, b.preset_index)) + .chain( + pack.computed_presets + .iter() + .map(|p| (&p.descriptor, p.preset_index)), + ); + for (d, preset_index) in descriptors { + let Some((layer_key, opacity)) = preset_index + .and_then(|pi| presets.get(pi)) + .and_then(|p| mdsl_only_layer_key_and_opacity(&p.items)) + else { + continue; + }; + let options = d.tool_options.as_ref().expect("toolOptions is parsed"); + assert_eq!(options.opacity_pct, Some(opacity), "{name}"); + let blend_mode = options.blend_mode.as_deref(); + assert!( + blend_mode.is_some_and(|m| m != layer_key), + "{name}: layer key {layer_key:?} read as {blend_mode:?}, not a BlnM id" + ); + if layer_key == "mul " { + assert_eq!(blend_mode, Some("Mltp"), "{name}"); + } + checked += 1; + } + } + println!("{checked} preset(s) with MdSl only"); + assert!( + checked > 0, + "no corpus preset stores its blend mode only in MdSl" + ); +}