Skip to content

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.rs
index 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.rs
index 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());