LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
Keep live brush dab budget across frames (#1520)
adrdsouza4d8f93585acb
diff --git a/crates/pipeline/src/masks.rs b/crates/pipeline/src/masks.rsindex 6db0e2e52..c9a7dada9 100644--- a/crates/pipeline/src/masks.rs+++ b/crates/pipeline/src/masks.rs@@ -544,10 +544,19 @@ pub fn dab_spacing(r: f64) -> f64 {/// nothing, so holding the brush still adds no coverage (#518). Returns whether `q` was stamped;/// callers move `prev` on only then. A stroke holding [`MAX_STROKE_DABS`] takes no more.pub fn push_dabs(dabs: &mut Vec<Point>, prev: Option<Point>, q: Point, r: f64) -> bool {- let room = MAX_STROKE_DABS.saturating_sub(dabs.len());+ let mut emitted = dabs.len();+ push_dabs_counted(dabs, &mut emitted, prev, q, r)+}++/// Append one segment using a persistent count of all dabs emitted for this stroke, including+/// dabs no longer held in `dabs`. Incremental callers retain `emitted` when clearing their buffer;+/// it advances only by the number actually appended. Acceptance and spacing match [`push_dabs`].+pub fn push_dabs_counted(dabs: &mut Vec<Point>, emitted: &mut usize, prev: Option<Point>, q: Point, r: f64) -> bool {+ let room = MAX_STROKE_DABS.saturating_sub(*emitted);if room == 0 || !(q.x.is_finite() && q.y.is_finite()) {return false;}+ let before = dabs.len();if let Some(prev) = prev {let dist = prev.dist(q);if dist.is_nan() || dist <= STATIONARY_PX {@@ -564,6 +573,7 @@ pub fn push_dabs(dabs: &mut Vec<Point>, prev: Option<Point>, q: Point, r: f64) -}}dabs.push(q);+ *emitted += dabs.len() - before;true}@@ -865,6 +875,33 @@ mod tests {assert!(v.len() <= 1_000_002, "{}", v.len());}+ /// A temporary output buffer must spend the same stroke budget as a retained one.+ #[test]+ fn incremental_dab_buffers_share_the_stroke_budget() {+ let points = [Point::new(20.0, 20.0), Point::new(80.0, 20.0), Point::new(200.0, 80.0), Point::new(21.0, 20.0)];+ let mut retained = Vec::new();+ let mut streamed = Vec::new();+ let mut retained_count = MAX_STROKE_DABS - 3;+ let mut streamed_count = retained_count;+ let mut prev = None;+ for q in points {+ let mut chunk = Vec::new();+ let accepted = push_dabs_counted(&mut retained, &mut retained_count, prev, q, 10.0);+ assert_eq!(accepted, push_dabs_counted(&mut chunk, &mut streamed_count, prev, q, 10.0));+ streamed.extend(chunk);+ if accepted {+ prev = Some(q);+ }+ }+ assert_eq!(retained, streamed);+ assert_eq!(retained.len(), 3);+ assert_eq!(retained_count, MAX_STROKE_DABS);+ assert_eq!(streamed_count, retained_count);+ assert_eq!(prev, Some(points[1]));+ assert!(!retained.contains(&points[2]));+ assert!(!retained.contains(&points[3]));+ }+/// Pen pressure scales each dab's radius and flow; a stroke without pressure data paints as before, and hostile/// pressures (NaN, out of range, a short list) neither panic nor paint more than full pressure.#[test]diff --git a/crates/ui-egui/src/brush_live.rs b/crates/ui-egui/src/brush_live.rsindex 83f6e186b..1d31d44d2 100644--- a/crates/ui-egui/src/brush_live.rs+++ b/crates/ui-egui/src/brush_live.rs@@ -9,7 +9,7 @@use egui::{Color32, ColorImage, Pos2, Rect, TextureHandle, TextureOptions, pos2};use lightcraft_geom::Point;-use lightcraft_pipeline::masks::{accumulate, dab_alpha, pressure_flow, pressure_radius, push_dabs, push_pressures};+use lightcraft_pipeline::masks::{accumulate, dab_alpha, pressure_flow, pressure_radius, push_dabs_counted, push_pressures};/// The largest live-stroke buffer edge (pixels); a bigger canvas is painted at a lower resolution.const MAX_SIDE: usize = 4096;@@ -41,6 +41,8 @@ pub struct LiveStroke {alpha: Vec<f32>,/// Samples stamped so far, and the last one (buffer pixels).placed: usize,+ /// Total dabs emitted across every stamp, including the first sample.+ emitted: usize,last: Option<Point>,/// The pen pressure of the last stamped sample.last_pressure: f32,@@ -54,7 +56,7 @@ impl LiveStroke {let scale = buffer_scale(params.clip, params.scale);let params = LiveParams { scale, ..params };let (w, h) = buffer_size(params.clip, scale);- LiveStroke { params, w, h, alpha: vec![0.0; w * h], placed: 0, last: None, last_pressure: 1.0, dirty: None, texture: None }+ LiveStroke { params, w, h, alpha: vec![0.0; w * h], placed: 0, emitted: 0, last: None, last_pressure: 1.0, dirty: None, texture: None }}/// Stroke coverage (0..1) at buffer pixel `(x, y)`; 0 outside.@@ -86,7 +88,7 @@ impl LiveStroke {for (k, q) in new.iter().enumerate() {let q = Point::new(((q.x - clip.left()) * scale) as f64, ((q.y - clip.top()) * scale) as f64);let before = dabs.len();- if push_dabs(&mut dabs, self.last, q, r) {+ if push_dabs_counted(&mut dabs, &mut self.emitted, self.last, q, r) {let pq = pressure.get(first + k).or(pressure.last()).copied().unwrap_or(1.0);let from = if self.last.is_some() { self.last_pressure } else { pq };push_pressures(&mut pressures, dabs.len() - before, from, pq);@@ -253,6 +255,39 @@ mod tests {assert_eq!(once.alpha, steps.alpha);}+ /// Crossing the budget in separate frames must match one stamp, including pressure state.+ #[test]+ fn incremental_stamping_respects_the_whole_stroke_budget() {+ use lightcraft_pipeline::masks::MAX_STROKE_DABS;++ let pts = [pos2(20.0, 20.0), pos2(80.0, 20.0), pos2(200.0, 80.0), pos2(21.0, 20.0)];+ let pressure = [0.2, 0.4, 1.0, 0.9];+ let mut once = LiveStroke::new(LiveParams { flow: 0.4, ..params() });+ once.emitted = MAX_STROKE_DABS - 3;+ once.stamp(&pts, &pressure);+ let mut steps = LiveStroke::new(once.params);+ steps.emitted = MAX_STROKE_DABS - 3;+ for n in 1..=pts.len() {+ steps.stamp(&pts[..n], &pressure[..n]);+ }+ assert_eq!(once.alpha, steps.alpha);+ assert_eq!(once.emitted, MAX_STROKE_DABS);+ assert_eq!(steps.emitted, once.emitted);+ assert_eq!(once.last, Some(Point::new(80.0, 20.0)));+ assert_eq!(steps.last, once.last);+ assert_eq!(once.last_pressure, pressure[1]);+ assert_eq!(steps.last_pressure, once.last_pressure);+ assert!(once.coverage(80, 20) > 0.0);+ assert_eq!(once.coverage(200, 80), 0.0);+ let alpha = steps.alpha.clone();+ let more = [pts[0], pts[1], pts[2], pts[3], pos2(300.0, 100.0)];+ steps.stamp(&more, &[1.0; 5]);+ assert_eq!(steps.alpha, alpha, "later frames cannot paint or reconnect discarded samples");+ assert_eq!(steps.last, once.last);+ assert_eq!(steps.last_pressure, once.last_pressure);+ assert_eq!(steps.emitted, MAX_STROKE_DABS);+ }+#[test]fn hostile_input_paints_nothing_and_does_not_panic() {let mut s = LiveStroke::new(params());