Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
196 changes: 196 additions & 0 deletions crates/abr/src/descriptor.rs
Original file line number Diff line number Diff line change
Expand Up @@ -809,13 +809,81 @@ fn parse_txtr(cursor: &mut Cursor<&[u8]>) -> io::Result<Txtr> {
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<String>,
opacity_pct: Option<i32>,
}

fn parse_mdsl(cursor: &mut Cursor<&[u8]>) -> io::Result<MdSl> {
let _class_name = read_unicode_string(cursor)?;
let _class_id = read_id(cursor)?;
let item_count = cursor.read_u32::<BigEndian>()?;

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::<BigEndian>()?.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::<BigEndian>()?),
_ => skip_descriptor_value(cursor, &type_tag, 0)?,
}
}
Ok(mdsl)
}

fn parse_tool_options(cursor: &mut Cursor<&[u8]>) -> io::Result<crate::ToolOptions> {
let _class_name = read_unicode_string(cursor)?;
let mut options = crate::ToolOptions {
tool: read_id(cursor)?,
..Default::default()
};
let item_count = cursor.read_u32::<BigEndian>()?;
let mut mdsl = None;

for _ in 0..item_count {
let key = read_id(cursor)?;
Expand All @@ -834,13 +902,21 @@ fn parse_tool_options(cursor: &mut Cursor<&[u8]>) -> io::Result<crate::ToolOptio
("wetness", "doub") => options.wetness_pct = Some(cursor.read_f64::<BigEndian>()?),
("dryness", "doub") => options.dryness_pct = Some(cursor.read_f64::<BigEndian>()?),
("mix", "doub") => options.mix_pct = Some(cursor.read_f64::<BigEndian>()?),
("MdSl", "Objc") => match parse_mdsl(cursor) {
Ok(parsed) => mdsl = Some(parsed),
Err(_) => break,
},
_ => {
if skip_descriptor_value(cursor, &type_tag, 0).is_err() {
break;
}
}
}
}
if let Some(mdsl) = mdsl {
options.blend_mode = options.blend_mode.or(mdsl.blend_mode);
options.opacity_pct = options.opacity_pct.or(mdsl.opacity_pct);
}
Ok(options)
}

Expand Down Expand Up @@ -1337,6 +1413,87 @@ mod tests {
buf
}

#[derive(Clone, Copy)]
enum ToolItem {
Flow,
MdSl(&'static [u8; 4]),
MalformedMdSl,
TopLevelModeAndOpacity,
}

fn build_mdsl_desc_block(items: &[ToolItem]) -> Vec<u8> {
let mut buf = Vec::new();

buf.write_u32::<BigEndian>(16).unwrap();
buf.write_u32::<BigEndian>(1).unwrap();
buf.write_u16::<BigEndian>(0).unwrap();
buf.write_u32::<BigEndian>(0).unwrap();
buf.extend_from_slice(b"null");
buf.write_u32::<BigEndian>(1).unwrap();

buf.write_u32::<BigEndian>(0).unwrap();
buf.extend_from_slice(b"Brsh");
buf.extend_from_slice(b"VlLs");
buf.write_u32::<BigEndian>(1).unwrap();

buf.extend_from_slice(b"Objc");
buf.write_u32::<BigEndian>(1).unwrap();
buf.write_u16::<BigEndian>(0).unwrap();
buf.write_u32::<BigEndian>(11).unwrap();
buf.extend_from_slice(b"brushPreset");
buf.write_u32::<BigEndian>(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::<BigEndian>(1).unwrap();
buf.write_u16::<BigEndian>(0).unwrap();
write_key(&mut buf, b"PbTl");
let count = items
.iter()
.map(|i| match i {
ToolItem::TopLevelModeAndOpacity => 2,
_ => 1,
})
.sum::<u32>();
buf.write_u32::<BigEndian>(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::<BigEndian>(1).unwrap();
buf.write_u16::<BigEndian>(0).unwrap();
write_key(&mut buf, b"MdSC");
buf.write_u32::<BigEndian>(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::<BigEndian>(1).unwrap();
buf.write_u16::<BigEndian>(0).unwrap();
write_key(&mut buf, b"MdSC");
buf.write_u32::<BigEndian>(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(),
Expand Down Expand Up @@ -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);
Expand Down
7 changes: 5 additions & 2 deletions crates/abr/src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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<i32>,
/// `toolOptions/flow` (`long`) — flow percent.
pub flow_pct: Option<i32>,
/// `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<String>,
/// `toolOptions/smoothing` (`bool`).
pub smoothing: Option<bool>,
Expand Down
84 changes: 84 additions & 0 deletions crates/abr/tests/corpus_smoke.rs
Original file line number Diff line number Diff line change
Expand Up @@ -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"
);
}
Loading