From a1a5c79b0332f99720c14c9424660689d85345bf Mon Sep 17 00:00:00 2001 From: bflatastic Date: Sun, 4 Oct 2026 23:45:24 +0700 Subject: [PATCH 1/3] M3.73: blend modes follow the reference formulas on screen, in SVG and in PDF color::blend gains blend_rgb (the 16 blend functions, with the 0.3/0.59/0.11 luminance of the non-separable modes), composite (source-over with blending) and the shared opacity-mask luminance weights. Exported SVG masks take luminance from sRGB values (color-interpolation="sRGB"), as the canvas does. Tests: a per-mode table on the canvas (object, fill and group blend modes, within 1/255; Exclusion 2/255 in the rasteriser's 8-bit pipeline), the same table through SVG export rendered by resvg, clip and invert masks against the canvas, and every mode's PDF name read back. Co-Authored-By: Claude Opus 5.5 --- crates/color/src/blend.rs | 177 +++++++++++++++++++++++++++++++ crates/pdf/src/lib.rs | 2 + crates/pdf/src/tests_blend.rs | 44 ++++++++ crates/render/src/lib.rs | 5 +- crates/render/src/tests_blend.rs | 109 +++++++++++++++++++ crates/svg/src/export.rs | 9 +- crates/svg/tests/blend_export.rs | 95 +++++++++++++++++ 7 files changed, 437 insertions(+), 4 deletions(-) create mode 100644 crates/pdf/src/tests_blend.rs create mode 100644 crates/render/src/tests_blend.rs create mode 100644 crates/svg/tests/blend_export.rs diff --git a/crates/color/src/blend.rs b/crates/color/src/blend.rs index a5f61dec..372669ca 100644 --- a/crates/color/src/blend.rs +++ b/crates/color/src/blend.rs @@ -75,6 +75,11 @@ impl BlendMode { _ => 5, } } + /// Whether the mode works on each colour channel separately (all but Hue, Saturation, Color + /// and Luminosity). + pub fn is_separable(self) -> bool { + self.group() != 5 + } /// Parse a label or identifier, case/space-insensitively. pub fn parse(s: &str) -> Option { let norm = |x: &str| x.to_ascii_lowercase().replace([' ', '_', '-'], ""); @@ -83,10 +88,182 @@ impl BlendMode { } } +/// Luminance weights of the non-separable modes (Hue, Saturation, Color, Luminosity), as the PDF +/// and W3C compositing specifications define them. +pub const LUM: [f32; 3] = [0.3, 0.59, 0.11]; + +/// Luminance weights of opacity masks (Rec. 709, applied to the sRGB values as SVG luminance masks +/// with `color-interpolation="sRGB"` apply them). +pub const MASK_LUM: [f32; 3] = [0.2126, 0.7152, 0.0722]; + +/// The blend function B(backdrop, source) of `mode` on straight (not premultiplied) RGB in 0..=1: +/// the colour that replaces the backdrop where an opaque source covers an opaque backdrop. Every +/// output (screen, SVG, PDF and transparency flattening) follows these formulas. +pub fn blend_rgb(mode: BlendMode, backdrop: [f32; 3], source: [f32; 3]) -> [f32; 3] { + use BlendMode as B; + let separable = |f: fn(f32, f32) -> f32| [0, 1, 2].map(|i| f(backdrop[i].clamp(0.0, 1.0), source[i].clamp(0.0, 1.0))); + match mode { + B::Normal => separable(|_, s| s), + B::Multiply => separable(|b, s| b * s), + B::Screen => separable(screen), + B::Overlay => separable(|b, s| hard_light(s, b)), + B::Darken => separable(f32::min), + B::Lighten => separable(f32::max), + B::ColorDodge => separable(|b, s| { + if b <= 0.0 { + 0.0 + } else if s >= 1.0 { + 1.0 + } else { + (b / (1.0 - s)).min(1.0) + } + }), + B::ColorBurn => separable(|b, s| { + if b >= 1.0 { + 1.0 + } else if s <= 0.0 { + 0.0 + } else { + 1.0 - ((1.0 - b) / s).min(1.0) + } + }), + B::HardLight => separable(hard_light), + B::SoftLight => separable(|b, s| { + if s <= 0.5 { + b - (1.0 - 2.0 * s) * b * (1.0 - b) + } else { + let d = if b <= 0.25 { ((16.0 * b - 12.0) * b + 4.0) * b } else { b.sqrt() }; + b + (2.0 * s - 1.0) * (d - b) + } + }), + B::Difference => separable(|b, s| (b - s).abs()), + B::Exclusion => separable(|b, s| b + s - 2.0 * b * s), + B::Hue => set_lum(set_sat(source, sat(backdrop)), lum(backdrop)), + B::Saturation => set_lum(set_sat(backdrop, sat(source)), lum(backdrop)), + B::Color => set_lum(source, lum(backdrop)), + B::Luminosity => set_lum(backdrop, lum(source)), + } +} + +/// Source-over compositing of `source` onto `backdrop` with `mode` (straight RGBA in 0..=1, the +/// result straight too): the source colour is mixed with B(backdrop, source) by the backdrop's +/// alpha, then laid over the backdrop by its own alpha. +pub fn composite(mode: BlendMode, backdrop: [f32; 4], source: [f32; 4]) -> [f32; 4] { + let (ab, as_) = (backdrop[3].clamp(0.0, 1.0), source[3].clamp(0.0, 1.0)); + let ao = as_ + ab * (1.0 - as_); + if ao <= 0.0 { + return [0.0; 4]; + } + let mixed = blend_rgb(mode, [backdrop[0], backdrop[1], backdrop[2]], [source[0], source[1], source[2]]); + let c = |i: usize| ((1.0 - ab) * source[i] + ab * mixed[i]) * as_ + (1.0 - as_) * ab * backdrop[i]; + [c(0) / ao, c(1) / ao, c(2) / ao, ao] +} + +fn screen(b: f32, s: f32) -> f32 { + b + s - b * s +} + +fn hard_light(b: f32, s: f32) -> f32 { + if s <= 0.5 { b * 2.0 * s } else { screen(b, 2.0 * s - 1.0) } +} + +fn lum(c: [f32; 3]) -> f32 { + LUM[0] * c[0] + LUM[1] * c[1] + LUM[2] * c[2] +} + +fn sat(c: [f32; 3]) -> f32 { + c[0].max(c[1]).max(c[2]) - c[0].min(c[1]).min(c[2]) +} + +/// Bring a colour moved off the gamut by [`set_lum`] back in, keeping its luminance. +fn clip_color(c: [f32; 3]) -> [f32; 3] { + let l = lum(c); + let (n, x) = (c[0].min(c[1]).min(c[2]), c[0].max(c[1]).max(c[2])); + let mut c = c; + if n < 0.0 { + c = c.map(|v| l + (v - l) * l / (l - n)); + } + if x > 1.0 { + c = c.map(|v| l + (v - l) * (1.0 - l) / (x - l)); + } + c +} + +fn set_lum(c: [f32; 3], l: f32) -> [f32; 3] { + let d = l - lum(c); + clip_color(c.map(|v| v + d)) +} + +/// `c` with saturation `s`: its largest component becomes `s`, its smallest 0 and the middle one +/// keeps its proportion. +fn set_sat(c: [f32; 3], s: f32) -> [f32; 3] { + let (n, x) = (c[0].min(c[1]).min(c[2]), c[0].max(c[1]).max(c[2])); + if x <= n { + return [0.0; 3]; + } + c.map(|v| (v - n) * s / (x - n)) +} + #[cfg(test)] mod tests { use super::*; + fn near(a: [f32; 3], b: [f32; 3]) -> bool { + a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-5) + } + + #[test] + fn separable_modes_follow_the_reference_formulas() { + let (b, s) = ([0.2, 0.5, 0.9], [0.6, 0.25, 0.5]); + let cases: [(BlendMode, [f32; 3]); 12] = [ + (BlendMode::Normal, s), + (BlendMode::Multiply, [0.12, 0.125, 0.45]), + (BlendMode::Screen, [0.68, 0.625, 0.95]), + (BlendMode::Darken, [0.2, 0.25, 0.5]), + (BlendMode::Lighten, [0.6, 0.5, 0.9]), + (BlendMode::Difference, [0.4, 0.25, 0.4]), + (BlendMode::Exclusion, [0.56, 0.5, 0.5]), + // Overlay = Hard Light with the layers swapped: b ≤ ½ multiplies, else screens. + (BlendMode::Overlay, [0.24, 0.25, 0.9]), + (BlendMode::HardLight, [0.36, 0.25, 0.9]), + (BlendMode::ColorDodge, [0.5, 0.6666667, 1.0]), + (BlendMode::ColorBurn, [0.0, 0.0, 0.8]), + // s ≤ ½ darkens by b(1−b)(1−2s); s > ½ lightens towards D(b). + (BlendMode::SoftLight, [0.2 + 0.2 * (((16.0 * 0.2 - 12.0) * 0.2 + 4.0) * 0.2 - 0.2), 0.375, 0.9]), + ]; + for (m, want) in cases { + assert!(near(blend_rgb(m, b, s), want), "{m:?}: {:?} ≠ {want:?}", blend_rgb(m, b, s)); + } + } + + #[test] + fn non_separable_modes_keep_the_reference_luminance() { + let (b, s) = ([0.8, 0.3, 0.2], [0.1, 0.4, 0.9]); + // Color and Hue take the backdrop's luminance; Luminosity the source's. + for m in [BlendMode::Hue, BlendMode::Saturation, BlendMode::Color] { + assert!((lum(blend_rgb(m, b, s)) - lum(b)).abs() < 1e-5, "{m:?}"); + } + assert!((lum(blend_rgb(BlendMode::Luminosity, b, s)) - lum(s)).abs() < 1e-5); + // Saturation of grey is 0: a grey source desaturates the backdrop to its luminance. + let l = lum(b); + assert!(near(blend_rgb(BlendMode::Saturation, b, [0.5; 3]), [l; 3])); + // Hue of the source with the backdrop's saturation: blue-ish stays blue-ish. + let h = blend_rgb(BlendMode::Hue, b, s); + assert!(h[2] > h[1] && h[1] > h[0], "{h:?}"); + assert!((sat(h) - sat(b)).abs() < 1e-5); + } + + #[test] + fn composite_lays_the_blend_over_the_backdrop_by_alpha() { + let (b, s) = ([0.8, 0.4, 0.2, 1.0], [0.5, 0.5, 0.5, 0.5]); + let o = composite(BlendMode::Multiply, b, s); + // Half of the multiplied colour over half of the backdrop. + assert!(near([o[0], o[1], o[2]], [0.6, 0.3, 0.15]) && o[3] == 1.0, "{o:?}"); + // Over a transparent backdrop the source shows unblended. + let o = composite(BlendMode::Difference, [0.3, 0.3, 0.3, 0.0], s); + assert!(near([o[0], o[1], o[2]], [0.5; 3]) && (o[3] - 0.5).abs() < 1e-6, "{o:?}"); + } + #[test] fn parse_labels() { assert_eq!(BlendMode::parse("color burn"), Some(BlendMode::ColorBurn)); diff --git a/crates/pdf/src/lib.rs b/crates/pdf/src/lib.rs index ec4052af..f8d0a240 100644 --- a/crates/pdf/src/lib.rs +++ b/crates/pdf/src/lib.rs @@ -112,6 +112,8 @@ mod tests_dashalign; #[cfg(test)] mod tests_fx; #[cfg(test)] +mod tests_blend; +#[cfg(test)] mod tests_stroke; #[cfg(test)] mod tests_strokeout; diff --git a/crates/pdf/src/tests_blend.rs b/crates/pdf/src/tests_blend.rs new file mode 100644 index 00000000..985be16a --- /dev/null +++ b/crates/pdf/src/tests_blend.rs @@ -0,0 +1,44 @@ +//! Blend modes and transparency groups in PDF export. + +use vectorcraft_color::{BlendMode, Color, Paint}; +use vectorcraft_doc::{Appearance, Document, Node, NodeId}; +use vectorcraft_geom::{Rect, shapes}; + +use crate::*; + +fn rect(r: Rect, rgb: (f32, f32, f32)) -> Node { + Node::path(NodeId(0), shapes::rectangle(r), Appearance::basic(Paint::solid(Color::rgb(rgb.0, rgb.1, rgb.2)), Paint::None, 0.0)) +} + +fn add(d: &mut Document, mut n: Node) { + n.id = d.alloc_id(); + let l = d.layers[0].id; + d.insert(Some(l), usize::MAX, n).unwrap(); +} + +/// The file's text with spaces removed (content streams uncompressed). +fn text(d: &Document) -> String { + let bytes = export(d, &PdfOptions { compress: false, ..Default::default() }).unwrap(); + String::from_utf8_lossy(&bytes).replace(' ', "") +} + +#[test] +fn every_blend_mode_is_written_under_its_pdf_name_and_read_back() { + for mode in BlendMode::ALL.into_iter().filter(|m| *m != BlendMode::Normal) { + let mut d = Document::new(100.0, 100.0); + add(&mut d, rect(Rect::new(0.0, 0.0, 100.0, 100.0), (0.2, 0.5, 0.9))); + let mut top = rect(Rect::new(20.0, 20.0, 80.0, 80.0), (0.6, 0.25, 0.5)); + top.blend = mode; + add(&mut d, top); + let name = mode.label().replace(' ', ""); + assert!(text(&d).contains(&format!("/BM/{name}")), "{mode:?}"); + let back = import(&export(&d, &PdfOptions::default()).unwrap()).unwrap(); + let mut found = BlendMode::Normal; + back.walk(|n| { + if n.blend != BlendMode::Normal { + found = n.blend; + } + }); + assert_eq!(found, mode); + } +} diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs index 434a23b1..d4181963 100644 --- a/crates/render/src/lib.rs +++ b/crates/render/src/lib.rs @@ -968,7 +968,8 @@ impl Renderer { /// Opacity-mask coverage of one premultiplied pixel: luminance, with the area outside the mask /// art black (clip) or white (no clip), optionally inverted. fn mask_value(r: u8, g: u8, b: u8, a: u8, clip: bool, invert: bool) -> u8 { - let mut l = (0.2126 * r as f32 + 0.7152 * g as f32 + 0.0722 * b as f32) / 255.0; + let [kr, kg, kb] = vectorcraft_color::blend::MASK_LUM; + let mut l = (kr * r as f32 + kg * g as f32 + kb * b as f32) / 255.0; if !clip { l += 1.0 - a as f32 / 255.0; } @@ -1101,6 +1102,8 @@ fn now() -> u64 { #[cfg(test)] mod tests; #[cfg(test)] +mod tests_blend; +#[cfg(test)] mod tests_clip; #[cfg(test)] mod tests_knockout; diff --git a/crates/render/src/tests_blend.rs b/crates/render/src/tests_blend.rs new file mode 100644 index 00000000..986dd43e --- /dev/null +++ b/crates/render/src/tests_blend.rs @@ -0,0 +1,109 @@ +//! Blend-mode accuracy: every mode matches the reference formulas ([`blend_rgb`]) within 1/255 +//! (see [`tolerance`]), whether it is an object's blend mode, a fill's or a group's. + +use super::*; +use vectorcraft_color::blend::blend_rgb; +use vectorcraft_color::{BlendMode as Blend, Color, Paint}; +use vectorcraft_doc::{Appearance, Node}; +use vectorcraft_geom::shapes; + +/// Backdrop / source pairs (8-bit, so the expected values carry no input rounding) that take every +/// branch of the formulas: dark and light backdrops, sources on both sides of ½, greys, extremes. +const PAIRS: [([u8; 3], [u8; 3]); 6] = [ + ([51, 128, 230], [153, 64, 128]), + ([230, 26, 102], [77, 204, 179]), + ([0, 255, 128], [255, 0, 127]), + ([200, 180, 40], [20, 60, 250]), + ([128, 128, 128], [240, 30, 90]), + ([10, 90, 160], [128, 128, 128]), +]; + +fn rect(d: &mut Document, r: Rect, rgb: [u8; 3]) -> Node { + Node::path(d.alloc_id(), shapes::rectangle(r), Appearance::basic(Paint::solid(Color::rgb8(rgb[0], rgb[1], rgb[2])), Paint::None, 0.0)) +} + +/// Where the blend is set: on the object, on its fill, or on a group around it. +#[derive(Clone, Copy, Debug)] +enum Level { + Object, + Fill, + Group, +} + +/// An opaque backdrop with the source on top of it, blended with `mode` at `level`. +fn doc(mode: Blend, level: Level, backdrop: [u8; 3], source: [u8; 3]) -> Document { + let mut d = Document::new(20.0, 20.0); + let below = rect(&mut d, Rect::new(0.0, 0.0, 20.0, 20.0), backdrop); + let mut top = rect(&mut d, Rect::new(5.0, 5.0, 15.0, 15.0), source); + match level { + Level::Object => top.blend = mode, + Level::Fill => { + if let Some(vectorcraft_doc::AppearanceItem::Fill(f)) = top.appearance.items.first_mut() { + f.blend = mode; + } + } + Level::Group => {} + } + let top = match level { + Level::Group => { + let mut g = Node::group(d.alloc_id(), vec![Arc::new(top)]); + g.blend = mode; + g + } + _ => top, + }; + let l = d.layers[0].id; + d.insert(Some(l), usize::MAX, below).unwrap(); + d.insert(Some(l), usize::MAX, top).unwrap(); + d +} + +pub(crate) fn expected(mode: Blend, backdrop: [u8; 3], source: [u8; 3]) -> [u8; 3] { + let f = |c: [u8; 3]| c.map(|v| v as f32 / 255.0); + blend_rgb(mode, f(backdrop), f(source)).map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8) +} + +/// Whether `a` is within `tol`/255 of `b` in every channel. +pub(crate) fn within(a: [u8; 3], b: [u8; 3], tol: i32) -> bool { + a.iter().zip(b).all(|(x, y)| (*x as i32 - y as i32).abs() <= tol) +} + +/// Tolerance of `mode` on screen: 1/255, except Exclusion, which the rasteriser's 8-bit pipeline +/// rounds twice (b + s − 2bs). +fn tolerance(mode: Blend) -> i32 { + if mode == Blend::Exclusion { 2 } else { 1 } +} + +#[test] +fn every_mode_matches_the_reference_formulas() { + let mut r = Renderer::new(); + for mode in Blend::ALL { + for level in [Level::Object, Level::Fill, Level::Group] { + for (b, s) in PAIRS { + let px = r.render(&doc(mode, level, b, s), 20, 20, Affine::IDENTITY, &RenderOptions::default()).pixel(10, 10); + let want = expected(mode, b, s); + assert!( + within([px[0], px[1], px[2]], want, tolerance(mode)) && px[3] == 255, + "{mode:?} at {level:?}, {b:?} under {s:?}: {px:?}, want {want:?}" + ); + } + } + } +} + +#[test] +fn a_translucent_source_mixes_the_blend_by_its_opacity() { + let mut r = Renderer::new(); + for mode in Blend::ALL { + let (b, s) = PAIRS[0]; + let mut d = doc(mode, Level::Object, b, s); + let top = d.layers[0].children().unwrap()[1].id; + d.node_mut(top).unwrap().opacity = 0.6; + let px = r.render(&d, 20, 20, Affine::IDENTITY, &RenderOptions::default()).pixel(10, 10); + let f = |c: [u8; 3], a: f32| [c[0] as f32 / 255.0, c[1] as f32 / 255.0, c[2] as f32 / 255.0, a]; + let o = vectorcraft_color::blend::composite(mode, f(b, 1.0), f(s, 0.6)); + let want = [o[0], o[1], o[2]].map(|v| (v * 255.0).round() as u8); + // The opacity is one more 8-bit step. + assert!(within([px[0], px[1], px[2]], want, tolerance(mode) + 1), "{mode:?}: {px:?}, want {want:?}"); + } +} diff --git a/crates/svg/src/export.rs b/crates/svg/src/export.rs index 27daeeab..df0c07a5 100644 --- a/crates/svg/src/export.rs +++ b/crates/svg/src/export.rs @@ -134,6 +134,9 @@ enum StrokePlan { /// A region covering any artwork (mask and filter extents). const BIG: &str = "x=\"-100000\" y=\"-100000\" width=\"200000\" height=\"200000\""; +/// Attributes of every ``: user-space units, and luminance taken from the sRGB values (as the +/// canvas and PDF take it) rather than from linearised ones. +const MASK: &str = "maskUnits=\"userSpaceOnUse\" color-interpolation=\"sRGB\""; pub(crate) fn blend_css(b: BlendMode) -> &'static str { match b { @@ -504,7 +507,7 @@ impl Writer<'_> { let b = self.xf.transform_rect_bbox(reach).inflate(1.0, 1.0); let (x, y, w, h) = (self.num(b.x0), self.num(b.y0), self.num(b.width()), self.num(b.height())); let fr = if rule == FillRule::EvenOdd { " fill-rule=\"evenodd\"" } else { "" }; - self.def(1, &format!("")); + self.def(1, &format!("")); self.def(2, &format!("")); self.def(2, &format!("")); self.def(1, ""); @@ -659,7 +662,7 @@ impl Writer<'_> { self.def(1, ""); fid }); - self.def(1, &format!("")); + self.def(1, &format!("")); if let Some(fid) = &inv { self.def(1, &format!("")); } @@ -751,7 +754,7 @@ impl Writer<'_> { let art = self.detached(3, |w| w.node(&shape)); self.anonymous = anonymous; let mid = self.fresh_id("knockout"); - self.def(1, &format!("")); + self.def(1, &format!("")); self.def(2, &format!("")); self.def(2, &format!("")); self.defs.push_str(&art); diff --git a/crates/svg/tests/blend_export.rs b/crates/svg/tests/blend_export.rs new file mode 100644 index 00000000..503130c9 --- /dev/null +++ b/crates/svg/tests/blend_export.rs @@ -0,0 +1,95 @@ +//! Blend modes and opacity masks in SVG export look as on the canvas: every mode follows the +//! reference formulas when resvg draws the file, and masks take luminance the canvas's way. + +use vectorcraft_color::blend::blend_rgb; +use vectorcraft_color::{BlendMode, Color, Paint}; +use vectorcraft_doc::{Appearance, Document, Node, OpacityMask}; +use vectorcraft_geom::{Rect, shapes}; +use vectorcraft_svg::{ExportOptions, export}; +use vectorcraft_testkit::raster::{Image, render_artboard}; + +fn rect(d: &mut Document, r: Rect, rgb: [u8; 3]) -> Node { + Node::path(d.alloc_id(), shapes::rectangle(r), Appearance::basic(Paint::solid(Color::rgb8(rgb[0], rgb[1], rgb[2])), Paint::None, 0.0)) +} + +fn add(d: &mut Document, n: Node) { + let l = d.layers[0].id; + d.insert(Some(l), usize::MAX, n).unwrap(); +} + +/// The exported SVG rendered by resvg on white at 1 px/pt. +fn resvg_render(svg: &str, w: u32, h: u32) -> Image { + let tree = resvg::usvg::Tree::from_str(svg, &resvg::usvg::Options::default()).expect("parse"); + let mut pm = resvg::tiny_skia::Pixmap::new(w, h).unwrap(); + pm.fill(resvg::tiny_skia::Color::WHITE); + resvg::render(&tree, resvg::tiny_skia::Transform::identity(), &mut pm.as_mut()); + Image { width: w, height: h, rgba: pm.data().to_vec() } +} + +fn within(a: [u8; 3], b: [u8; 3], tol: i32) -> bool { + a.iter().zip(b).all(|(x, y)| (*x as i32 - y as i32).abs() <= tol) +} + +#[test] +fn every_blend_mode_follows_the_reference_formulas() { + // (backdrop, source, whether a non-separable result leaves the gamut). resvg's rasteriser + // departs from the reference formulas when Hue, Saturation, Color or Luminosity have to clip + // their result back into the gamut, so those cases are checked on the canvas only + // (vectorcraft-render's blend tests). + let pairs: [([u8; 3], [u8; 3], bool); 4] = [ + ([51, 128, 230], [153, 64, 128], false), + ([230, 26, 102], [77, 204, 179], true), + ([200, 180, 40], [20, 60, 250], true), + ([10, 90, 160], [128, 128, 128], false), + ]; + for mode in BlendMode::ALL { + for (b, s, clips) in pairs { + if clips && !mode.is_separable() { + continue; + } + let mut d = Document::new(20.0, 20.0); + let below = rect(&mut d, Rect::new(0.0, 0.0, 20.0, 20.0), b); + let mut top = rect(&mut d, Rect::new(5.0, 5.0, 15.0, 15.0), s); + top.blend = mode; + add(&mut d, below); + add(&mut d, top); + let svg = export(&d, &ExportOptions::default()); + let px = resvg_render(&svg, 20, 20).over_white(10, 10); + let f = |c: [u8; 3]| c.map(|v| v as f32 / 255.0); + let want = blend_rgb(mode, f(b), f(s)).map(|v| (v * 255.0).round() as u8); + assert!(within(px, want, 1), "{mode:?}, {b:?} under {s:?}: {px:?}, want {want:?}"); + } + } +} + +/// A red square under a mask of green art (luminance 0.7152 with Rec. 709 weights, 0.59 with the +/// blend-mode weights) that covers its left half. +fn masked(clip: bool, invert: bool) -> Document { + let mut d = Document::new(40.0, 20.0); + let art = rect(&mut d, Rect::new(0.0, 0.0, 20.0, 20.0), [0, 255, 0]); + let mut red = rect(&mut d, Rect::new(0.0, 0.0, 40.0, 20.0), [255, 0, 0]); + let mut m = OpacityMask::new(art, clip); + m.invert = invert; + red.mask = Some(Box::new(m)); + add(&mut d, red); + d +} + +#[test] +fn clip_and_invert_masks_match_the_canvas() { + for (clip, invert) in [(true, false), (false, false), (true, true), (false, true)] { + let d = masked(clip, invert); + let svg = export(&d, &ExportOptions::default()); + assert!(svg.contains("color-interpolation=\"sRGB\""), "{svg}"); + let canvas = render_artboard(&d); + let written = resvg_render(&svg, 40, 20); + for x in [10, 30] { + let (c, w) = (canvas.over_white(x, 10), written.over_white(x, 10)); + assert!(within(c, w, 2), "clip {clip}, invert {invert}, x {x}: canvas {c:?}, svg {w:?}"); + } + // Over the green art the red shows at the art's luminance (inverted: its complement). + let lum: f32 = if invert { 1.0 - 0.7152 } else { 0.7152 }; + let g = (255.0 * (1.0 - lum)).round() as u8; + assert!(within(canvas.over_white(10, 10), [255, g, g], 2), "{:?}", canvas.over_white(10, 10)); + } +} From 54427d7a9264a7ffc42dd8531583966dfb017ce4 Mon Sep 17 00:00:00 2001 From: bflatastic Date: Mon, 5 Oct 2026 00:03:18 +0700 Subject: [PATCH 2/3] M3.74: blending inside a group reaches the art below unless the group isolates it On screen, a group (or object) with opacity, a blend mode, an opacity mask or knockout whose content blends is drawn offscreen over a copy of its backdrop and mixed back in by its opacity, mask and clip (a group blend mode then applies to the backdrop-free result, as PDF defines it). Isolate Blending keeps the content starting from transparency. Clip groups no longer isolate their children (blending content is clipped per drawing), and non-isolated knockout groups composite their elements against the art below the group. Groups without blending inside still render as plain layers. In PDF, such groups are written as non-isolated transparency groups (a constant-alpha soft mask instead of the writer's isolated opacity group), knockout groups included. doc: Node::blends_through / children_blend. Co-Authored-By: Claude Opus 5.5 --- crates/doc/src/node.rs | 20 ++ crates/pdf/src/export.rs | 46 +++-- crates/pdf/src/lib.rs | 4 +- crates/pdf/src/tests_blend.rs | 55 ++++++ crates/render/src/brush_fx.rs | 21 +- crates/render/src/fx.rs | 31 +-- crates/render/src/group.rs | 275 +++++++++++++++++++++++++++ crates/render/src/lib.rs | 185 ++++++++++-------- crates/render/src/live.rs | 19 +- crates/render/src/pattern.rs | 18 +- crates/render/src/tests_isolation.rs | 215 +++++++++++++++++++++ docs/mcp.md | 8 +- 12 files changed, 755 insertions(+), 142 deletions(-) create mode 100644 crates/render/src/group.rs create mode 100644 crates/render/src/tests_isolation.rs diff --git a/crates/doc/src/node.rs b/crates/doc/src/node.rs index ac21bd3e..55a37261 100644 --- a/crates/doc/src/node.rs +++ b/crates/doc/src/node.rs @@ -752,6 +752,26 @@ impl Node { push(children, &mut out); out } + + /// Whether blending inside this object reaches the art below it unless the object isolates + /// it: a blend mode other than Normal on a child (or, in a leaf, on a fill or stroke), + /// directly or through children that don't isolate their own blending. + pub fn blends_through(&self) -> bool { + self.blends_through_with(&mut |c| c.blends_through()) + } + + /// [`Self::blends_through`], with `inner` answering it for the children (e.g. from a cache). + pub fn blends_through_with(&self, inner: &mut dyn FnMut(&Arc) -> bool) -> bool { + match self.children() { + Some(ch) if !matches!(self.kind, NodeKind::Compound { .. }) => Self::children_blend(ch, inner), + _ => self.appearance.items.iter().any(|i| i.visible() && i.blend() != BlendMode::Normal), + } + } + + /// [`Self::blends_through`] of a group made of `children` (`inner` answers it for each child). + pub fn children_blend(children: &[Arc], inner: &mut dyn FnMut(&Arc) -> bool) -> bool { + children.iter().any(|c| c.visible && (c.blend != BlendMode::Normal || (!c.isolate && inner(c)))) + } } /// Is `a` a move plus a positive uniform scale (after which a refit gradient still matches)? diff --git a/crates/pdf/src/export.rs b/crates/pdf/src/export.rs index f8046d51..54f5a110 100644 --- a/crates/pdf/src/export.rs +++ b/crates/pdf/src/export.rs @@ -208,18 +208,25 @@ fn color(c: &Color) -> krilla::color::Color { } } -/// Fill the page (with a margin) with an opaque grey level (0 = black, 255 = white): mask backdrops. -fn cover(s: &mut Surface, page: Rect, level: u8) { +/// Fill the page (with a margin) with a grey level (0 = black, 255 = white) at `opacity`: mask +/// backdrops. +fn cover(s: &mut Surface, page: Rect, level: u8, opacity: f32) { let Some(p) = to_path(&page.inflate(1.0, 1.0).to_path(0.1)) else { return }; s.set_stroke(None); - s.set_fill(Some(Fill { - paint: rgb::Color::new(level, level, level).into(), - opacity: NormalizedF32::ONE, - rule: krilla::paint::FillRule::NonZero, - })); + s.set_fill(Some(Fill { paint: rgb::Color::new(level, level, level).into(), opacity: norm(opacity), rule: krilla::paint::FillRule::NonZero })); s.draw_path(&p); } +/// An alpha mask of constant `alpha` over the page. A group drawn through it is a transparency +/// group of that opacity that, unlike the writer's opacity groups, is not isolated. +fn constant_mask(s: &mut Surface, page: Rect, alpha: f32) -> krilla::mask::Mask { + let mut sb = s.stream_builder(); + let mut ms = sb.surface(); + cover(&mut ms, page, 0, alpha); + ms.finish(); + krilla::mask::Mask::new(sb.finish(), krilla::mask::MaskType::Alpha) +} + fn rects_overlap(a: Rect, b: Rect) -> bool { a.x0 <= b.x1 && b.x0 <= a.x1 && a.y0 <= b.y1 && b.y0 <= a.y1 } @@ -356,7 +363,7 @@ impl Exporter<'_> { // An opaque backdrop when it matters: white outside the art (no clip), or black for the // inverting Difference pass below to turn white. if !m.clip || m.invert { - cover(&mut ms, page, if m.clip { 0 } else { 255 }); + cover(&mut ms, page, if m.clip { 0 } else { 255 }, 1.0); } // Mask art is a picture of its own: it takes no part in a knockout group around the object. let knockout = std::mem::take(&mut self.knockout); @@ -364,7 +371,7 @@ impl Exporter<'_> { self.knockout = knockout; if m.invert { ms.push_blend_mode(krilla::blend::BlendMode::Difference); - cover(&mut ms, page, 255); + cover(&mut ms, page, 255, 1.0); ms.pop(); } ms.finish(); @@ -405,7 +412,7 @@ impl Exporter<'_> { let shape = if c.knockout_shape { c.clone() } else { Node { opacity: 1.0, mask: None, ..c.clone() } }; let mut sb = s.stream_builder(); let mut ms = sb.surface(); - cover(&mut ms, page, 255); + cover(&mut ms, page, 255, 1.0); let alpha = { let mut ab = ms.stream_builder(); let mut als = ab.surface(); @@ -414,7 +421,7 @@ impl Exporter<'_> { krilla::mask::Mask::new(ab.finish(), krilla::mask::MaskType::Alpha) }; ms.push_mask(alpha); - cover(&mut ms, page, 0); + cover(&mut ms, page, 0, 1.0); ms.pop(); ms.finish(); krilla::mask::Mask::new(sb.finish(), krilla::mask::MaskType::Luminosity) @@ -434,7 +441,7 @@ impl Exporter<'_> { } self.warn_raster(&n.appearance.effects); let container = n.is_container() && !matches!(n.kind, NodeKind::Compound { .. }); - // Whether this container's children knock each other out (a knockout group is isolated). + // Whether this container's children knock each other out (a knockout group is written as a group). let knockout = n.knocks_out(self.knockout); let enclosing = std::mem::replace(&mut self.knockout, knockout); let mut pushes = 0; @@ -442,11 +449,16 @@ impl Exporter<'_> { s.push_blend_mode(blend(n.blend)); pushes += 1; } - if n.opacity < 1.0 { - s.push_opacity(norm(n.opacity)); - pushes += 1; - } else if container && (n.isolate || n.blend != BlendMode::Normal || knockout) { - s.push_isolated(); + if n.opacity < 1.0 || (container && (n.isolate || n.blend != BlendMode::Normal || knockout)) { + if !n.isolate && n.blends_through() { + // Not isolated: blending inside reaches the art below the group. + let alpha = constant_mask(s, page, n.opacity); + s.push_mask(alpha); + } else if n.opacity < 1.0 { + s.push_opacity(norm(n.opacity)); + } else { + s.push_isolated(); + } pushes += 1; } if let Some(m) = n.mask.as_deref() diff --git a/crates/pdf/src/lib.rs b/crates/pdf/src/lib.rs index f8d0a240..1e6ec125 100644 --- a/crates/pdf/src/lib.rs +++ b/crates/pdf/src/lib.rs @@ -108,12 +108,12 @@ pub enum PdfError { #[cfg(test)] mod tests; #[cfg(test)] +mod tests_blend; +#[cfg(test)] mod tests_dashalign; #[cfg(test)] mod tests_fx; #[cfg(test)] -mod tests_blend; -#[cfg(test)] mod tests_stroke; #[cfg(test)] mod tests_strokeout; diff --git a/crates/pdf/src/tests_blend.rs b/crates/pdf/src/tests_blend.rs index 985be16a..dbafa475 100644 --- a/crates/pdf/src/tests_blend.rs +++ b/crates/pdf/src/tests_blend.rs @@ -42,3 +42,58 @@ fn every_blend_mode_is_written_under_its_pdf_name_and_read_back() { assert_eq!(found, mode); } } + +/// The backdrop and a 50% group (isolated or not) holding a Multiply square. +fn half_group(isolate: bool) -> Document { + let mut d = Document::new(100.0, 100.0); + add(&mut d, rect(Rect::new(0.0, 0.0, 100.0, 100.0), (0.8, 0.6, 0.2))); + let mut m = rect(Rect::new(20.0, 20.0, 80.0, 80.0), (0.5, 0.5, 1.0)); + (m.id, m.blend) = (d.alloc_id(), BlendMode::Multiply); + let mut g = Node::group(NodeId(0), vec![std::sync::Arc::new(m)]); + (g.opacity, g.isolate) = (0.5, isolate); + add(&mut d, g); + d +} + +#[test] +fn a_group_is_written_non_isolated_unless_it_isolates_blending() { + let open = text(&half_group(false)); + // A transparency group without /I, its 50% carried by a constant alpha soft mask. + assert!(!open.contains("/Itrue"), "{open}"); + assert!(open.contains("/SMask") && open.contains("/Alpha") && open.contains("/BM/Multiply"), "{open}"); + let isolated = text(&half_group(true)); + assert!(isolated.contains("/Itrue") && isolated.contains("/ca0.5"), "{isolated}"); + assert!(!isolated.contains("/Alpha"), "{isolated}"); + // Either way the child's blend mode reads back. + for d in [half_group(false), half_group(true)] { + let back = import(&export(&d, &PdfOptions::default()).unwrap()).unwrap(); + let mut bm = BlendMode::Normal; + back.walk(|n| { + if n.blend != BlendMode::Normal { + bm = n.blend; + } + }); + assert_eq!(bm, BlendMode::Multiply); + } +} + +#[test] +fn groups_without_blending_inside_stay_isolated_groups() { + let mut d = half_group(false); + let g = d.layers[0].children().unwrap()[1].id; + let m = d.node(g).unwrap().children().unwrap()[0].id; + d.node_mut(m).unwrap().blend = BlendMode::Normal; + let t = text(&d); + assert!(t.contains("/Itrue") && t.contains("/ca0.5") && !t.contains("/SMask"), "{t}"); +} + +#[test] +fn a_knockout_group_with_blending_elements_is_non_isolated_unless_isolated() { + for isolate in [false, true] { + let mut d = half_group(isolate); + let g = d.layers[0].children().unwrap()[1].id; + let n = d.node_mut(g).unwrap(); + (n.opacity, n.knockout) = (1.0, vectorcraft_doc::Knockout::On); + assert_eq!(text(&d).contains("/Itrue"), isolate, "isolate {isolate}"); + } +} diff --git a/crates/render/src/brush_fx.rs b/crates/render/src/brush_fx.rs index 2fa32741..d089cc60 100644 --- a/crates/render/src/brush_fx.rs +++ b/crates/render/src/brush_fx.rs @@ -13,7 +13,7 @@ use vectorcraft_doc::{AppearanceItem, Document, Node, StrokeLayer}; use vectorcraft_geom::{BezPath, Rect}; use vello_cpu::RenderContext; -use crate::{Frame, Renderer, blend_mode}; +use crate::{Frame, Renderer}; struct Entry { path: BezPath, @@ -98,16 +98,15 @@ impl Renderer { pieces } }; - let layered = st.opacity < 1.0 || st.blend != vectorcraft_color::BlendMode::Normal; - if layered { - ctx.set_transform(vectorcraft_geom::Affine::IDENTITY); - ctx.push_layer(None, Some(blend_mode(st.blend)), Some(st.opacity), None, None); - } - for p in pieces.iter() { - self.draw_node(ctx, f, p, true); - } - if layered { - ctx.pop_layer(); + let mut draw = |r: &mut Self, c: &mut RenderContext, fr: &Frame| { + for p in pieces.iter() { + r.draw_node(c, fr, p, true); + } + }; + if st.opacity < 1.0 || st.blend != vectorcraft_color::BlendMode::Normal { + self.group(ctx, f, crate::group::Composite { blend: st.blend, opacity: st.opacity, ..Default::default() }, &mut draw); + } else { + draw(self, ctx, f); } true } diff --git a/crates/render/src/fx.rs b/crates/render/src/fx.rs index 7ecd9c73..643adede 100644 --- a/crates/render/src/fx.rs +++ b/crates/render/src/fx.rs @@ -284,7 +284,7 @@ impl Renderer { // Silhouette (the object's painted alpha), offset by the shadow distance. let mut off = crate::single_threaded_context(w, h); let crop = Frame { mt: false, view: Affine::translate((-x0, -y0)) * f.view, ..*f }; - paint(self, &mut off, &shifted(&crop, dx, dy)); + self.inside_layer(|r| paint(r, &mut off, &shifted(&crop, dx, dy))); off.flush(); let mut pm = vello_cpu::Pixmap::new(w, h); off.render(&mut pm, &mut self.resources); @@ -343,11 +343,19 @@ impl Renderer { /// the art standing for the object's silhouette. pub(crate) fn draw_object_fx(&mut self, ctx: &mut RenderContext, f: &Frame, a: &Arc, cache: bool) { let opacity = self.opacity_of(a); - let layered = !f.opts.outline && (opacity < 1.0 || a.blend != vectorcraft_doc::color::BlendMode::Normal || a.isolate); - if layered { - ctx.set_transform(Affine::IDENTITY); - ctx.push_layer(None, Some(blend_mode(a.blend)), Some(opacity), None, None); + if !f.opts.outline && (opacity < 1.0 || a.blend != vectorcraft_doc::color::BlendMode::Normal || a.isolate) { + let blends = self.blends_through(a); + let bounds = if blends { self.bounds_of(a) } else { None }; + let comp = crate::group::Composite { blend: a.blend, opacity, isolated: a.isolate, blends, bounds, ..Default::default() }; + self.group(ctx, f, comp, &mut |r, c, fr| r.draw_object_fx_art(c, fr, a, cache)); + } else { + self.draw_object_fx_art(ctx, f, a, cache); } + self.stats.drawn += 1; + } + + /// What [`Self::draw_object_fx`] draws inside the object's transparency group. + fn draw_object_fx_art(&mut self, ctx: &mut RenderContext, f: &Frame, a: &Arc, cache: bool) { let art = self.fx_art(f.doc, a, cache); let rfx = effects::raster_effects(&a.appearance.effects); match cull_bounds(&art) { @@ -363,10 +371,6 @@ impl Renderer { } _ => self.draw_node(ctx, f, &art, true), } - if layered { - ctx.pop_layer(); - } - self.stats.drawn += 1; } /// The art [`Self::draw_object_fx`] draws for `a` (cached by `Arc` identity when `cache`): @@ -535,7 +539,7 @@ impl Renderer { draw: impl FnOnce(&mut Self, &mut RenderContext, &Frame, Option<(vectorcraft_doc::color::BlendMode, f32)>), ) { if !f.mt { - return draw(self, ctx, f, composite); + return self.inside_layer(|r| draw(r, ctx, f, composite)); } // 3σ of the Gaussian (σ = blur / 2) in pixels, plus a pixel of antialiasing. let spread = blur.max(0.0) * 1.5 / f.px + 2.0; @@ -549,7 +553,7 @@ impl Renderer { let (w, h) = (w as u16, h as u16); let mut off = crate::single_threaded_context(w, h); let shifted = Frame { mt: false, view: Affine::translate((-x0, -y0)) * f.view, ..*f }; - draw(self, &mut off, &shifted, None); + self.inside_layer(|r| draw(r, &mut off, &shifted, None)); off.flush(); let mut pm = vello_cpu::Pixmap::new(w, h); off.render(&mut pm, &mut self.resources); @@ -558,13 +562,10 @@ impl Renderer { ctx.set_transform(Affine::IDENTITY); ctx.push_layer(None, Some(blend_mode(m)), Some(o), None, None); } - ctx.set_transform(Affine::translate((x0, y0))); - ctx.set_paint(vello_cpu::Image { image: vello_cpu::ImageSource::Pixmap(std::sync::Arc::new(pm)), sampler: peniko::ImageSampler::default() }); - ctx.fill_rect(&Rect::new(0.0, 0.0, w as f64, h as f64)); + crate::group::draw_pixmap(ctx, std::sync::Arc::new(pm), (x0, y0)); if layered { ctx.pop_layer(); } - ctx.set_transform(Affine::IDENTITY); } /// Paint the fills and strokes of `n` on geometry `g`, applying per-item geometry effects and diff --git a/crates/render/src/group.rs b/crates/render/src/group.rs new file mode 100644 index 00000000..7703411d --- /dev/null +++ b/crates/render/src/group.rs @@ -0,0 +1,275 @@ +//! Transparency groups: groups with opacity or a blend mode, clip groups, opacity masks, the page +//! group. Most are vello layers, which are isolated (their content starts from transparency). A +//! non-isolated group whose content blends is drawn offscreen over a copy of its backdrop, so its +//! children blend with the art below it, then mixed back in (backdrop-copy compositing). + +use std::sync::Arc; + +use vectorcraft_color::BlendMode as Blend; +use vectorcraft_doc::Node; +use vectorcraft_geom::{Affine, BezPath, FillRule, Rect}; +use vello_cpu::peniko::{self, BlendMode, Compose, Mix}; +use vello_cpu::{Pixmap, RenderContext}; + +use crate::{Frame, Renderer, blend_mode, fill_rule, single_threaded_context}; + +/// How a group composites onto what is below it. +pub(crate) struct Composite<'a> { + /// Clipping path (document space). + pub clip: Option<(&'a BezPath, FillRule)>, + pub blend: Blend, + pub opacity: f32, + /// Opacity mask (the context's size). + pub mask: Option, + /// The content starts from transparency instead of from the art below. + pub isolated: bool, + /// Blending inside reaches the group's backdrop ([`Node::blends_through`]). + pub blends: bool, + /// Area the content covers (document space); `None` = anywhere. + pub bounds: Option, +} + +impl Default for Composite<'_> { + fn default() -> Self { + Self { clip: None, blend: Blend::Normal, opacity: 1.0, mask: None, isolated: false, blends: false, bounds: None } + } +} + +/// Group content drawn into a context (called once, or twice for a non-isolated group with a blend +/// mode: over the backdrop copy, then alone for its shape). +pub(crate) type Content<'d> = dyn FnMut(&mut Renderer, &mut RenderContext, &Frame) + 'd; + +/// A pixel region of a context: origin and size. +#[derive(Clone, Copy)] +struct Region { + x: u16, + y: u16, + w: u16, + h: u16, +} + +impl Renderer { + /// Draw a group's content with `draw` and composite it as `c` says. Blending content is drawn + /// offscreen: over a copy of the backdrop when the group isn't isolated (possible only with + /// no layer open around it, else it is drawn isolated), from transparency when it is (so + /// non-isolated groups inside can copy their backdrop). + pub(crate) fn group(&mut self, ctx: &mut RenderContext, f: &Frame, c: Composite, draw: &mut Content) { + if c.blends + && !c.isolated + && c.opacity >= 1.0 + && c.blend == Blend::Normal + && c.mask.is_none() + && let Some((path, rule)) = c.clip + { + // A plain clip clips each drawing instead of compositing a layer: blending inside + // reaches the art below directly. + ctx.set_transform(f.view); + ctx.set_fill_rule(fill_rule(rule)); + ctx.push_clip_path(path); + self.clip_paths.push((path.clone(), rule, f.view)); + draw(self, ctx, f); + self.clip_paths.pop(); + ctx.pop_clip_path(); + return; + } + if c.blends && (c.isolated || self.nested == 0) { + return self.group_offscreen(ctx, f, c, draw); + } + ctx.set_transform(f.view); + if let Some((_, rule)) = c.clip { + ctx.set_fill_rule(fill_rule(rule)); + } + ctx.push_layer(c.clip.map(|(p, _)| p), Some(blend_mode(c.blend)), Some(c.opacity), c.mask, None); + self.nested += 1; + // The layer starts from transparency: no backdrop for the content. + let backdrop = self.backdrop.take(); + draw(self, ctx, f); + self.backdrop = backdrop; + self.nested -= 1; + ctx.pop_layer(); + } + + fn group_offscreen(&mut self, ctx: &mut RenderContext, f: &Frame, c: Composite, draw: &mut Content) { + let Composite { clip, blend, opacity, mask, isolated, bounds, .. } = c; + let Some(r) = region(ctx, f, bounds) else { return }; + let view = Affine::translate((-(r.x as f64), -(r.y as f64))) * f.view; + let visible = view.inverse().transform_rect_bbox(Rect::new(0.0, 0.0, r.w as f64, r.h as f64)); + let sub = Frame { mt: false, view, visible, ..*f }; + let backdrop = (!isolated).then(|| self.flatten(ctx, r)); + let content = self.offscreen(r, &sub, backdrop.clone(), draw); + let at = (r.x as f64, r.y as f64); + let push = |ctx: &mut RenderContext, mode: BlendMode, mask: Option| { + ctx.set_transform(f.view); + if let Some((_, rule)) = clip { + ctx.set_fill_rule(fill_rule(rule)); + } + ctx.push_layer(clip.map(|(p, _)| p), Some(mode), Some(opacity), mask, None); + }; + match backdrop { + // The backdrop under the content, mixed with it by opacity, mask and clip: take that + // share of the backdrop out, then add the same share of the content. + Some(_) if blend == Blend::Normal => { + push(ctx, BlendMode::new(Mix::Normal, Compose::DestOut), mask.clone()); + ctx.set_transform(Affine::IDENTITY); + ctx.set_paint(peniko::Color::BLACK); + ctx.fill_rect(&Rect::new(at.0, at.1, at.0 + r.w as f64, at.1 + r.h as f64)); + ctx.pop_layer(); + push(ctx, BlendMode::new(Mix::Normal, Compose::Plus), mask); + draw_pixmap(ctx, Arc::new(content), at); + } + // A blend mode applies to the group as an object of its own: take the backdrop's share + // out of the content (it needs the content's own coverage), then blend the rest. + Some(b) => { + let alone = self.offscreen(r, &sub, None, draw); + push(ctx, blend_mode(blend), mask); + draw_pixmap(ctx, Arc::new(remove_backdrop(content, &alone, &b)), at); + } + None => { + push(ctx, blend_mode(blend), mask); + draw_pixmap(ctx, Arc::new(content), at); + } + } + ctx.pop_layer(); + } + + /// Render what `ctx` holds so far, and start it again from that picture (so later drawing sees + /// it unchanged). Returns the pixels of `r`. + fn flatten(&mut self, ctx: &mut RenderContext, r: Region) -> Arc { + ctx.flush(); + let mut all = Pixmap::new(ctx.width(), ctx.height()); + ctx.render(&mut all, &mut self.resources); + ctx.reset(); + let crop = if (r.x, r.y, r.w, r.h) == (0, 0, all.width(), all.height()) { + None + } else { + let mut out = Pixmap::new(r.w, r.h); + let (src_w, w) = (all.width() as usize, r.w as usize); + for row in 0..r.h as usize { + let from = (r.y as usize + row) * src_w + r.x as usize; + out.data_mut()[row * w..(row + 1) * w].copy_from_slice(&all.data()[from..from + w]); + } + Some(Arc::new(out)) + }; + let all = Arc::new(all); + draw_pixmap(ctx, all.clone(), (0.0, 0.0)); + for (path, rule, xf) in &self.clip_paths { + ctx.set_transform(*xf); + ctx.set_fill_rule(fill_rule(*rule)); + ctx.push_clip_path(path); + } + crop.unwrap_or(all) + } + + /// `draw` rendered into a new context of region `r` (frame `sub`), over `backdrop` if any. + fn offscreen(&mut self, r: Region, sub: &Frame, backdrop: Option>, draw: &mut Content) -> Pixmap { + let mut ctx = single_threaded_context(r.w, r.h); + if let Some(b) = &backdrop { + draw_pixmap(&mut ctx, b.clone(), (0.0, 0.0)); + } + let outer = (std::mem::replace(&mut self.nested, 0), std::mem::replace(&mut self.backdrop, backdrop), std::mem::take(&mut self.clip_paths)); + draw(self, &mut ctx, sub); + (self.nested, self.backdrop, self.clip_paths) = outer; + ctx.flush(); + let mut pm = Pixmap::new(r.w, r.h); + ctx.render(&mut pm, &mut self.resources); + pm + } + + /// Run `draw` inside layers (or into another context) it opens itself: groups drawn there can't + /// copy their backdrop, and see none. + pub(crate) fn inside_layer(&mut self, draw: impl FnOnce(&mut Self) -> T) -> T { + self.nested += 1; + let backdrop = self.backdrop.take(); + let out = draw(self); + self.backdrop = backdrop; + self.nested -= 1; + out + } + + /// Whether blending inside `n` reaches its backdrop ([`Node::blends_through`], cached per + /// container). + pub(crate) fn blends_through(&mut self, n: &Node) -> bool { + n.blends_through_with(&mut |c| self.blends_of(c)) + } + + /// [`Self::blends_through`] of the group `children` make up. + pub(crate) fn children_blend(&mut self, children: &[Arc]) -> bool { + Node::children_blend(children, &mut |c| self.blends_of(c)) + } + + fn blends_of(&mut self, a: &Arc) -> bool { + if !a.is_container() { + return a.blends_through(); + } + let key = Arc::as_ptr(a) as usize; + if let Some(e) = self.blends.get_mut(&key) + && Arc::ptr_eq(&e.0, a) + { + e.2 = self.stamp; + return e.1; + } + let v = a.blends_through_with(&mut |c| self.blends_of(c)); + if self.blends.len() > 1024 { + let g = self.stamp; + self.blends.retain(|_, e| g - e.2 <= 3); + } + self.blends.insert(key, (a.clone(), v, self.stamp)); + v + } + + /// Draw knockout element `c` in a layer composited with `compose`: as its knockout shape + /// (`DestOut` erases what the elements below drew there, `DestIn` keeps only that part), or + /// as itself (`Plus` adds it). In a non-isolated knockout group (`backdrop`), the element is + /// laid over the group's backdrop and cut to its shape, so it composites against the art + /// below the group instead of the elements below it. + pub(crate) fn knockout_pass(&mut self, ctx: &mut RenderContext, f: &Frame, c: &Arc, compose: Compose, backdrop: Option<&Arc>) { + ctx.set_transform(Affine::IDENTITY); + ctx.push_layer(None, Some(BlendMode::new(Mix::Normal, compose)), None, None, None); + self.nested += 1; + if let Some(b) = backdrop { + draw_pixmap(ctx, b.clone(), (0.0, 0.0)); + } + let shape = compose != Compose::Plus && !c.knockout_shape; + self.shape_of = if shape { Arc::as_ptr(c) as usize } else { 0 }; + self.draw_arc(ctx, f, c); + self.shape_of = 0; + if backdrop.is_some() { + self.knockout_pass(ctx, f, c, Compose::DestIn, None); + } + self.nested -= 1; + ctx.pop_layer(); + } +} + +/// Draw `pm` with its top-left corner at pixel `at` (whole pixels: copied exactly). +pub(crate) fn draw_pixmap(ctx: &mut RenderContext, pm: Arc, at: (f64, f64)) { + let (w, h) = (pm.width() as f64, pm.height() as f64); + ctx.set_transform(Affine::translate(at)); + ctx.set_paint(vello_cpu::Image { image: vello_cpu::ImageSource::Pixmap(pm), sampler: peniko::ImageSampler::default() }); + ctx.fill_rect(&Rect::new(0.0, 0.0, w, h)); + ctx.set_transform(Affine::IDENTITY); +} + +/// The pixel region of `ctx` that `bounds` (document space) covers, with a margin for +/// antialiasing; `None` when it is off the context. +fn region(ctx: &RenderContext, f: &Frame, bounds: Option) -> Option { + let full = Rect::new(0.0, 0.0, ctx.width() as f64, ctx.height() as f64); + let r = match bounds { + Some(b) => f.view.transform_rect_bbox(b).inflate(2.0, 2.0).intersect(full), + None => full, + }; + let (x0, y0, x1, y1) = (r.x0.floor().max(0.0), r.y0.floor().max(0.0), r.x1.ceil().min(full.x1), r.y1.ceil().min(full.y1)); + (x1 > x0 && y1 > y0).then_some(Region { x: x0 as u16, y: y0 as u16, w: (x1 - x0) as u16, h: (y1 - y0) as u16 }) +} + +/// The group's own colour from `content` (the group drawn over `backdrop`) and `alone` (drawn +/// over transparency, for its coverage): content = group + (1 − group alpha) × backdrop, all +/// premultiplied. +fn remove_backdrop(mut content: Pixmap, alone: &Pixmap, backdrop: &Pixmap) -> Pixmap { + for ((c, a), b) in content.data_mut().iter_mut().zip(alone.data()).zip(backdrop.data()) { + let keep = 255 - a.a as u32; + let sub = |v: u8, bv: u8| (v as u32).saturating_sub((keep * bv as u32 + 127) / 255).min(a.a as u32) as u8; + (c.r, c.g, c.b, c.a) = (sub(c.r, b.r), sub(c.g, b.g), sub(c.b, b.b), a.a); + } + content +} diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs index d4181963..9eda6757 100644 --- a/crates/render/src/lib.rs +++ b/crates/render/src/lib.rs @@ -8,6 +8,7 @@ mod brush_fx; mod fx; +mod group; mod live; mod paint; mod pattern; @@ -23,6 +24,8 @@ use vello_cpu::kurbo; use vello_cpu::peniko::{self, BlendMode, Compose, Mix}; use vello_cpu::{Pixmap, RenderContext, Resources}; +use group::Composite; + pub use effects::stroke::width_outline; pub use live::expand_live; pub use pattern::render_pattern_swatch; @@ -237,6 +240,17 @@ pub struct Renderer { shape_of: usize, /// The art drawn for objects with effects that apply through it (see `fx::has_object_fx`). fx_arts: PtrMap, Arc)>, + /// Layers open around the drawing point in the current context: a non-isolated group can copy + /// its backdrop only when there are none (see [`Self::group`]). + nested: u32, + /// Copy of the backdrop of the non-isolated group being drawn offscreen, in its context's + /// pixels: the elements of a non-isolated knockout group composite against it. + backdrop: Option>, + /// [`Node::blends_through`] per container, keyed like `geom`. + blends: PtrMap, bool, u64)>, + /// Clip paths pushed on the current context (path, rule, transform): starting the context + /// again from a picture of it pushes them again (see [`Self::group`]). + clip_paths: Vec<(BezPath, FillRule, Affine)>, } #[derive(Clone, Copy, Debug, Default)] @@ -287,6 +301,10 @@ impl Renderer { knockout: false, shape_of: 0, fx_arts: PtrMap::default(), + nested: 0, + backdrop: None, + blends: PtrMap::default(), + clip_paths: vec![], } } @@ -327,40 +345,18 @@ impl Renderer { } } self.stamp += 1; - let trim = opts.trim && !doc.artboards.is_empty(); - if trim { + (self.nested, self.backdrop) = (0, None); + self.clip_paths.clear(); + if opts.trim && !doc.artboards.is_empty() { let mut clip = BezPath::new(); for ab in &doc.artboards { clip.extend(ab.rect.path_elements(0.1)); } - ctx.set_transform(view); - ctx.push_clip_layer(&clip); - } - if !self.draw_pattern_edit(&mut ctx, &frame) { - // While editing an opacity mask its art is seen only through the mask (Illustrator). - let mask_layer = doc.mask_edit.map(|m| m.layer); - let layers = doc.layers.iter().filter(|l| Some(l.id) != mask_layer); - // Page Isolated Blending / Page Knockout Group: the page is a group of its own. - let page_group = !opts.outline && (doc.page_isolate || doc.page_knockout); - self.knockout = page_group && doc.page_knockout; - if page_group { - ctx.set_transform(Affine::IDENTITY); - ctx.push_layer(None, None, None, None, None); - } - if self.knockout { - self.draw_knockout(&mut ctx, &frame, &layers.cloned().collect::>()); - } else { - for layer in layers { - self.draw_arc(&mut ctx, &frame, layer); - } - } - if page_group { - ctx.pop_layer(); - } - self.knockout = false; - } - if trim { - ctx.pop_layer(); + let blends = self.children_blend(&doc.layers); + let trim = Composite { clip: Some((&clip, FillRule::NonZero)), blends, ..Default::default() }; + self.group(&mut ctx, &frame, trim, &mut |r, c, fr| r.draw_page(c, fr)); + } else { + self.draw_page(&mut ctx, &frame); } // Drop cache entries not seen for a few frames. let g = self.stamp; @@ -387,6 +383,32 @@ impl Renderer { Rendered { width: w as u32, height: h as u32, pixels } } + /// The page's art: the layers (or the pattern being edited), inside the page group when the + /// page has one. + fn draw_page(&mut self, ctx: &mut RenderContext, f: &Frame) { + if self.draw_pattern_edit(ctx, f) { + return; + } + let doc = f.doc; + // While editing an opacity mask its art is seen only through the mask. + let mask_layer = doc.mask_edit.map(|m| m.layer); + let layers: Vec> = doc.layers.iter().filter(|l| Some(l.id) != mask_layer).cloned().collect(); + // Page Isolated Blending / Page Knockout Group: the page is a group of its own. + let page_group = !f.opts.outline && (doc.page_isolate || doc.page_knockout); + let knockout = page_group && doc.page_knockout; + let mut draw = |r: &mut Self, c: &mut RenderContext, fr: &Frame| { + r.knockout = knockout; + r.draw_children(c, fr, &layers, knockout); + r.knockout = false; + }; + if page_group { + let blends = self.children_blend(&layers); + self.group(ctx, f, Composite { isolated: doc.page_isolate, blends, ..Default::default() }, &mut draw); + } else { + draw(self, ctx, f); + } + } + /// Render one artboard (or any document rect) at `scale` pixels per point, transparent or on white, /// as exported: template layers are left out. pub fn render_region(&mut self, doc: &Document, region: Rect, scale: f64, white: bool) -> Rendered { @@ -415,7 +437,8 @@ impl Renderer { ctx.fill_rect(&kurbo::Rect::new(0.0, 0.0, w as f64, w as f64)); } let frame = Frame { mt: false, doc, view, visible: b.inflate(1.0, 1.0), px: 1.0 / s, opts: &RenderOptions::default() }; - self.knockout = false; + (self.knockout, self.nested, self.backdrop) = (false, 0, None); + self.clip_paths.clear(); self.draw_node(&mut ctx, &frame, n, true); ctx.flush(); let mut pm = Pixmap::new(w, w); @@ -508,11 +531,11 @@ impl Renderer { && !f.opts.outline && !self.is_shape(a) { - let mask = self.opacity_mask(f, m, ctx.width(), ctx.height()); - ctx.set_transform(Affine::IDENTITY); - ctx.push_layer(None, None, None, Some(mask), None); - self.draw_arc_body(ctx, f, a); - ctx.pop_layer(); + // A masked object is a non-isolated group of its own. + let mask = Some(self.opacity_mask(f, m, ctx.width(), ctx.height())); + let blends = a.blend != vectorcraft_color::BlendMode::Normal || (!a.isolate && self.blends_through(a)); + let bounds = if blends { self.bounds_of(a) } else { None }; + self.group(ctx, f, Composite { mask, blends, bounds, ..Default::default() }, &mut |r, c, fr| r.draw_arc_body(c, fr, a)); return; } self.draw_arc_body(ctx, f, a); @@ -522,9 +545,10 @@ impl Renderer { fn opacity_mask(&mut self, f: &Frame, m: &vectorcraft_doc::OpacityMask, w: u16, h: u16) -> vello_cpu::Mask { let mut mctx = single_threaded_context(w, h); // Mask art is a picture of its own: it takes no part in a knockout group around the object. - let knockout = std::mem::take(&mut self.knockout); + let outer = + (std::mem::take(&mut self.knockout), std::mem::take(&mut self.nested), self.backdrop.take(), std::mem::take(&mut self.clip_paths)); self.draw_node(&mut mctx, &Frame { mt: false, ..*f }, &m.art, true); - self.knockout = knockout; + (self.knockout, self.nested, self.backdrop, self.clip_paths) = outer; mctx.flush(); let mut pm = Pixmap::new(w, h); mctx.render(&mut pm, &mut self.resources); @@ -598,45 +622,42 @@ impl Renderer { return self.draw_object_fx(ctx, f, &Arc::new(n.clone()), false); } let outline = f.opts.outline; - let mut layers = 0; let template_dim = matches!(n.kind, NodeKind::Layer { template: true, .. }) && f.opts.dim_templates; let opacity = if template_dim { self.opacity_of(n) * 0.5 } else { self.opacity_of(n) }; - // Whether this container's children knock each other out (a knockout group is isolated). + // Whether this container's children knock each other out. let knockout = !outline && n.knocks_out(self.knockout); let enclosing = std::mem::replace(&mut self.knockout, knockout); if !outline && (opacity < 1.0 || n.blend != vectorcraft_color::BlendMode::Normal || n.isolate || knockout) { - ctx.set_transform(Affine::IDENTITY); - ctx.push_layer(None, Some(blend_mode(n.blend)), Some(opacity), None, None); - layers += 1; + let blends = self.blends_through(n); + let bounds = if blends { self.node_bounds(n) } else { None }; + let comp = Composite { blend: n.blend, opacity, isolated: n.isolate, blends, bounds, ..Default::default() }; + self.group(ctx, f, comp, &mut |r, c, fr| r.draw_content(c, fr, n, knockout)); + } else { + self.draw_content(ctx, f, n, knockout); } + self.knockout = enclosing; + self.stats.drawn += 1; + } + + /// What `n` draws inside its transparency group (`knockout`: its children knock each other out). + fn draw_content(&mut self, ctx: &mut RenderContext, f: &Frame, n: &Node, knockout: bool) { match &n.kind { - NodeKind::Layer { children, .. } | NodeKind::Group { children, clip: false } if knockout => self.draw_knockout(ctx, f, children), - NodeKind::Layer { children, .. } | NodeKind::Group { children, clip: false } => { - for c in children { - self.draw_arc(ctx, f, c); - } - } - NodeKind::Group { children, clip: true } if outline => { + NodeKind::Layer { children, .. } | NodeKind::Group { children, clip: false } => self.draw_children(ctx, f, children, knockout), + NodeKind::Group { children, clip: true } if f.opts.outline => { for c in children { self.draw_node(ctx, f, c, false); } } NodeKind::Group { children, clip: true } => { - // Nothing to clip by hides the clipped art (as in the SVG and PDF output). + // Nothing to clip by hides the clipped art (as in the SVG and PDF output). A clip + // group doesn't isolate: blending inside it reaches the art below. if let Some((clip, rest)) = children.split_first() && let Some(region) = self.clip_of(clip) { - ctx.set_transform(f.view); - ctx.set_fill_rule(fill_rule(region.1)); - ctx.push_clip_layer(®ion.0); - if knockout { - self.draw_knockout(ctx, f, rest); - } else { - for c in rest { - self.draw_arc(ctx, f, c); - } - } - ctx.pop_layer(); + let blends = self.blends_through(n); + let bounds = if blends { Some(region.0.bounding_box()) } else { None }; + let comp = Composite { clip: Some((®ion.0, region.1)), blends, bounds, ..Default::default() }; + self.group(ctx, f, comp, &mut |r, c, fr| r.draw_children(c, fr, rest, knockout)); } } NodeKind::Path { path, rule, guide, .. } => { @@ -667,10 +688,25 @@ impl Renderer { } NodeKind::Blend { .. } | NodeKind::Envelope { .. } | NodeKind::Mesh(_) | NodeKind::Repeat(_) => self.draw_live_node(ctx, f, n), } - self.knockout = enclosing; - self.stats.drawn += 1; - for _ in 0..layers { - ctx.pop_layer(); + } + + /// The children of a group: as the elements of a knockout group when `knockout`. + fn draw_children(&mut self, ctx: &mut RenderContext, f: &Frame, children: &[Arc], knockout: bool) { + if knockout { + self.draw_knockout(ctx, f, children); + } else { + for c in children { + self.draw_arc(ctx, f, c); + } + } + } + + /// Cull bounds of `n`: cached when it is a node of the tree being drawn. + fn node_bounds(&mut self, n: &Node) -> Option { + match self.geom.get(&(n as *const Node as usize)) { + // The entry keeps its node alive, so the address is that node's. + Some(e) if std::ptr::eq(Arc::as_ptr(&e.node), n) => e.bounds, + _ => fx::cull_bounds(n), } } @@ -678,21 +714,18 @@ impl Renderer { /// what the elements below it drew wherever it paints (its knockout shape: its coverage at full /// object opacity without its opacity mask, or as drawn when its opacity and mask define the /// knockout shape), then adds itself: it composites against the group's backdrop instead of - /// over the elements below it. + /// over the elements below it (the art below the group when the group is non-isolated and + /// drawn over a copy of it, see [`Self::group`]). fn draw_knockout(&mut self, ctx: &mut RenderContext, f: &Frame, children: &[Arc]) { + let backdrop = self.backdrop.take(); for c in Node::knockout_elements(children) { if self.skipped(f, c) { continue; } - for (compose, shape) in [(Compose::DestOut, !c.knockout_shape), (Compose::Plus, false)] { - ctx.set_transform(Affine::IDENTITY); - ctx.push_layer(None, Some(BlendMode::new(Mix::Normal, compose)), None, None, None); - self.shape_of = if shape { Arc::as_ptr(c) as usize } else { 0 }; - self.draw_arc(ctx, f, c); - self.shape_of = 0; - ctx.pop_layer(); - } + self.knockout_pass(ctx, f, c, Compose::DestOut, None); + self.knockout_pass(ctx, f, c, Compose::Plus, backdrop.as_ref()); } + self.backdrop = backdrop; } /// Whether `n` is the knockout element being drawn as its shape (see [`Self::draw_knockout`]). @@ -1106,6 +1139,8 @@ mod tests_blend; #[cfg(test)] mod tests_clip; #[cfg(test)] +mod tests_isolation; +#[cfg(test)] mod tests_knockout; #[cfg(test)] mod tests_objectfx; diff --git a/crates/render/src/live.rs b/crates/render/src/live.rs index d4e7ed7a..1d1a1f7e 100644 --- a/crates/render/src/live.rs +++ b/crates/render/src/live.rs @@ -11,11 +11,11 @@ use std::sync::Arc; use vectorcraft_doc::live::{self, GradientMesh, MeshQuad}; use vectorcraft_doc::{Node, NodeKind}; -use vectorcraft_geom::{Affine, BezPath, PathData, Point}; +use vectorcraft_geom::{BezPath, PathData, Point}; use vello_cpu::RenderContext; use vello_cpu::peniko; -use crate::{Frame, Renderer, blend_mode, text_geom}; +use crate::{Frame, Renderer, text_geom}; type Expanded = Arc>>; type MeshEntry = (Arc, Arc>, u64); @@ -113,14 +113,13 @@ impl Renderer { let stamp = self.stamp; self.live.tick(stamp); let opacity = self.opacity_of(a); - let layered = !f.opts.outline && (opacity < 1.0 || a.blend != vectorcraft_color::BlendMode::Normal || a.isolate); - if layered { - ctx.set_transform(Affine::IDENTITY); - ctx.push_layer(None, Some(blend_mode(a.blend)), Some(opacity), None, None); - } - self.draw_live_body(ctx, f, a, true); - if layered { - ctx.pop_layer(); + if !f.opts.outline && (opacity < 1.0 || a.blend != vectorcraft_color::BlendMode::Normal || a.isolate) { + let blends = self.blends_through(a); + let bounds = if blends { self.bounds_of(a) } else { None }; + let comp = crate::group::Composite { blend: a.blend, opacity, isolated: a.isolate, blends, bounds, ..Default::default() }; + self.group(ctx, f, comp, &mut |r, c, fr| r.draw_live_body(c, fr, a, true)); + } else { + self.draw_live_body(ctx, f, a, true); } self.stats.drawn += 1; } diff --git a/crates/render/src/pattern.rs b/crates/render/src/pattern.rs index 714696a5..8ca8fc09 100644 --- a/crates/render/src/pattern.rs +++ b/crates/render/src/pattern.rs @@ -183,17 +183,15 @@ impl Renderer { let children: Vec> = layer.children().cloned().unwrap_or_default(); if layer.visible && !children.is_empty() { let dim = (def.dim_copies / 100.0).clamp(0.0, 1.0); - ctx.set_transform(Affine::IDENTITY); - ctx.push_layer(None, None, Some(dim), None, None); - for o in def.preview_offsets() { - let view = f.view * Affine::translate(o); - let visible = f.visible - o; - let frame = Frame { view, visible, ..*f }; - for c in &children { - self.draw_arc(ctx, &frame, c); + let comp = crate::group::Composite { opacity: dim, ..Default::default() }; + self.group(ctx, f, comp, &mut |r, c, fr| { + for o in def.preview_offsets() { + let frame = Frame { view: fr.view * Affine::translate(o), visible: fr.visible - o, ..*fr }; + for a in &children { + r.draw_arc(c, &frame, a); + } } - } - ctx.pop_layer(); + }); } self.draw_arc(ctx, f, layer); if def.show_tile_edge { diff --git a/crates/render/src/tests_isolation.rs b/crates/render/src/tests_isolation.rs new file mode 100644 index 00000000..5494eefb --- /dev/null +++ b/crates/render/src/tests_isolation.rs @@ -0,0 +1,215 @@ +//! Non-isolated transparency groups: blending inside a group with opacity or a blend mode reaches +//! the art below the group unless Isolate Blending is on (checked against the reference formulas). + +use super::*; +use vectorcraft_color::blend::{blend_rgb, composite}; +use vectorcraft_color::{BlendMode as Blend, Color, Paint}; +use vectorcraft_doc::{Appearance, Knockout, Node}; +use vectorcraft_geom::shapes; + +/// The backdrop colour (a full-page rectangle) and the blended child's colour. +const B: [f32; 3] = [0.8, 0.6, 0.2]; +const S: [f32; 3] = [0.5, 0.5, 1.0]; + +fn rect(d: &mut Document, r: Rect, c: [f32; 3]) -> Node { + Node::path(d.alloc_id(), shapes::rectangle(r), Appearance::basic(Paint::solid(Color::rgb(c[0], c[1], c[2])), Paint::None, 0.0)) +} + +/// A Multiply rectangle at 20..80 (the group's content). +fn multiply(d: &mut Document) -> Node { + let mut n = rect(d, Rect::new(20.0, 20.0, 80.0, 80.0), S); + n.blend = Blend::Multiply; + n +} + +/// The backdrop, then `top` (built by `make`), in a 100 × 100 document. +fn doc(make: impl FnOnce(&mut Document) -> Node) -> Document { + let mut d = Document::new(100.0, 100.0); + let below = rect(&mut d, Rect::new(0.0, 0.0, 100.0, 100.0), B); + let top = make(&mut d); + let l = d.layers[0].id; + d.insert(Some(l), usize::MAX, below).unwrap(); + d.insert(Some(l), usize::MAX, top).unwrap(); + d +} + +/// A group of `children` with `opacity`, `blend` and isolation. +fn group(d: &mut Document, children: Vec, opacity: f32, blend: Blend, isolate: bool) -> Node { + let mut g = Node::group(d.alloc_id(), children.into_iter().map(Arc::new).collect()); + (g.opacity, g.blend, g.isolate) = (opacity, blend, isolate); + g +} + +fn render_with(r: &mut Renderer, d: &Document, opts: &RenderOptions) -> Rendered { + r.render(d, 100, 100, Affine::IDENTITY, opts) +} + +fn render(d: &Document) -> Rendered { + render_with(&mut Renderer::new(), d, &RenderOptions::default()) +} + +fn rgb(p: [u8; 4]) -> [u8; 3] { + [p[0], p[1], p[2]] +} + +fn to8(c: [f32; 3]) -> [u8; 3] { + c.map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8) +} + +fn lerp(a: [f32; 3], b: [f32; 3], t: f32) -> [f32; 3] { + [0, 1, 2].map(|i| a[i] + (b[i] - a[i]) * t) +} + +fn assert_near(got: [u8; 4], want: [f32; 3], what: &str) { + let w = to8(want); + assert!(rgb(got).iter().zip(w).all(|(a, b)| (*a as i32 - b as i32).abs() <= 2) && got[3] == 255, "{what}: {got:?}, want {w:?}"); +} + +#[test] +fn a_multiply_child_of_a_half_opaque_group_multiplies_with_the_backdrop() { + let multiplied = blend_rgb(Blend::Multiply, B, S); + for isolate in [false, true] { + let d = doc(|d| { + let m = multiply(d); + group(d, vec![m], 0.5, Blend::Normal, isolate) + }); + let r = render(&d); + // Non-isolated: the child multiplies with the backdrop, then the group is half opaque. + // Isolated: the child multiplies with nothing, so the group shows its plain colour. + let inside = if isolate { lerp(B, S, 0.5) } else { lerp(B, multiplied, 0.5) }; + assert_near(r.pixel(50, 50), inside, &format!("isolate {isolate}")); + assert_near(r.pixel(10, 10), B, "outside the group"); + } +} + +#[test] +fn a_group_blend_mode_applies_again_to_the_non_isolated_result() { + // The child (opaque) multiplies with the backdrop; the group then screens that result onto the + // backdrop at 60%. + let d = doc(|d| { + let m = multiply(d); + group(d, vec![m], 0.6, Blend::Screen, false) + }); + let g = blend_rgb(Blend::Multiply, B, S); + let o = composite(Blend::Screen, [B[0], B[1], B[2], 1.0], [g[0], g[1], g[2], 0.6]); + assert_near(render(&d).pixel(50, 50), [o[0], o[1], o[2]], "screened multiply"); +} + +#[test] +fn a_clip_group_does_not_isolate_its_children() { + let d = doc(|d| { + let clip = rect(d, Rect::new(30.0, 30.0, 70.0, 70.0), [0.0; 3]); + let m = multiply(d); + Node::new(d.alloc_id(), NodeKind::Group { children: vec![Arc::new(clip), Arc::new(m)], clip: true }) + }); + let r = render(&d); + assert_near(r.pixel(50, 50), blend_rgb(Blend::Multiply, B, S), "inside the clip"); + assert_near(r.pixel(25, 25), B, "clipped away"); +} + +#[test] +fn a_non_isolated_group_inside_a_clip_group_stays_clipped() { + // The half-opaque group copies its backdrop while the clip is in force: the clip still applies + // to it and to what follows. + let d = doc(|d| { + let clip = rect(d, Rect::new(30.0, 30.0, 70.0, 70.0), [0.0; 3]); + let m = multiply(d); + let g = group(d, vec![m], 0.5, Blend::Normal, false); + let after = rect(d, Rect::new(0.0, 60.0, 100.0, 100.0), S); + let children = [clip, g, after].into_iter().map(Arc::new).collect(); + Node::new(d.alloc_id(), NodeKind::Group { children, clip: true }) + }); + let r = render(&d); + assert_near(r.pixel(50, 40), lerp(B, blend_rgb(Blend::Multiply, B, S), 0.5), "inside the clip"); + assert_near(r.pixel(25, 50), B, "group clipped away"); + assert_near(r.pixel(50, 65), S, "later art inside the clip"); + assert_near(r.pixel(50, 85), B, "later art clipped away"); +} + +#[test] +fn a_masked_object_blends_with_the_backdrop() { + let d = doc(|d| { + let m = multiply(d); + let mut g = group(d, vec![m], 1.0, Blend::Normal, false); + // A 50% grey mask over the whole group. + let art = rect(d, Rect::new(0.0, 0.0, 100.0, 100.0), [0.5; 3]); + g.mask = Some(Box::new(vectorcraft_doc::OpacityMask::new(art, true))); + g + }); + assert_near(render(&d).pixel(50, 50), lerp(B, blend_rgb(Blend::Multiply, B, S), 0.5), "masked multiply"); +} + +#[test] +fn a_non_isolated_group_inside_an_isolated_one_blends_with_its_siblings_below() { + // An isolated group holding a green square, then a 50% group with the Multiply child: the + // child multiplies with the green (the isolated group's own art), not with the backdrop. + const G: [f32; 3] = [0.2, 0.9, 0.4]; + let d = doc(|d| { + let green = rect(d, Rect::new(10.0, 10.0, 90.0, 90.0), G); + let m = multiply(d); + let inner = group(d, vec![m], 0.5, Blend::Normal, false); + group(d, vec![green, inner], 1.0, Blend::Normal, true) + }); + assert_near(render(&d).pixel(50, 50), lerp(G, blend_rgb(Blend::Multiply, G, S), 0.5), "multiplied with the sibling"); +} + +#[test] +fn a_non_isolated_knockout_group_composites_its_children_against_the_backdrop() { + // Two Multiply squares overlapping at 40..60 in a knockout group: in the overlap the top one + // multiplies with the backdrop only (it knocks out the one below). + const T: [f32; 3] = [1.0, 0.4, 0.6]; + for isolate in [false, true] { + let d = doc(|d| { + let mut lower = rect(d, Rect::new(10.0, 10.0, 60.0, 90.0), S); + let mut upper = rect(d, Rect::new(40.0, 10.0, 90.0, 90.0), T); + (lower.blend, upper.blend) = (Blend::Multiply, Blend::Multiply); + let mut g = group(d, vec![lower, upper], 1.0, Blend::Normal, isolate); + g.knockout = Knockout::On; + g + }); + let r = render(&d); + let (overlap, alone) = if isolate { (T, S) } else { (blend_rgb(Blend::Multiply, B, T), blend_rgb(Blend::Multiply, B, S)) }; + assert_near(r.pixel(50, 50), overlap, &format!("overlap, isolate {isolate}")); + assert_near(r.pixel(20, 50), alone, &format!("lower alone, isolate {isolate}")); + } +} + +#[test] +fn trim_view_page_group_and_threads_keep_the_non_isolated_look() { + let d = doc(|d| { + let m = multiply(d); + group(d, vec![m], 0.5, Blend::Normal, false) + }); + let want = lerp(B, blend_rgb(Blend::Multiply, B, S), 0.5); + let trim = RenderOptions { trim: true, ..Default::default() }; + assert_near(render_with(&mut Renderer::new(), &d, &trim).pixel(50, 50), want, "trim view"); + let mut paged = d.clone(); + paged.page_isolate = true; + assert_near(render(&paged).pixel(50, 50), want, "isolated page group"); + let mut threaded = Renderer::new(); + threaded.threads = 2; + let single = render(&d); + let multi = render_with(&mut threaded, &d, &RenderOptions::default()); + assert_eq!(single.pixels, multi.pixels, "multithreaded rendering copies the backdrop the same way"); +} + +#[test] +fn copying_the_backdrop_changes_nothing_without_blending() { + // A plain 50% group renders the same with or without an invisible blending group drawn first + // (which makes the renderer start again from a picture of the page and mix it back in). + let plain = doc(|d| { + let c = rect(d, Rect::new(20.0, 20.0, 80.0, 80.0), S); + group(d, vec![c], 0.5, Blend::Normal, false) + }); + let mut flattened = plain.clone(); + let m = multiply(&mut flattened); + let g = group(&mut flattened, vec![m], 0.5, Blend::Normal, false); + let l = flattened.layers[0].id; + // Behind everything but the backdrop, and fully transparent: only the copy happens. + let mut g = g; + g.children_mut().unwrap().iter_mut().for_each(|c| Arc::make_mut(c).opacity = 0.0); + flattened.insert(Some(l), 1, g).unwrap(); + let (a, b) = (render(&plain).pixels, render(&flattened).pixels); + let worst = a.iter().zip(&b).map(|(x, y)| (*x as i32 - *y as i32).abs()).max().unwrap(); + assert!(worst <= 1, "differs by {worst}/255"); +} diff --git a/docs/mcp.md b/docs/mcp.md index 102d6b40..d0291c19 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -203,8 +203,12 @@ neutral, the default). In a knockout group each child hides what it covers of th pass the enclosing group's setting to their children, off groups never knock out. `knockoutShape: true` makes the object's opacity and opacity mask scale how much it knocks out. `transparency.togglePageKnockoutGroup` and `transparency.togglePageIsolatedBlending` (`{value?}`) treat the whole page as a knockout or isolated group; they are -saved with the document and undoable, and `transparency.info` reports them. Knockout groups render as isolated groups; -PDF and SVG write them as soft-masked groups with the same look (the PDF export reports a warning). +saved with the document and undoable, and `transparency.info` reports them. PDF and SVG write knockout groups as +soft-masked groups with the same look (the PDF export reports a warning). + +Groups are not isolated unless Isolate Blending is on: a blend mode inside a group with opacity, a blend mode, an +opacity mask, knockout or a clip reaches the art below the group, on screen and in PDF (a knockout group's elements +then composite against the art below it). SVG has no non-isolated groups, so there such groups stay isolated. ## Clipping masks From 45ff33e144012c0590b6308eac999a1a8974b3be Mon Sep 17 00:00:00 2001 From: bflatastic Date: Mon, 5 Oct 2026 00:17:35 +0700 Subject: [PATCH 3/3] M3.75: layer clipping masks from the Layers panel button layer.clippingMask.toggle {id?} -> {clip}: the top object of the current layer (or of the one selected group, or of `id`) becomes the clipping path, unpainted and moved to the bottom so art added later is clipped too; pressing the button again releases the mask and leaves the path unpainted. One undo step. The Layers panel button runs it and underlines clipping-path names. Model: NodeKind::Layer.clip (skipped when false). Clipped layers render, hit test, bound, and export to SVG and PDF like clip groups (Node::clips / set_clips); the clip-path helpers are shared with Make/Release Clipping Mask. Co-Authored-By: Claude Opus 5.5 --- crates/doc/src/hit.rs | 4 +- crates/doc/src/node.rs | 27 +++++- crates/engine/src/cmd/layer.rs | 39 +++++++++ crates/engine/src/cmd/object.rs | 62 ++++++++------ crates/engine/src/lib.rs | 2 + crates/engine/src/tests_clip.rs | 14 +-- crates/engine/src/tests_layerclip.rs | 122 +++++++++++++++++++++++++++ crates/pdf/src/export.rs | 4 +- crates/render/src/fx.rs | 2 +- crates/render/src/lib.rs | 10 ++- crates/svg/src/export.rs | 4 +- crates/ui-egui/src/panels/layers.rs | 39 +++++++-- docs/mcp.md | 5 ++ 13 files changed, 279 insertions(+), 55 deletions(-) create mode 100644 crates/engine/src/tests_layerclip.rs diff --git a/crates/doc/src/hit.rs b/crates/doc/src/hit.rs index 4e1e2c54..84e46d0d 100644 --- a/crates/doc/src/hit.rs +++ b/crates/doc/src/hit.rs @@ -88,8 +88,8 @@ fn clip_contains(clip: &Node, p: Point) -> bool { fn hit_children(parent: &Node, p: Point, opt: HitOptions, chain: &mut Vec) -> Option { let children = parent.children()?; - // A clip group only hits inside its clipping path. - if let NodeKind::Group { clip: true, .. } = parent.kind + // A clip group (or a layer with a clipping mask) only hits inside its clipping path. + if parent.clips() && let Some(clip) = children.first() && !clip_contains(clip, p) { diff --git a/crates/doc/src/node.rs b/crates/doc/src/node.rs index 55a37261..7f6617e6 100644 --- a/crates/doc/src/node.rs +++ b/crates/doc/src/node.rs @@ -174,6 +174,9 @@ pub enum NodeKind { #[serde(default = "yes")] printable: bool, children: Vec>, + /// Layer clipping mask: the first (bottom-most) child clips the others, as in a clip group. + #[serde(default, skip_serializing_if = "crate::skip::is_default")] + clip: bool, }, /// A group. With `clip`, the first (bottom-most) child is the clipping path. Group { @@ -336,7 +339,7 @@ impl Node { Self::new(id, NodeKind::Group { children, clip: false }) } pub fn layer(id: NodeId, name: &str, color: LayerColor) -> Self { - let mut n = Self::new(id, NodeKind::Layer { color, template: false, printable: true, children: vec![] }); + let mut n = Self::new(id, NodeKind::Layer { color, template: false, printable: true, children: vec![], clip: false }); n.name = Some(name.to_string()); n } @@ -427,7 +430,9 @@ impl Node { pub fn geometric_bounds(&self) -> Option { match &self.kind { NodeKind::Path { path, .. } => path.bounds(), - NodeKind::Group { children, clip: true } => children.first().and_then(|c| c.geometric_bounds()), + NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } => { + children.first().and_then(|c| c.geometric_bounds()) + } NodeKind::Layer { children, .. } | NodeKind::Group { children, .. } | NodeKind::Compound { children, .. } => children .iter() .filter(|c| c.visible || !matches!(self.kind, NodeKind::Layer { .. })) @@ -447,7 +452,9 @@ impl Node { /// Visual bounds (includes stroke outset). pub fn visual_bounds(&self) -> Option { match &self.kind { - NodeKind::Group { children, clip: true } => children.first().and_then(|c| c.geometric_bounds()), + NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } => { + children.first().and_then(|c| c.geometric_bounds()) + } NodeKind::Layer { children, .. } | NodeKind::Group { children, .. } => { children.iter().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, c.visual_bounds())) } @@ -731,7 +738,7 @@ impl Node { /// A plain group or layer that is neutral to knockout and has no transparency or appearance /// of its own: inside a knockout group its children composite as the group's own children. pub fn passes_knockout_through(&self) -> bool { - matches!(self.kind, NodeKind::Group { clip: false, .. } | NodeKind::Layer { template: false, .. }) + matches!(self.kind, NodeKind::Group { clip: false, .. } | NodeKind::Layer { template: false, clip: false, .. }) && self.has_default_transparency() && self.appearance.items.is_empty() && self.appearance.effects.is_empty() @@ -753,6 +760,18 @@ impl Node { out } + /// Whether this is a clip group or a layer with a clipping mask: its first child clips the rest. + pub fn clips(&self) -> bool { + matches!(self.kind, NodeKind::Group { clip: true, .. } | NodeKind::Layer { clip: true, .. }) + } + + /// Make this group or layer clip its children by its first child, or stop it. + pub fn set_clips(&mut self, on: bool) { + if let NodeKind::Group { clip, .. } | NodeKind::Layer { clip, .. } = &mut self.kind { + *clip = on; + } + } + /// Whether blending inside this object reaches the art below it unless the object isolates /// it: a blend mode other than Normal on a child (or, in a leaf, on a fill or stroke), /// directly or through children that don't isolate their own blending. diff --git a/crates/engine/src/cmd/layer.rs b/crates/engine/src/cmd/layer.rs index 26d0feb8..f749f192 100644 --- a/crates/engine/src/cmd/layer.rs +++ b/crates/engine/src/cmd/layer.rs @@ -47,9 +47,48 @@ pub fn specs() -> Vec { ), cmd!("artboard.fitToArt", "Fit to Artwork Bounds", ["Object", "Artboards"], None, "{index?}", has_doc, artboard_fit_art), cmd!("artboard.fitToSelection", "Fit to Selected Art", ["Object", "Artboards"], None, "{index?}", has_selection, artboard_fit_sel), + cmd!( + "layer.clippingMask.toggle", + "Make/Release Clipping Mask", + ["Window", "Layers"], + None, + "{id?: layer or group (default: the one selected group, else the current layer)} make: its top object (a path, compound path or text, which loses its paint) clips the rest and moves to the bottom (new art added on top is clipped); release: it stops clipping, the clipping path stays unpainted → {clip}", + has_doc, + clip_toggle + ), ] } +/// The Layers panel's clipping mask button: the top object of a layer (or group) clips the rest, +/// or the clipping mask is released. +fn clip_toggle(s: &mut Session, p: &Value) -> Result { + let st = s.doc()?; + let group = match st.selection.objects.as_slice() { + [id] if matches!(st.doc.node(*id).map(|n| &n.kind), Some(NodeKind::Group { .. })) => Some(*id), + _ => None, + }; + let id = id_param(p, "id").or(group).or(st.current_layer()).ok_or_else(|| bad("layer.clippingMask.toggle", "no layer"))?; + let clip = s.edit("Make/Release Clipping Mask", |d, _| { + let n = d.node(id).ok_or(EngineError::NoNode(id))?; + if !matches!(n.kind, NodeKind::Layer { .. } | NodeKind::Group { .. }) { + return Err(bad("layer.clippingMask.toggle", "not a layer or group")); + } + if n.clips() { + super::object::release_clip(d, id); + return Ok(false); + } + let top = + n.children().and_then(|c| c.last()).map(|c| c.id).ok_or_else(|| EngineError::Other("the layer has no objects to clip by".into()))?; + super::object::make_clipping_path(d, top)?; + d.move_node(top, Some(id), 0)?; + if let Some(n) = d.node_mut(id) { + n.set_clips(true); + } + Ok(true) + })?; + Ok(json!({ "clip": clip })) +} + fn new_layer(s: &mut Session, p: &Value) -> Result { let name = str_param(p, "name").map(str::to_string); let st = s.doc()?; diff --git a/crates/engine/src/cmd/object.rs b/crates/engine/src/cmd/object.rs index debcf0af..64403fca 100644 --- a/crates/engine/src/cmd/object.rs +++ b/crates/engine/src/cmd/object.rs @@ -532,13 +532,43 @@ fn compound_release(s: &mut Session, _: &Value) -> Result { ok() } +/// Make `top` (a path, compound path or text object) the clipping path: it loses its paint (it +/// stays unpainted after Release). +pub(super) fn make_clipping_path(d: &mut Document, top: NodeId) -> Result<()> { + let c = d.node_mut(top).ok_or(EngineError::NoNode(top))?; + if !matches!(c.kind, NodeKind::Path { guide: false, .. } | NodeKind::Compound { .. } | NodeKind::Text(_)) { + return Err(EngineError::Other("the top object must be a path, compound path or text object to use as a clipping mask".into())); + } + c.appearance = Appearance::basic(Paint::None, Paint::None, 0.0); + match &mut c.kind { + NodeKind::Path { clipping, .. } => *clipping = true, + NodeKind::Text(t) => { + for r in &mut t.runs { + (r.style.fill, r.style.stroke) = (Paint::None, Paint::None); + } + } + _ => {} + } + Ok(()) +} + +/// Stop clip group or clipped layer `id` clipping; its clipping path stays, unpainted. +pub(super) fn release_clip(d: &mut Document, id: NodeId) { + let Some(n) = d.node_mut(id).filter(|n| n.clips()) else { return }; + n.set_clips(false); + let clip = n.children().and_then(|c| c.first()).map(|c| c.id); + if let Some(c) = clip.and_then(|c| d.node_mut(c)) + && let NodeKind::Path { clipping, .. } = &mut c.kind + { + *clipping = false; + } +} + fn clip_make(s: &mut Session, _: &Value) -> Result { let ids = selected_roots(s)?; let top = *ids.last().unwrap(); let gid = s.edit("Make Clipping Mask", |d, sel| { - if !matches!(d.node(top).map(|n| &n.kind), Some(NodeKind::Path { guide: false, .. } | NodeKind::Compound { .. } | NodeKind::Text(_))) { - return Err(EngineError::Other("the top object must be a path, compound path or text object to use as a clipping mask".into())); - } + make_clipping_path(d, top)?; let (par, idx, _) = d.position(top).ok_or(EngineError::NoNode(top))?; let gid = d.alloc_id(); d.insert(par, idx + 1, Node::new(gid, NodeKind::Group { children: vec![], clip: true }))?; @@ -546,19 +576,6 @@ fn clip_make(s: &mut Session, _: &Value) -> Result { for id in &ids[..ids.len() - 1] { d.move_node(*id, Some(gid), usize::MAX)?; } - if let Some(c) = d.node_mut(top) { - // The clipping path loses its paint (it stays unpainted after Release). - c.appearance = Appearance::basic(Paint::None, Paint::None, 0.0); - match &mut c.kind { - NodeKind::Path { clipping, .. } => *clipping = true, - NodeKind::Text(t) => { - for r in &mut t.runs { - (r.style.fill, r.style.stroke) = (Paint::None, Paint::None); - } - } - _ => {} - } - } sel.set([gid]); Ok(gid) })?; @@ -569,18 +586,7 @@ fn clip_release(s: &mut Session, _: &Value) -> Result { let ids = selected_roots(s)?; s.edit("Release Clipping Mask", |d, _| { for id in &ids { - let clip_child = match d.node(*id).map(|n| &n.kind) { - Some(NodeKind::Group { children, clip: true }) => children.first().map(|c| c.id), - _ => continue, - }; - if let Some(NodeKind::Group { clip, .. }) = d.node_mut(*id).map(|n| &mut n.kind) { - *clip = false; - } - if let Some(c) = clip_child.and_then(|c| d.node_mut(c)) - && let NodeKind::Path { clipping, .. } = &mut c.kind - { - *clipping = false; - } + release_clip(d, *id); } Ok(()) })?; diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index 436db81c..635f123d 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -770,6 +770,8 @@ mod tests_gradpanel; #[cfg(test)] mod tests_knockout; #[cfg(test)] +mod tests_layerclip; +#[cfg(test)] mod tests_live; #[cfg(test)] mod tests_menucmds; diff --git a/crates/engine/src/tests_clip.rs b/crates/engine/src/tests_clip.rs index a581aa31..f3ea91f8 100644 --- a/crates/engine/src/tests_clip.rs +++ b/crates/engine/src/tests_clip.rs @@ -7,13 +7,13 @@ use vectorcraft_render::Rendered; use super::*; -fn session() -> Session { +pub(crate) fn session() -> Session { let mut s = Session::new(); s.execute("file.new", &json!({"width": 100, "height": 100})).unwrap(); s } -fn id_of(v: &Value) -> NodeId { +pub(crate) fn id_of(v: &Value) -> NodeId { NodeId(v["id"].as_u64().unwrap()) } @@ -21,16 +21,16 @@ fn ellipse(s: &mut Session, x: f64, w: f64) -> NodeId { id_of(&s.execute("shape.ellipse", &json!({"x": x, "y": x, "width": w, "height": w})).unwrap()) } -fn select(s: &mut Session, ids: &[NodeId]) { +pub(crate) fn select(s: &mut Session, ids: &[NodeId]) { s.execute("select.set", &json!({"ids": ids.iter().map(|i| i.0).collect::>()})).unwrap(); } /// The active document's 100×100 artboard, rendered transparent. -fn render(s: &Session) -> Rendered { +pub(crate) fn render(s: &Session) -> Rendered { vectorcraft_render::Renderer::new().render(&s.doc().unwrap().doc, 100, 100, Affine::IDENTITY, &Default::default()) } -fn opaque(r: &Rendered, x: u32, y: u32) -> bool { +pub(crate) fn opaque(r: &Rendered, x: u32, y: u32) -> bool { r.pixel(x, y)[3] > 128 } @@ -43,7 +43,7 @@ fn reopened(s: &mut Session, format: &str) -> Rendered { } /// The same probes are opaque on screen and in the SVG and PDF output. -fn assert_outputs_agree(s: &mut Session, probes: &[(u32, u32)]) { +pub(crate) fn assert_outputs_agree(s: &mut Session, probes: &[(u32, u32)]) { let screen = render(s); for format in ["svg", "pdf"] { let out = reopened(s, format); @@ -54,7 +54,7 @@ fn assert_outputs_agree(s: &mut Session, probes: &[(u32, u32)]) { } /// The leaf a click at (`x`, `y`) hits. -fn hit(s: &Session, x: f64, y: f64) -> Option { +pub(crate) fn hit(s: &Session, x: f64, y: f64) -> Option { vectorcraft_doc::hit::hit_test(&s.doc().unwrap().doc, vectorcraft_geom::Point::new(x, y), Default::default()).map(|h| h.leaf) } diff --git a/crates/engine/src/tests_layerclip.rs b/crates/engine/src/tests_layerclip.rs new file mode 100644 index 00000000..074be859 --- /dev/null +++ b/crates/engine/src/tests_layerclip.rs @@ -0,0 +1,122 @@ +//! Layer clipping masks (M3.75): the Layers panel button makes the top object of the current layer +//! (or of the selected group) clip the rest, and pressing it again releases the mask. + +use serde_json::json; + +use super::tests_clip::{assert_outputs_agree, hit, id_of, opaque, render, select, session}; +use super::*; + +fn rect(s: &mut Session, x: f64, y: f64, w: f64, h: f64) -> NodeId { + id_of(&s.execute("shape.rectangle", &json!({"x": x, "y": y, "width": w, "height": h})).unwrap()) +} + +fn toggle(s: &mut Session) -> bool { + s.execute("layer.clippingMask.toggle", &json!({})).unwrap()["clip"].as_bool().unwrap() +} + +fn layer(s: &Session) -> vectorcraft_doc::Node { + let st = s.doc().unwrap(); + st.doc.node(st.current_layer().unwrap()).unwrap().clone() +} + +/// A full-page square under a 50 × 50 square at 25..75 (the clip to be), nothing selected. +fn art_and_clip(s: &mut Session) -> (NodeId, NodeId) { + let art = rect(s, 0.0, 0.0, 100.0, 100.0); + let clip = rect(s, 25.0, 25.0, 50.0, 50.0); + s.execute("select.none", &json!({})).unwrap(); + (art, clip) +} + +#[test] +fn the_top_object_clips_the_layer_and_pressing_again_releases_it() { + let mut s = session(); + let (art, clip) = art_and_clip(&mut s); + assert!(toggle(&mut s)); + let l = layer(&s); + assert!(l.clips()); + // The clipping path loses its paint and goes to the bottom, so art added on top is clipped. + let c = &l.children().unwrap()[0]; + assert_eq!(c.id, clip); + assert!(c.appearance.fill_paint().is_none() && matches!(c.kind, NodeKind::Path { clipping: true, .. })); + let r = render(&s); + assert!(opaque(&r, 50, 50) && !opaque(&r, 10, 10)); + // Clicks only reach the art inside the clip. + assert_eq!(hit(&s, 50.0, 50.0), Some(art)); + assert_eq!(hit(&s, 10.0, 10.0), None); + rect(&mut s, 0.0, 80.0, 100.0, 20.0); + assert!(!opaque(&render(&s), 50, 90), "new art is clipped"); + // Again: released, the clipping path stays unpainted. + s.execute("select.none", &json!({})).unwrap(); + assert!(!toggle(&mut s)); + let l = layer(&s); + assert!(!l.clips()); + let c = &l.children().unwrap()[0]; + assert!(c.appearance.fill_paint().is_none() && matches!(c.kind, NodeKind::Path { clipping: false, .. })); + let r = render(&s); + assert!(opaque(&r, 10, 10) && opaque(&r, 50, 90)); +} + +#[test] +fn making_a_layer_clipping_mask_is_one_undo_step() { + let mut s = session(); + let (_, clip) = art_and_clip(&mut s); + let before = layer(&s); + toggle(&mut s); + s.execute("edit.undo", &json!({})).unwrap(); + assert_eq!(layer(&s), before, "the clip path is back on top with its paint"); + s.execute("edit.redo", &json!({})).unwrap(); + assert!(layer(&s).clips()); + assert_eq!(layer(&s).children().unwrap()[0].id, clip); +} + +#[test] +fn layer_clipping_masks_save_and_export() { + let mut s = session(); + art_and_clip(&mut s); + toggle(&mut s); + let doc = &s.doc().unwrap().doc; + let back = vectorcraft_format::load(&vectorcraft_format::save(doc, false)).unwrap(); + assert!(back.layers[0].clips()); + assert_eq!(back, **doc); + // An unclipped layer writes no `clip` key (older files stay as they were). + let plain = String::from_utf8(vectorcraft_format::save(&session().doc().unwrap().doc, false)).unwrap(); + assert!(!plain.contains("\"clip\""), "{plain}"); + // SVG and PDF clip the same way as the canvas. + assert_outputs_agree(&mut s, &[(50, 50), (10, 10), (30, 30), (80, 80), (74, 26)]); +} + +#[test] +fn a_selected_group_becomes_a_clip_group() { + let mut s = session(); + let (art, clip) = art_and_clip(&mut s); + select(&mut s, &[art, clip]); + let g = id_of(&s.execute("object.group", &json!({})).unwrap()); + select(&mut s, &[g]); + assert!(toggle(&mut s)); + let n = s.doc().unwrap().doc.node(g).unwrap().clone(); + assert!(matches!(n.kind, NodeKind::Group { clip: true, .. })); + assert_eq!(n.children().unwrap()[0].id, clip); + assert!(!layer(&s).clips(), "the layer is left alone"); + assert!(!opaque(&render(&s), 10, 10)); + assert!(!toggle(&mut s)); + assert!(!s.doc().unwrap().doc.node(g).unwrap().clips()); +} + +#[test] +fn the_top_object_must_be_able_to_clip() { + let mut s = session(); + let a = rect(&mut s, 0.0, 0.0, 50.0, 50.0); + let b = rect(&mut s, 50.0, 50.0, 50.0, 50.0); + select(&mut s, &[a, b]); + s.execute("object.group", &json!({})).unwrap(); + s.execute("select.none", &json!({})).unwrap(); + let before = layer(&s); + assert!(s.execute("layer.clippingMask.toggle", &json!({})).is_err(), "a group on top"); + assert_eq!(layer(&s), before); + // An explicit id picks the layer even with a group selected. + let l = before.id; + s.execute("layer.newSublayer", &json!({"parent": l.0})).unwrap(); + let sub = layer(&s).children().unwrap().last().unwrap().id; + let err = s.execute("layer.clippingMask.toggle", &json!({"id": sub.0})); + assert!(err.is_err(), "an empty sublayer has nothing to clip by"); +} diff --git a/crates/pdf/src/export.rs b/crates/pdf/src/export.rs index 54f5a110..ebf48ca8 100644 --- a/crates/pdf/src/export.rs +++ b/crates/pdf/src/export.rs @@ -469,8 +469,8 @@ impl Exporter<'_> { pushes += 1; } match &n.kind { - NodeKind::Layer { children, .. } | NodeKind::Group { children, clip: false } => self.children(s, children, page), - NodeKind::Group { children, clip: true } => { + NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => self.children(s, children, page), + NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } => { // The region every output clips to; nothing to clip by hides the clipped art. if let Some((clip, rest)) = children.split_first() && let Some((p, r)) = vectorcraft_effects::clip_outline(clip).and_then(|(bp, r)| to_path(&bp).map(|p| (p, r))) diff --git a/crates/render/src/fx.rs b/crates/render/src/fx.rs index 643adede..9066238e 100644 --- a/crates/render/src/fx.rs +++ b/crates/render/src/fx.rs @@ -127,7 +127,7 @@ pub(crate) fn visual_bounds(n: &Node) -> Option { /// the subtree (a shadow can reach the view while its object is outside it). pub(crate) fn cull_bounds(n: &Node) -> Option { match &n.kind { - NodeKind::Layer { children, .. } | NodeKind::Group { children, clip: false } => { + NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => { children.iter().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, cull_bounds(c))) } _ if has_fx(n) => visual_bounds(n), diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs index 9eda6757..9654d292 100644 --- a/crates/render/src/lib.rs +++ b/crates/render/src/lib.rs @@ -456,7 +456,7 @@ impl Renderer { return e.bounds; } let b = match &a.kind { - NodeKind::Layer { children, .. } | NodeKind::Group { children, clip: false } if !fx::has_fx(a) => { + NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } if !fx::has_fx(a) => { let mut acc: Option = None; for c in children { if c.visible { @@ -642,13 +642,15 @@ impl Renderer { /// What `n` draws inside its transparency group (`knockout`: its children knock each other out). fn draw_content(&mut self, ctx: &mut RenderContext, f: &Frame, n: &Node, knockout: bool) { match &n.kind { - NodeKind::Layer { children, .. } | NodeKind::Group { children, clip: false } => self.draw_children(ctx, f, children, knockout), - NodeKind::Group { children, clip: true } if f.opts.outline => { + NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => { + self.draw_children(ctx, f, children, knockout) + } + NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } if f.opts.outline => { for c in children { self.draw_node(ctx, f, c, false); } } - NodeKind::Group { children, clip: true } => { + NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } => { // Nothing to clip by hides the clipped art (as in the SVG and PDF output). A clip // group doesn't isolate: blending inside it reaches the art below. if let Some((clip, rest)) = children.split_first() diff --git a/crates/svg/src/export.rs b/crates/svg/src/export.rs index df0c07a5..4832eb7f 100644 --- a/crates/svg/src/export.rs +++ b/crates/svg/src/export.rs @@ -777,7 +777,7 @@ impl Writer<'_> { } match &n.kind { NodeKind::Layer { template: true, .. } => {} - NodeKind::Layer { children, .. } | NodeKind::Group { children, clip: false } => { + NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => { let id = self.id_attr(n); let a = self.attrs(&self.group_props(n)); self.line(&format!("")); @@ -786,7 +786,7 @@ impl Writer<'_> { self.depth -= 1; self.line(""); } - NodeKind::Group { children, clip: true } => { + NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } => { let Some((clip, rest)) = children.split_first() else { return }; let cid = self.fresh_id("clip-path"); self.def(1, &format!("")); diff --git a/crates/ui-egui/src/panels/layers.rs b/crates/ui-egui/src/panels/layers.rs index fee74ddb..8988d335 100644 --- a/crates/ui-egui/src/panels/layers.rs +++ b/crates/ui-egui/src/panels/layers.rs @@ -31,7 +31,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) { egui::ScrollArea::vertical().max_height(h).auto_shrink([false, false]).show(ui, |ui| { ui.spacing_mut().item_spacing.y = 0.0; for l in doc.layers.iter().rev() { - row(ui, &doc, l, 0, &sel, current, &mut expanded, &mut actions, &t); + row(ui, &doc, l, 0, false, &sel, current, &mut expanded, &mut actions, &t); } }); ui.data_mut(|d| d.insert_temp(expanded_id(), expanded)); @@ -64,7 +64,7 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) { actions.push(("layer.newSublayer".into(), json!({}))); } if widgets::icon_button(&mut child, "frame", "Make/Release Clipping Mask", false, 24.0).clicked() { - actions.push(("object.clippingMask.make".into(), json!({}))); + actions.push(("layer.clippingMask.toggle".into(), json!({}))); } if widgets::icon_button(&mut child, "search", "Locate Object", false, 24.0).clicked() { // Expand ancestors of the selection. @@ -89,6 +89,7 @@ fn row( doc: &vectorcraft_doc::Document, n: &Node, depth: usize, + clip_path: bool, sel: &HashSet, current: Option, expanded: &mut HashSet, @@ -199,7 +200,12 @@ fn row( } } _ => { - ui.painter().with_clip_rect(name_rect).text(egui::pos2(x, r.center().y), egui::Align2::LEFT_CENTER, name.clone(), font, t.text); + let painter = ui.painter().with_clip_rect(name_rect); + let text = painter.text(egui::pos2(x, r.center().y), egui::Align2::LEFT_CENTER, name.clone(), font, t.text); + // A clipping path's name is underlined. + if clip_path { + painter.line_segment([text.left_bottom(), text.right_bottom()], Stroke::new(1.0, t.text)); + } } } // Target circle and selection square. @@ -269,8 +275,8 @@ fn row( } if has_children && expanded.contains(&n.id.0) { - for c in n.children().unwrap().iter().rev() { - row(ui, doc, c, depth + 1, sel, current, expanded, actions, t); + for (i, c) in n.children().unwrap().iter().enumerate().rev() { + row(ui, doc, c, depth + 1, i == 0 && n.clips(), sel, current, expanded, actions, t); } } } @@ -374,4 +380,27 @@ mod tests { run(&mut app, "appearance.addStroke", json!({})); assert_eq!(filled_targets(&mut app, &ctx), 1, "two strokes"); } + + #[test] + fn a_layer_clipping_mask_underlines_its_clipping_path() { + let mut app = VectorcraftApp::new(Session::new(), Default::default()); + let run = |app: &mut VectorcraftApp, id: &str, p: serde_json::Value| app.session.execute(id, &p).unwrap(); + run(&mut app, "file.new", json!({"width": 100, "height": 100})); + run(&mut app, "shape.rectangle", json!({"x": 0, "y": 0, "width": 100, "height": 100})); + run(&mut app, "shape.rectangle", json!({"x": 25, "y": 25, "width": 50, "height": 50})); + run(&mut app, "select.none", json!({})); + let ctx = egui::Context::default(); + let text = Tokens::get(&ctx).text; + // Line segments in the text colour: the underlines. + let underlines = |app: &mut VectorcraftApp| { + let mut out = ctx.run_ui(egui::RawInput::default(), |ui| show(app, ui)); + out.textures_delta.clear(); + out.shapes.iter().filter(|c| matches!(&c.shape, egui::Shape::LineSegment { stroke, .. } if stroke.color == text)).count() + }; + assert_eq!(underlines(&mut app), 0); + assert_eq!(run(&mut app, "layer.clippingMask.toggle", json!({}))["clip"], true); + assert_eq!(underlines(&mut app), 1); + run(&mut app, "layer.clippingMask.toggle", json!({})); + assert_eq!(underlines(&mut app), 0); + } } diff --git a/docs/mcp.md b/docs/mcp.md index d0291c19..cdbc5d6f 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -222,6 +222,11 @@ plain group and keeps the clipping path, unpainted. {"name":"run_command","arguments":{"command":"object.clippingMask.make","params":{}}} ``` +`layer.clippingMask.toggle {id?}` is the Layers panel's clipping mask button: the top object of the layer `id` (default: +the one selected group, else the current layer) becomes its clipping path (unpainted, moved to the bottom of the layer, +so art added later is clipped too); called again it releases the mask. It returns `{clip}`, and the Layers panel +underlines clipping-path names. + ## Graphic styles A graphic style holds an appearance (fills, strokes, effects) plus opacity, blend mode, isolate and knockout.