Skip to content

ProCraft for Android: An Android native painting app written in Rust

Rust

perf(gpu): keep the composite caches through transforms, adjustments and held edits

Josh1df400c30a53
diff --git a/crates/gpu/src/canvas.rs b/crates/gpu/src/canvas.rs
index 36bbe10..2279b99 100644
--- a/crates/gpu/src/canvas.rs
+++ b/crates/gpu/src/canvas.rs
@@ -3826,9 +3826,7 @@ impl Canvas {
/// is below the run), with every layer in them; none while something else is under way
/// (Animation Assist's frames, an adjustment, liquify, a transform, a stroke elsewhere).
fn live_items(&self, doc: &Document) -> Option<(Vec<LayerId>, std::ops::Range<usize>)> {
- let busy =
- self.transforming.is_some() || self.liquify.is_some() || self.pencil.is_some() || self.held.is_some();
- if doc.animation.is_some() || busy || self.smudge.is_some() {
+ if doc.animation.is_some() {
return None;
}
let tops = doc.members(None);
@@ -3852,7 +3850,16 @@ impl Canvas {
end += 1;
}
let live: HashSet<LayerId> = tops.get(start..end)?.iter().flat_map(|t| item_layers(doc, *t)).collect();
- if self.active.is_some_and(|a| !live.contains(&a.layer)) {
+ // what is being worked on (a stroke, a smudge, a transform or adjustment, a held edit)
+ // must be among them
+ let worked = self
+ .active
+ .map(|a| a.layer)
+ .into_iter()
+ .chain(self.smudge.as_ref().map(|s| s.layer))
+ .chain(self.transforming.iter().chain(&self.transform_more).map(|t| t.layer))
+ .chain(self.held.as_ref().map(|h| h.layer));
+ if worked.into_iter().any(|id| !live.contains(&id)) {
return None;
}
Some((tops, start..end))
@@ -4227,17 +4234,35 @@ impl Canvas {
self.invalidate();
}
- /// Whether work keeps the caches: painting, or undoing or redoing it, on a layer worked on.
+ /// Whether work keeps the caches: it changes only the pixels of layers worked on (painting,
+ /// transforms and adjustments, held edits, clearing, and undoing or redoing those).
fn keeps_caches(&self, op: &Op, live: &HashSet<LayerId>) -> bool {
let only_live = |step: Option<&Step>| {
step.is_some_and(|s| s.doc.is_none() && s.pixels.iter().all(|p| live.contains(&p.layer)))
};
+ let transformed_live = || self.transforming.iter().chain(&self.transform_more).all(|t| live.contains(&t.layer));
match op {
Op::Stamps { layer, .. } => live.contains(layer),
Op::Commit(stroke) => live.contains(&stroke.layer),
Op::Cancel | Op::SaveTip(_) | Op::Untip(_) | Op::Mark | Op::Name(_) | Op::Collapse => true,
Op::Undo => only_live(self.undo.last()),
Op::Redo => only_live(self.redo.last()),
+ Op::TransformBegin(id)
+ | Op::TransformAlso(id)
+ | Op::Hold(id)
+ | Op::Put(id, _)
+ | Op::Clear(id)
+ | Op::Wipe(id) => live.contains(id),
+ Op::TransformSet { .. }
+ | Op::TransformMesh { .. }
+ | Op::FilterSet(_)
+ | Op::LiquifyBegin
+ | Op::PencilBegin
+ | Op::LiquifyStamps(_)
+ | Op::LiquifyClear
+ | Op::TransformEnd { .. } => transformed_live(),
+ Op::Release { before: None, .. } => self.held.as_ref().is_none_or(|h| live.contains(&h.layer)),
+ Op::Write { layers, before: None } => layers.iter().all(|(id, _)| live.contains(id)),
_ => false,
}
}
diff --git a/crates/gpu/tests/layers.rs b/crates/gpu/tests/layers.rs
index b4ce5a9..b83220d 100644
--- a/crates/gpu/tests/layers.rs
+++ b/crates/gpu/tests/layers.rs
@@ -5,7 +5,7 @@
use procraft_engine::document::{BlendMode, Document, LayerId};
use procraft_engine::geom::Vec2;
use procraft_engine::stroke::Stamp;
-use procraft_gpu::{Canvas, Gpu, StrokeStyle, StrokeTool};
+use procraft_gpu::{Canvas, Filter, Gpu, Resample, StrokeStyle, StrokeTool};
const W: u32 = 16;
@@ -728,3 +728,49 @@ fn a_layers_version_changes_with_its_pixels_only() {
assert_ne!(canvas.layer_version(b), painted, "undone");
assert_eq!(gpu.errors(), 0);
}
+
+#[test]
+fn transforms_and_adjustments_on_the_layer_worked_on_keep_the_caches() {
+ let Some((gpu, _, _)) = setup() else { return };
+ let docs = [Document::new(W, W), Document::new(W, W)];
+ let canvases = [Canvas::new(&gpu, &docs[0]).unwrap(), Canvas::new(&gpu, &docs[1]).unwrap()];
+ let mut t = Twins { docs, canvases };
+ t.canvases[0].set_cache_composites(true);
+ let base = t.docs[0].current();
+ t.each(|doc, canvas| {
+ fill(canvas, doc, base, [200, 40, 40]);
+ for i in 0..4u8 {
+ let id = doc.add_layer();
+ let at = Vec2::new(f32::from(i) * 3.0 + 3.0, 8.0);
+ paint(canvas, doc, id, [i * 50, 100, 200 - i * 40], at, 3.0, StrokeTool::Paint);
+ }
+ canvas.invalidate();
+ });
+ let middle = t.docs[0].layers()[2].id;
+ t.each(|doc, _| {
+ doc.set_current(middle);
+ });
+ t.same(&gpu, 2, "made");
+ assert!(t.canvases[0].composites_cached());
+ // moved by (3, 2), applied, undone
+ t.each(|_, canvas| {
+ canvas.begin_transform(middle);
+ canvas.set_transform([1.0, 0.0, -3.0, 0.0, 1.0, -2.0, 0.0, 0.0, 1.0], Resample::Bilinear);
+ });
+ t.same(&gpu, 2, "moved");
+ assert!(t.canvases[0].composites_cached(), "kept while transforming");
+ t.each(|_, canvas| canvas.end_transform(true));
+ t.same(&gpu, 2, "applied");
+ t.each(|_, canvas| canvas.undo());
+ t.same(&gpu, 2, "undone");
+ // an adjustment on it, cancelled
+ t.each(|_, canvas| {
+ canvas.begin_transform(middle);
+ canvas.set_filter(Filter::Hsb { hue: 1.0, saturation: 0.5, brightness: 0.1 });
+ });
+ t.same(&gpu, 2, "adjusted");
+ assert!(t.canvases[0].composites_cached(), "kept while adjusting");
+ t.each(|_, canvas| canvas.end_transform(false));
+ t.same(&gpu, 2, "cancelled");
+ assert!(t.canvases[0].composites_cached());
+}