VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Bound offscreen pixels kept alive by nested blending groups
bflatastice2713842c4c2
diff --git a/crates/render/src/group.rs b/crates/render/src/group.rsindex 95e1c379c..4383d515a 100644--- a/crates/render/src/group.rs+++ b/crates/render/src/group.rs@@ -74,11 +74,17 @@ impl Renderer {return;}if c.blends && (c.isolated || self.nested == 0) {- return self.group_offscreen(ctx, f, c, draw);+ let Some(r) = region(ctx, f, c.bounds) else { return };+ // Past the budget for offscreen pixels, the group is drawn as a layer (isolated).+ // A masked group is drawn offscreen whatever the budget: its mask scales its pixels.+ if c.mask.is_some() || self.offscreen_fits(ctx, r, c.isolated) {+ return self.group_offscreen(ctx, f, c, r, draw);+ }}if c.mask.is_some() {// Its backdrop out of reach (or not needed), a masked group starts from transparency.- return self.group_offscreen(ctx, f, Composite { isolated: true, ..c }, draw);+ let Some(r) = region(ctx, f, c.bounds) else { return };+ return self.group_offscreen(ctx, f, Composite { isolated: true, ..c }, r, draw);}ctx.set_transform(f.view);if let Some((_, rule)) = c.clip {@@ -94,9 +100,22 @@ impl Renderer {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, sub)) = area(ctx, f, bounds) else { return };+ /// Whether a group drawn offscreen over region `r` keeps the offscreen pixels alive within+ /// [`OFFSCREEN_FRAMES`] times the frame `ctx` (the frame's own context when none is alive).+ fn offscreen_fits(&self, ctx: &RenderContext, r: Region, isolated: bool) -> bool {+ let budget =+ if self.offscreen_live == 0 { OFFSCREEN_FRAMES * u64::from(ctx.width()) * u64::from(ctx.height()) } else { self.offscreen_budget };+ self.offscreen_live.saturating_add(offscreen_cost(r, isolated)) <= budget+ }++ fn group_offscreen(&mut self, ctx: &mut RenderContext, f: &Frame, c: Composite, r: Region, draw: &mut Content) {+ let Composite { clip, blend, opacity, mask, isolated, .. } = c;+ if self.offscreen_live == 0 {+ self.offscreen_budget = OFFSCREEN_FRAMES * u64::from(ctx.width()) * u64::from(ctx.height());+ }+ let cost = offscreen_cost(r, isolated);+ self.offscreen_live = self.offscreen_live.saturating_add(cost);+ let sub = frame_over(f, r);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);@@ -143,6 +162,7 @@ impl Renderer {}}ctx.pop_layer();+ self.offscreen_live = self.offscreen_live.saturating_sub(cost);}/// Render what `ctx` holds so far, and start it again from that picture (so later drawing sees@@ -301,6 +321,16 @@ thread_local! {pub(crate) static PIXELS_DRAWN: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };}+/// The offscreen pixels that groups drawn offscreen may keep alive at once, in frames: deeper+/// nested blending groups are drawn as layers instead (#3581).+const OFFSCREEN_FRAMES: u64 = 4;++/// The pixels a group drawn offscreen over `r` keeps alive: its content, and when it isn't+/// isolated the backdrop copy and the content drawn alone.+fn offscreen_cost(r: Region, isolated: bool) -> u64 {+ u64::from(r.w) * u64::from(r.h) * if isolated { 1 } else { 3 }+}+/// 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<Rect>) -> Option<Region> {@@ -317,9 +347,14 @@ fn region(ctx: &RenderContext, f: &Frame, bounds: Option<Rect>) -> Option<Region/// context of that region's size.pub(crate) fn area<'a>(ctx: &RenderContext, f: &Frame<'a>, bounds: Option<Rect>) -> Option<(Region, Frame<'a>)> {let r = region(ctx, f, bounds)?;+ Some((r, frame_over(f, r)))+}++/// Frame `f` drawing into a context of region `r`'s size (on the calling thread).+fn frame_over<'a>(f: &Frame<'a>, r: Region) -> Frame<'a> {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));- Some((r, Frame { mt: false, view, visible, ..*f }))+ Frame { mt: false, view, visible, ..*f }}/// `pm` (premultiplied) with each pixel scaled by its coverage in `mask` (row-major, `pm`'s size).diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rsindex 82a44aa58..a4eb30fcd 100644--- a/crates/render/src/lib.rs+++ b/crates/render/src/lib.rs@@ -528,6 +528,11 @@ pub struct Renderer {/// The picture [`Self::flatten`] started the current context again from, with 8-bit/// compositing: [`Self::finish`] renders the context over it.picture: Option<Arc<Pixmap>>,+ /// Pixels of the groups being drawn offscreen (contexts and backdrop copies), and the most+ /// they may hold (set from the frame when the first opens, see [`Self::group`]); both reset+ /// at the start of every frame.+ offscreen_live: u64,+ offscreen_budget: u64,/// What clipping paths paint, per clipping path (see [`Self::clip_paint_of`]).clip_paints: FrameCache<usize, ClipPaintEntry>,/// Gradients along or across strokes (see [`Self::fill_path_gradient`]), keyed by@@ -653,6 +658,8 @@ impl Renderer {blends: PtrMap::default(),clip_paths: vec![],picture: None,+ offscreen_live: 0,+ offscreen_budget: 0,clip_paints: FrameCache::new(lru::CLIP_BUDGET, 256),stroke_slices: PtrMap::default(),adjusts: HashMap::new(),@@ -737,6 +744,8 @@ impl Renderer {fn begin_frame(&mut self) {self.stamp += 1;self.inline_depth = 0;+ // Nothing is drawn offscreen yet (even if an earlier frame stopped part way).+ (self.offscreen_live, self.offscreen_budget) = (0, 0);}/// End a frame: drop cache entries not used for a few frames (every render, thumbnails too,diff --git a/crates/render/src/tests_isolation.rs b/crates/render/src/tests_isolation.rsindex 7b2296920..d4d05b48a 100644--- a/crates/render/src/tests_isolation.rs+++ b/crates/render/src/tests_isolation.rs@@ -416,3 +416,27 @@ fn isolation_mode_dims_the_art_around_the_isolated_group() {// An object that isn't in the document dims nothing.assert_eq!(isolated(NodeId(u64::MAX)).pixels, plain.pixels);}++/// Deeply nested isolated blending groups (#3581): each level is drawn offscreen only while the+/// offscreen pixels alive stay within a few frames' worth; deeper levels are drawn as layers.+#[test]+fn nested_isolated_blending_groups_stay_within_the_offscreen_budget() {+ let d = doc(|d| {+ let mut n = multiply(d);+ for _ in 0..30 {+ n = group(d, vec![n], 1.0, Blend::Multiply, true);+ }+ n+ });+ let drawn = || crate::group::PIXELS_DRAWN.with(std::cell::Cell::get);+ let before = drawn();+ let frame = render(&d);+ let images = drawn() - before;+ // Each level's offscreen region is the content's bounds (20..80) plus `region`'s 2 px+ // antialiasing margin on each side: 64 × 64. A budget of 4 frames fits whole levels only.+ let level = 64 * 64;+ let budget = 4 * 100 * 100 / level * level;+ assert!(images <= budget, "{images} pixels drawn from offscreen groups, budget {budget}");+ assert_near(frame.pixel(50, 50), blend_rgb(Blend::Multiply, B, S), "inside the groups");+ assert_near(frame.pixel(10, 10), B, "outside the groups");+}