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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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 afterif 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.rsindex 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());+}