Skip to content

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

Rust

feat(gpu): caches are remade a part at a time when they need more layers than fit, and an opening artwork parks what doesn't

Josh3cc1cf0e763c
diff --git a/crates/gpu/src/canvas.rs b/crates/gpu/src/canvas.rs
index be3d450..14b77f3 100644
--- a/crates/gpu/src/canvas.rs
+++ b/crates/gpu/src/canvas.rs
@@ -2895,6 +2895,9 @@ impl Canvas {
self.collect_layers(doc);
}
+ 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);
@@ -2914,9 +2917,6 @@ impl Canvas {
if !uniforms.data.is_empty() {
gpu.queue.write_buffer(&self.uniform_buffer, 0, &uniforms.data);
}
- if !smudge_uniforms.data.is_empty() {
- gpu.queue.write_buffer(&self.smudge_params, 0, &smudge_uniforms.data);
- }
gpu.queue.submit([encoder.finish()]);
self.renders = self.renders.wrapping_add(1);
self.park_extra(gpu, doc);
@@ -3819,6 +3819,39 @@ impl Canvas {
if remake_above {
needed.extend(above_items.iter().flat_map(|t| item_layers(doc, *t)));
}
+ let most = self.most_resident();
+ let missing = needed.iter().filter(|id| !self.layers.contains_key(*id)).count();
+ if self.layers.len().saturating_add(missing) > most {
+ // more than fit: the work so far is sent first, so what is cached is made from it, then
+ // the caches a part at a time, each part's layers let go before the next comes back
+ let done =
+ std::mem::replace(encoder, device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default()));
+ if !uniforms.data.is_empty() {
+ gpu.queue.write_buffer(&self.uniform_buffer, 0, &uniforms.data);
+ }
+ gpu.queue.submit([done.finish()]);
+ *uniforms = UniformData::default();
+ let mut keep: HashSet<LayerId> =
+ tops.get(live.clone()).unwrap_or_default().iter().flat_map(|t| item_layers(doc, *t)).collect();
+ keep.extend(tops.get(live.start).and_then(|first| doc.clip_base(*first)));
+ keep.extend(self.active.map(|a| a.layer));
+ keep.extend(self.held.as_ref().map(|h| h.layer));
+ self.restore_all(gpu, keep.iter().copied().collect::<Vec<_>>(), false);
+ if remake_below {
+ self.stream_cache(gpu, doc, &caches.below, &caches.below_views, &below_items, true, &keep);
+ caches.below_items = below_items;
+ caches.below_key = below_key;
+ }
+ if remake_above {
+ self.stream_cache(gpu, doc, &caches.above, &caches.above_views, &above_items, false, &keep);
+ caches.above_items = above_items;
+ caches.above_key = above_key;
+ }
+ caches.live = tops.get(live).unwrap_or_default().to_vec();
+ caches.live_layers = caches.live.iter().flat_map(|t| item_layers(doc, *t)).collect();
+ self.caches = Some(caches);
+ return;
+ }
self.restore_all(gpu, needed, false);
if remake_below {
let [r, g, b] = doc.background;
@@ -3857,6 +3890,103 @@ impl Canvas {
self.caches = Some(caches);
}
+ /// How many layers' textures fit the budget (any number without one).
+ fn most_resident(&self) -> usize {
+ let per = u64::from(self.width) * u64::from(self.height) * 4;
+ if self.resident_budget == 0 {
+ usize::MAX
+ } else {
+ usize::try_from(self.resident_budget / per.max(1)).unwrap_or(usize::MAX).max(1)
+ }
+ }
+
+ /// Lets go of the textures of layers unchanged since parked (their compressed copies kept),
+ /// but those in `keep`.
+ fn let_go_clean(&mut self, keep: &HashSet<LayerId>) {
+ let parked = &self.parked;
+ self.layers.retain(|id, _| keep.contains(id) || !parked.contains_key(id));
+ }
+
+ /// `items` composited onto a cache's pair of textures (over the background if `background`,
+ /// else over transparency) a part at a time: each part's layers brought back, composited and
+ /// sent, then let go (but `keep`) before the next part's come back.
+ #[allow(clippy::too_many_arguments)]
+ fn stream_cache(
+ &mut self,
+ gpu: &Gpu,
+ doc: &Document,
+ textures: &[wgpu::Texture; 2],
+ views: &[wgpu::TextureView; 2],
+ items: &[LayerId],
+ background: bool,
+ keep: &HashSet<LayerId>,
+ ) {
+ let device = &gpu.device;
+ let full = self.full();
+ let new_encoder =
+ || device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("cache part") });
+ let mut encoder = new_encoder();
+ let mut uniforms = UniformData::default();
+ {
+ let [r, g, b] = doc.background;
+ let solid = if background && doc.background_visible { [r, g, b, 1.0] } else { [0.0; 4] };
+ let offset = uniforms.push(&LayerUniform { opacity: 1.0, solid, ..Default::default() });
+ let mut pass = render_pass(&mut encoder, "cache", &views[0], wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT));
+ pass.set_pipeline(&self.pipelines.solid);
+ pass.set_bind_group(0, &self.stroke_bind, &[]);
+ pass.set_bind_group(1, &self.uniform_bind, &[offset]);
+ pass.draw(0..3, 0..1);
+ }
+ let stack = Stack { textures, views };
+ let mut current = 0;
+ let room = self.most_resident().saturating_sub(self.layers.len()).max(1);
+ let mut at = 0;
+ while at < items.len() {
+ // as many whole items as fit (at least one)
+ let mut part = Vec::new();
+ let mut layers = Vec::new();
+ while let Some(&item) = items.get(at) {
+ let more = item_layers(doc, item);
+ if !part.is_empty() && layers.len() + more.len() > room {
+ break;
+ }
+ layers.extend(more);
+ part.push(item);
+ at += 1;
+ }
+ self.restore_all(gpu, layers, false);
+ self.composite_items(device, doc, &mut encoder, &mut uniforms, full, &part, true, &stack, &mut current);
+ if !uniforms.data.is_empty() {
+ gpu.queue.write_buffer(&self.uniform_buffer, 0, &uniforms.data);
+ }
+ gpu.queue.submit([std::mem::replace(&mut encoder, new_encoder()).finish()]);
+ uniforms = UniformData::default();
+ self.let_go_clean(keep);
+ gpu.flush();
+ }
+ stack.settle(&mut encoder, full, current);
+ gpu.queue.submit([encoder.finish()]);
+ }
+
+ /// Whether another layer's texture fits the budget.
+ pub fn has_room(&self) -> bool {
+ self.layers.len() < self.most_resident()
+ }
+
+ /// Keeps layer `id`'s pixels (premultiplied RGBA, the canvas's size) compressed, without a
+ /// texture, as a layer parked: for an artwork opening with more layers than fit.
+ pub fn park_pixels(&mut self, id: LayerId, rgba: &[u8]) -> Result<(), GpuError> {
+ let expected = self.width as usize * self.height as usize * 4;
+ if rgba.len() != expected {
+ return Err(GpuError::Readback(format!("layer {id:?}: {} bytes, expected {expected}", rgba.len())));
+ }
+ self.layers.remove(&id);
+ self.parked.insert(id, procraft_engine::applz4::encode(rgba));
+ self.caches = None;
+ self.invalidate();
+ Ok(())
+ }
+
/// Whether work keeps the caches: painting, or undoing or redoing it, on a layer worked on.
fn keeps_caches(&self, op: &Op, live: &HashSet<LayerId>) -> bool {
let only_live = |step: Option<&Step>| {
diff --git a/crates/gpu/tests/layers.rs b/crates/gpu/tests/layers.rs
index 2c1a773..cd26ca2 100644
--- a/crates/gpu/tests/layers.rs
+++ b/crates/gpu/tests/layers.rs
@@ -492,3 +492,49 @@ fn parked_layers_come_back_as_they_were() {
t.same(&gpu, 2, "the duplicate undone");
assert!(t.canvases[0].parked_layers() > 0);
}
+
+#[test]
+fn an_artwork_opening_with_more_layers_than_fit_parks_the_rest() {
+ let Some((gpu, _, _)) = setup() else { return };
+ let mut doc = Document::new(W, W);
+ for _ in 0..9 {
+ doc.add_layer();
+ }
+ let ids: Vec<LayerId> = doc.layers().iter().map(|l| l.id).collect();
+ // each layer a band of its own colour, half covering
+ let pixels: Vec<Vec<u8>> = (0..ids.len())
+ .map(|i| {
+ let mut px = vec![0u8; (W * W * 4) as usize];
+ for y in 0..W as usize {
+ for x in 0..W as usize {
+ if (x + y + i) % 3 != 0 {
+ let o = (y * W as usize + x) * 4;
+ px[o..o + 4].copy_from_slice(&[(i * 25) as u8, 200 - (i * 20) as u8, 90, 255]);
+ }
+ }
+ }
+ px
+ })
+ .collect();
+ let docs = [doc.clone(), doc];
+ 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(W * W * 4));
+ for (id, px) in ids.iter().zip(&pixels) {
+ if t.canvases[0].has_room() {
+ t.canvases[0].upload_layer(&gpu, *id, px).unwrap();
+ } else {
+ t.canvases[0].park_pixels(*id, px).unwrap();
+ }
+ t.canvases[1].upload_layer(&gpu, *id, px).unwrap();
+ }
+ assert!(t.canvases[0].parked_layers() >= 6);
+ t.same(&gpu, 2, "opened");
+ let middle = ids[5];
+ t.each(|doc, canvas| {
+ doc.set_current(middle);
+ paint(canvas, doc, middle, [250, 0, 0], Vec2::new(8.0, 8.0), 3.0, StrokeTool::Paint);
+ });
+ t.same(&gpu, 2, "one opened parked, painted");
+ assert!(t.canvases[0].parked_layers() > 0);
+}