Skip to content

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

Rust

fix(gpu): saves and exports read the picture once the caches are remade

Josh506bdc036f26
diff --git a/apps/procraft-android/src/animation.rs b/apps/procraft-android/src/animation.rs
index 9d88c07..aa0677b 100644
--- a/apps/procraft-android/src/animation.rs
+++ b/apps/procraft-android/src/animation.rs
@@ -138,7 +138,7 @@ impl CanvasSession {
return Err(file_error("reading the picture", "the canvas is not shown yet"));
};
canvas.invalidate();
- canvas.render(gpu, &mut doc, None);
+ canvas.render_finished(gpu, &mut doc);
let rgba = canvas.read_composite(gpu);
canvas.invalidate();
canvas.render(gpu, &mut st.doc, None);
diff --git a/apps/procraft-android/src/clipboard.rs b/apps/procraft-android/src/clipboard.rs
index fab7ff7..7a1a484 100644
--- a/apps/procraft-android/src/clipboard.rs
+++ b/apps/procraft-android/src/clipboard.rs
@@ -89,12 +89,14 @@ impl CanvasSession {
/// The whole canvas as it shows, to paste later.
pub fn copy_canvas(&self) -> Option<ThumbnailImage> {
+ self.shared.finish_caches();
let mut guard = self.shared.lock();
let st = &mut *guard;
st.finish_stroke();
st.settle();
st.flush();
- let (Some(canvas), Some(gpu)) = (st.canvas.as_ref(), st.gpu.as_ref()) else { return None };
+ let (Some(canvas), Some(gpu)) = (st.canvas.as_mut(), st.gpu.as_ref()) else { return None };
+ canvas.render_finished(gpu, &mut st.doc);
let rgba = canvas.read_composite(gpu).ok()?;
Some(ThumbnailImage { width: st.doc.width(), height: st.doc.height(), rgba })
}
diff --git a/apps/procraft-android/src/lib.rs b/apps/procraft-android/src/lib.rs
index a684494..43794d8 100644
--- a/apps/procraft-android/src/lib.rs
+++ b/apps/procraft-android/src/lib.rs
@@ -653,6 +653,21 @@ impl Shared {
self.state.lock().unwrap_or_else(|e| e.into_inner())
}
+ /// Lets the canvas finish remaking its caches a render at a time, the lock let go between,
+ /// so a save or export after reads the picture as it is without holding everything up.
+ pub(crate) fn finish_caches(&self) {
+ // each render remakes at least one item, so this ends well before the bound
+ for _ in 0..100_000 {
+ let mut guard = self.lock();
+ let st = &mut *guard;
+ let (Some(canvas), Some(gpu)) = (st.canvas.as_mut(), st.gpu.as_ref()) else { return };
+ canvas.render(gpu, &mut st.doc, None);
+ if !canvas.busy() {
+ return;
+ }
+ }
+ }
+
fn frame(&self, st: &mut State) {
st.needs_frame = true;
self.wake.notify_all();
diff --git a/apps/procraft-android/src/project.rs b/apps/procraft-android/src/project.rs
index 5d6244f..827be8d 100644
--- a/apps/procraft-android/src/project.rs
+++ b/apps/procraft-android/src/project.rs
@@ -411,6 +411,7 @@ impl CanvasSession {
/// Saves started together run one after the other.
pub fn save(&self, dir: String) -> Result<(), MobileError> {
let mut saved = self.shared.saving.lock().unwrap_or_else(|e| e.into_inner());
+ self.shared.finish_caches();
let snapshot = {
let mut guard = self.shared.lock();
let st = &mut *guard;
@@ -427,6 +428,7 @@ impl CanvasSession {
/// would end (a stroke, a transform, an adjustment, text being edited...); false if it didn't.
pub fn save_if_idle(&self, dir: String) -> Result<bool, MobileError> {
let mut saved = self.shared.saving.lock().unwrap_or_else(|e| e.into_inner());
+ self.shared.finish_caches();
let snapshot = {
let mut guard = self.shared.lock();
let st = &mut *guard;
@@ -466,6 +468,7 @@ impl CanvasSession {
/// Writes the flattened picture, full size and with straight alpha, to `path` as a PNG.
pub fn export_png(&self, path: String) -> Result<(), MobileError> {
+ self.shared.finish_caches();
let (w, h, rgba, icc) = {
let mut guard = self.shared.lock();
let st = &mut *guard;
@@ -477,7 +480,7 @@ impl CanvasSession {
let (Some(canvas), Some(gpu)) = (st.canvas.as_mut(), st.gpu.as_ref()) else {
return Err(file_error("reading the picture", "the canvas is not shown yet"));
};
- canvas.render(gpu, &mut st.doc, None);
+ canvas.render_finished(gpu, &mut st.doc);
let rgba = canvas.read_composite(gpu).map_err(|e| file_error("reading the picture", e))?;
(w, h, rgba, (icc, proof))
};
@@ -531,6 +534,7 @@ impl CanvasSession {
}
None => None,
};
+ self.shared.finish_caches();
let (doc, pixels, composite, name, info) = {
let mut guard = self.shared.lock();
let st = &mut *guard;
@@ -721,6 +725,7 @@ impl CanvasSession {
}
fn pictures(&self, with_layers: bool) -> Result<Pictures, MobileError> {
+ self.shared.finish_caches();
let mut guard = self.shared.lock();
let st = &mut *guard;
st.finish_stroke();
@@ -728,7 +733,7 @@ impl CanvasSession {
let (Some(canvas), Some(gpu)) = (st.canvas.as_mut(), st.gpu.as_ref()) else {
return Err(file_error("reading the picture", "the canvas is not shown yet"));
};
- canvas.render(gpu, &mut st.doc, None);
+ canvas.render_finished(gpu, &mut st.doc);
let composite = straight_alpha(&canvas.read_composite(gpu).map_err(|e| file_error("reading the picture", e))?);
let mut layers = std::collections::HashMap::new();
let mut masks = std::collections::HashMap::new();
diff --git a/apps/procraft-android/src/scene3d.rs b/apps/procraft-android/src/scene3d.rs
index 27495d8..34073bd 100644
--- a/apps/procraft-android/src/scene3d.rs
+++ b/apps/procraft-android/src/scene3d.rs
@@ -1117,7 +1117,7 @@ impl State {
// the channel painted on is the session's; the others wait in the scene
*picture = if part == current && channel == painted {
let canvas = self.canvas.as_mut().ok_or_else(|| failed("the model is not shown yet".to_owned()))?;
- canvas.render(gpu, &mut self.doc, None);
+ canvas.render_finished(gpu, &mut self.doc);
Some(canvas.read_composite(gpu).map_err(|e| failed(e.to_string()))?)
} else {
match scene.slot(part, channel).and_then(Option::as_mut) {
@@ -1146,7 +1146,7 @@ fn waiting_picture(gpu: &procraft_gpu::Gpu, set: &mut TextureSet) -> Result<Vec<
}
};
let canvas = set.canvas.insert(canvas);
- canvas.render(gpu, &mut set.doc, None);
+ canvas.render_finished(gpu, &mut set.doc);
canvas.read_composite(gpu).map_err(|e| e.to_string())
}
diff --git a/crates/gpu/src/canvas.rs b/crates/gpu/src/canvas.rs
index 8d0983c..a21e171 100644
--- a/crates/gpu/src/canvas.rs
+++ b/crates/gpu/src/canvas.rs
@@ -1869,6 +1869,19 @@ impl Canvas {
self.remake.is_some()
}
+ /// Renders until the caches are remade, so the composite is the picture as it is (to read it
+ /// back: a save's, an export's).
+ pub fn render_finished(&mut self, gpu: &Gpu, doc: &mut Document) {
+ self.render(gpu, doc, None);
+ // each render remakes at least one item, so this ends well before the bound
+ for _ in 0..100_000 {
+ if !self.busy() {
+ break;
+ }
+ self.render(gpu, doc, None);
+ }
+ }
+
/// Whether the composite is being made around pictures of what isn't worked on.
pub fn composites_cached(&self) -> bool {
self.caches.is_some()
@@ -2966,9 +2979,10 @@ impl Canvas {
if !smudge_uniforms.data.is_empty() {
gpu.queue.write_buffer(&self.smudge_params, 0, &smudge_uniforms.data);
}
- let dirty = self.dirty.intersect(self.full());
self.make_groups(device, doc.max_depth());
self.ensure_caches(gpu, doc, &mut encoder, &mut uniforms);
+ // after the caches: caches just made want the whole picture composited again
+ let dirty = self.dirty.intersect(self.full());
let device = &gpu.device;
// while caches are remade the composite stays as it was, what changed kept for after
if self.remake.is_none() {
@@ -4892,7 +4906,7 @@ impl Canvas {
}
pub fn composite_thumbnail(&mut self, gpu: &Gpu, doc: &mut Document, max_side: u32) -> Result<Thumbnail, GpuError> {
- self.render(gpu, doc, None);
+ self.render_finished(gpu, doc);
self.sample_view(gpu, &self.composite_views[0], self.full(), max_side)
}
@@ -4983,7 +4997,8 @@ impl Canvas {
DisplayLut { bind: lut_bind(gpu, &self.pipelines.lut_layout, lut.grid as u32, &rgba) }
}
- /// The composite's pixels (premultiplied RGBA8, rows top to bottom). Waits for the GPU.
+ /// The composite's pixels (premultiplied RGBA8, rows top to bottom) as last rendered: after
+ /// [`Canvas::render_finished`], the picture as it is. Waits for the GPU.
pub fn read_composite(&self, gpu: &Gpu) -> Result<Vec<u8>, GpuError> {
read_texture(gpu, &self.composite[0], self.width, self.height)
}
@@ -4996,7 +5011,7 @@ impl Canvas {
doc: &mut Document,
left_out: &[LayerId],
) -> Result<Vec<u8>, GpuError> {
- self.render(gpu, doc, None);
+ self.render_finished(gpu, doc);
if left_out.is_empty() {
return self.read_composite(gpu);
}
@@ -5005,7 +5020,7 @@ impl Canvas {
shown.set_visible(id, false);
}
self.invalidate();
- self.render(gpu, &mut shown, None);
+ self.render_finished(gpu, &mut shown);
let read = self.read_composite(gpu);
self.invalidate();
self.render(gpu, doc, None);
diff --git a/crates/gpu/tests/layers.rs b/crates/gpu/tests/layers.rs
index 45748a4..3875dbd 100644
--- a/crates/gpu/tests/layers.rs
+++ b/crates/gpu/tests/layers.rs
@@ -405,13 +405,18 @@ fn composites_made_around_cached_pictures_match_full_ones() {
// a layer below changed, one above hidden, then another layer worked on (inside the group)
let ids: Vec<LayerId> = t.docs[0].layers().iter().map(|l| l.id).collect();
let multiply = ids[1];
- t.each(|doc, _| {
+ // as the app makes them: an undo step
+ t.each(|doc, canvas| {
+ let before = doc.clone();
doc.set_opacity(multiply, 0.4);
+ canvas.record_document(before);
});
t.same(&gpu, 2, "a layer below changed");
let top = *ids.last().unwrap();
- t.each(|doc, _| {
+ t.each(|doc, canvas| {
+ let before = doc.clone();
doc.set_visible(top, false);
+ canvas.record_document(before);
});
t.same(&gpu, 2, "a layer above hidden");
let green = t.docs[0].layers().iter().find(|l| l.blend == BlendMode::Screen).map(|l| l.id).unwrap();
@@ -514,11 +519,15 @@ fn parked_layers_come_back_as_they_were() {
canvas.duplicate_layer(ids[1], copy, before);
});
t.same(&gpu, 2, "duplicated");
- t.each(|doc, _| {
+ t.each(|doc, canvas| {
+ let before = doc.clone();
doc.set_visible(ids[3], false);
+ canvas.record_document(before);
});
t.same(&gpu, 2, "hidden");
t.each(|_, canvas| canvas.undo());
+ t.same(&gpu, 2, "shown again");
+ t.each(|_, canvas| canvas.undo());
t.same(&gpu, 2, "the duplicate undone");
assert!(t.canvases[0].parked_layers() > 0);
}
@@ -656,3 +665,38 @@ fn empty_and_clipped_layers_cache_as_they_composite() {
}
assert!(t.canvases[0].parked_layers() > 0);
}
+
+#[test]
+fn the_picture_read_back_waits_for_the_caches() {
+ let Some((gpu, _, _)) = setup() else { return };
+ // big enough that remaking the caches takes several renders
+ const SIDE: u32 = 768;
+ let docs = [Document::new(SIDE, SIDE), Document::new(SIDE, SIDE)];
+ let canvases = [Canvas::new(&gpu, &docs[0]).unwrap(), Canvas::new(&gpu, &docs[1]).unwrap()];
+ let mut t = Twins { docs, canvases };
+ t.canvases[0].set_resident_budget(3 * u64::from(SIDE * SIDE * 4));
+ t.each(|doc, canvas| {
+ for i in 0..40u8 {
+ let id = doc.add_layer();
+ let at = Vec2::new(f32::from(i % 8) * 90.0 + 40.0, f32::from(i / 8) * 140.0 + 60.0);
+ paint(canvas, doc, id, [i * 6, 220 - i * 5, 90], at, 70.0, StrokeTool::Paint);
+ }
+ canvas.invalidate();
+ });
+ t.same(&gpu, 2, "made");
+ // a layer low down hidden (an undo step, as the app makes it), then the picture read at once
+ // (as a save does)
+ let low = t.docs[0].layers()[3].id;
+ t.each(|doc, canvas| {
+ let before = doc.clone();
+ doc.set_visible(low, false);
+ canvas.record_document(before);
+ });
+ let mut read = Vec::new();
+ for (doc, canvas) in t.docs.iter_mut().zip(t.canvases.iter_mut()) {
+ read.push(canvas.read_composite_without(&gpu, doc, &[]).unwrap());
+ }
+ let worst = read[0].iter().zip(&read[1]).map(|(a, b)| a.abs_diff(*b)).max().unwrap_or(0);
+ assert!(worst <= 2, "read while the caches are remade: differs by {worst}");
+ assert!(!t.canvases[0].busy());
+}