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