VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Gradients: a dithered fill samples only the part of its grid the view shows
Taha-Mahmoodi4062e74ff34d
diff --git a/crates/color/src/gradient.rs b/crates/color/src/gradient.rsindex 309487982..35573f4ff 100644--- a/crates/color/src/gradient.rs+++ b/crates/color/src/gradient.rs@@ -553,11 +553,25 @@ impl GradientPaint {/// as `rgb` gives them, mixed as the renderer mixes them: [`Ramp`]). Dithered, each colour/// channel of pixel (column, row) gets [`dither_noise`] before it is rounded to a level.pub fn pixels(&self, bounds: Rect, area: Rect, cols: u16, rows: u16, rgb: &dyn Fn(&Color) -> [f32; 3]) -> impl Iterator<Item = [u8; 4]> + use<> {+ self.pixels_within(bounds, area, cols, rows, [0..cols, 0..rows], rgb)+ }+ /// [`Self::pixels`] for the cells in columns `cells[0]` and rows `cells[1]` of the grid only,+ /// row by row: the same pixels, noise and all, the whole grid has there.+ pub fn pixels_within(+ &self,+ bounds: Rect,+ area: Rect,+ cols: u16,+ rows: u16,+ cells: [std::ops::Range<u16>; 2],+ rgb: &dyn Fn(&Color) -> [f32; 3],+ ) -> impl Iterator<Item = [u8; 4]> + use<> {let (kind, geom, dither) = (self.gradient.kind, self.resolve(bounds), self.gradient.dither);let ramp = Ramp::new(&self.gradient, rgb);let (cw, ch) = (area.width() / f64::from(cols.max(1)), area.height() / f64::from(rows.max(1)));let (x0, y0) = (area.x0, area.y0);- (0..u32::from(rows)).flat_map(move |j| (0..u32::from(cols)).map(move |i| (i, j))).map(move |(i, j)| {+ let [across, down] = cells.map(|r| u32::from(r.start)..u32::from(r.end));+ down.flat_map(move |j| across.clone().map(move |i| (i, j))).map(move |(i, j)| {let p = Point::new(x0 + (f64::from(i) + 0.5) * cw, y0 + (f64::from(j) + 0.5) * ch);let c = ramp.at(geom.param_at(kind, p) as f32);let level = |k: usize| {diff --git a/crates/render/src/dither.rs b/crates/render/src/dither.rsindex 9a1ad9d94..49a38d7ce 100644--- a/crates/render/src/dither.rs+++ b/crates/render/src/dither.rs@@ -5,10 +5,13 @@//! the grid and a zoom rarely misses), each colour channel given fine noise of up to a level//! ([`vectorcraft_color::gradient::dither_noise`]) before it is rounded, and drawn as an image//! paint that the fill clips. Past [`MAX_CELLS`] a side (a box larger than that on screen), cells-//! grow beyond a pixel and are mixed bilinearly, so the gradient stays smooth.+//! grow beyond a pixel and are mixed bilinearly, so the gradient stays smooth. Only the cells the+//! render target can show are sampled ([`window`]), so a large box mostly off-screen costs what+//! its visible part does.use std::cell::RefCell;use std::hash::{Hash, Hasher};+use std::ops::Range;use std::sync::Arc;use vectorcraft_color::GradientPaint;@@ -24,11 +27,23 @@ use crate::lru::{self, FrameCache};/// Most cells along a side of a dithered gradient's grid (64 MiB for a square grid).pub(crate) const MAX_CELLS: f64 = 4096.0;+/// Cells along a side of the part of a grid that is sampled snap out to multiples of this+/// ([`window`]), so a pan within them keeps the sampled part.+const TILE: f64 = 256.0;+thread_local! {/// Grids by [`key`], within [`lru::DITHER_BUDGET`], least recently used first out.static GRIDS: RefCell<FrameCache<u64, Arc<Pixmap>>> = RefCell::new(FrameCache::new(lru::DITHER_BUDGET, usize::MAX));}+/// Bytes of the grids this thread keeps, after `f` runs on an empty cache.+#[cfg(test)]+pub(crate) fn grid_bytes_after(f: impl FnOnce()) -> usize {+ GRIDS.with(|c| c.borrow_mut().clear());+ f();+ GRIDS.with(|c| c.borrow().bytes())+}+/// Cells along a side `px` device pixels long: at least one per pixel, rounded up to a/// quarter-octave step, 1 to [`MAX_CELLS`].fn cells(px: f64) -> u16 {@@ -36,9 +51,10 @@ fn cells(px: f64) -> u16 {2f64.powf(steps / 4.0).ceil().clamp(1.0, MAX_CELLS) as u16}-/// Cache key of gradient `g` placed on box `b` as a `cols` × `rows` grid painted with `ink` (and-/// the active colour settings, which turn colours into display RGB or inks).-fn key(g: &GradientPaint, b: Rect, cols: u16, rows: u16, ink: Ink) -> u64 {+/// Cache key of gradient `g` placed on box `b` as a `cols` × `rows` grid, cells `win` of it,+/// painted with `ink` (and the active colour settings, which turn colours into display RGB or+/// inks).+fn key(g: &GradientPaint, b: Rect, cols: u16, rows: u16, win: &[Range<u16>; 2], ink: Ink) -> u64 {let mut h = std::collections::hash_map::DefaultHasher::new();let gr = &g.gradient;(gr.kind as u8, gr.dither).hash(&mut h);@@ -50,24 +66,47 @@ fn key(g: &GradientPaint, b: Rect, cols: u16, rows: u16, ink: Ink) -> u64 {(geom.start.x.to_bits(), geom.start.y.to_bits(), geom.end.x.to_bits(), geom.end.y.to_bits(), geom.aspect.to_bits()).hash(&mut h);geom.focal.map(|f| (f.x.to_bits(), f.y.to_bits())).hash(&mut h);(b.x0.to_bits(), b.y0.to_bits(), b.x1.to_bits(), b.y1.to_bits(), cols, rows).hash(&mut h);+ win.hash(&mut h);(Arc::as_ptr(&vectorcraft_color::cms::active()) as usize, ink).hash(&mut h);h.finish()}-/// `g` placed on `b` as a premultiplied `cols` × `rows` pixmap, colours as `ink` paints them.-pub(crate) fn rasterize(g: &GradientPaint, b: Rect, cols: u16, rows: u16, ink: Ink) -> Pixmap {+/// The cells of a `cols` × `rows` grid over box `b` that a `w` × `h` render target, which+/// transform `xf` maps the box onto, can show: (columns, rows), a cell more each way for the+/// bilinear mix, out to whole [`TILE`]s. The whole grid where `xf` has no inverse; None where+/// no cell shows.+fn window(xf: Affine, w: u16, h: u16, b: Rect, cols: u16, rows: u16) -> Option<[Range<u16>; 2]> {+ let seen = xf.inverse().transform_rect_bbox(Rect::new(0.0, 0.0, f64::from(w), f64::from(h)));+ let span = |lo: f64, hi: f64, start: f64, len: f64, n: u16| {+ let cell = len / f64::from(n);+ let (first, last) = (((lo - start) / cell).floor() - 1.0, ((hi - start) / cell).ceil() + 1.0);+ if !(first.is_finite() && last.is_finite()) {+ return Some(0..n);+ }+ let a = ((first / TILE).floor() * TILE).clamp(0.0, f64::from(n));+ let z = ((last / TILE).ceil() * TILE).clamp(0.0, f64::from(n));+ (a < z).then_some(a as u16..z as u16)+ };+ Some([span(seen.x0, seen.x1, b.x0, b.width(), cols)?, span(seen.y0, seen.y1, b.y0, b.height(), rows)?])+}++/// Cells `win` (columns, rows) of `g` placed on `b` as a `cols` × `rows` grid, as a+/// premultiplied pixmap, colours as `ink` paints them.+pub(crate) fn rasterize(g: &GradientPaint, b: Rect, cols: u16, rows: u16, win: [Range<u16>; 2], ink: Ink) -> Pixmap {+ let (w, h) = (win[0].len() as u16, win[1].len() as u16);let data = g- .pixels(b, b, cols, rows, &|c| ink.rgb(c))+ .pixels_within(b, b, cols, rows, win, &|c| ink.rgb(c)).map(|[r, gr, bl, a]| {let pm = |v: u8| ((u16::from(v) * u16::from(a) + 127) / 255) as u8;vello_cpu::color::PremulRgba8 { r: pm(r), g: pm(gr), b: pm(bl), a }}).collect();- Pixmap::from_parts(data, cols, rows)+ Pixmap::from_parts(data, w, h)}/// Set dithered gradient `g` on box `bounds` (in the paint's space, which the context's current-/// transform maps to pixels) as the context paint. Returns false for an empty box.+/// transform maps to pixels) as the context paint. Returns false for an empty box or one off the+/// render target.pub(crate) fn set_dithered_paint(ctx: &mut RenderContext, g: &GradientPaint, bounds: Rect, ink: Ink) -> bool {let Some(b) = painted_box(bounds) else { return false };// Device pixels per unit along the box's sides.@@ -78,7 +117,9 @@ pub(crate) fn set_dithered_paint(ctx: &mut RenderContext, g: &GradientPaint, boureturn false;}let (cols, rows) = (cells(wpx), cells(hpx));- let k = key(g, b, cols, rows, ink);+ let Some(win) = window(*ctx.transform(), ctx.width(), ctx.height(), b, cols, rows) else { return false };+ let (first_col, first_row) = (win[0].start, win[1].start);+ let k = key(g, b, cols, rows, &win, ink);let pm = GRIDS.with(|c| {let mut c = c.borrow_mut();@@ -86,11 +127,11 @@ pub(crate) fn set_dithered_paint(ctx: &mut RenderContext, g: &GradientPaint, bouc.get(&k, t).cloned()}).unwrap_or_else(|| {- let pm = Arc::new(rasterize(g, b, cols, rows, ink));+ let pm = Arc::new(rasterize(g, b, cols, rows, win, ink));GRIDS.with(|c| {let mut c = c.borrow_mut();let t = c.tick();- c.insert(k, pm.clone(), cols as usize * rows as usize * 4, t);+ c.insert(k, pm.clone(), usize::from(pm.width()) * usize::from(pm.height()) * 4, t);});pm});@@ -100,6 +141,8 @@ pub(crate) fn set_dithered_paint(ctx: &mut RenderContext, g: &GradientPaint, boulet quality = if fine { ImageQuality::Low } else { ImageQuality::Medium };let sampler = ImageSampler { x_extend: Extend::Pad, y_extend: Extend::Pad, quality, alpha: 1.0 };ctx.set_paint(vello_cpu::Image { image: vello_cpu::ImageSource::Pixmap(pm), sampler });- ctx.set_paint_transform(Affine::translate(b.origin().to_vec2()) * Affine::scale_non_uniform(b.width() / cols as f64, b.height() / rows as f64));+ let (cw, ch) = (b.width() / f64::from(cols), b.height() / f64::from(rows));+ let origin = (b.x0 + f64::from(first_col) * cw, b.y0 + f64::from(first_row) * ch);+ ctx.set_paint_transform(Affine::translate(origin) * Affine::scale_non_uniform(cw, ch));true}diff --git a/crates/render/src/tests_dither.rs b/crates/render/src/tests_dither.rsindex a8df8941e..a7290c531 100644--- a/crates/render/src/tests_dither.rs+++ b/crates/render/src/tests_dither.rs@@ -98,3 +98,26 @@ fn a_zoomed_or_rotated_dithered_gradient_keeps_its_colours() {}}}++#[test]+fn a_large_dithered_box_mostly_off_screen_samples_only_what_shows() {+ // A 2000-unit square, the shallow ramp across it: a 2048-cell grid a side, 16 MiB.+ const S: u32 = 2000;+ let mut d = Document::new(f64::from(S), f64::from(S));+ let id = d.alloc_id();+ let n = Node::path(+ id,+ shapes::rectangle(Rect::new(0.0, 0.0, f64::from(S), f64::from(S))),+ Appearance::basic(shallow(GradientKind::Linear, true), Paint::None, 0.0),+ );+ d.insert(Some(d.layers[0].id), 0, n).unwrap();+ let opts = RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };+ let whole = Renderer::new().render(&d, S, S, Affine::IDENTITY, &opts);+ // A 64-pixel view of its middle draws the pixels the whole render has there...+ let mut part = None;+ let bytes = dither::grid_bytes_after(|| part = Some(Renderer::new().render(&d, 64, 64, Affine::translate((-1000.0, -1000.0)), &opts)));+ let part = part.unwrap();+ assert!((0..64).all(|y| (0..64).all(|x| part.pixel(x, y) == whole.pixel(1000 + x, 1000 + y))), "the view draws what the whole render does");+ // ...from the cells around it only, not the whole grid.+ assert!(bytes > 0 && bytes <= 512 * 512 * 4, "{bytes} bytes of grid for a 64-pixel view");+}