Skip to content

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

Rust
42.2 KB
Raw Blame
//! Layers on a real GPU: blend modes, clipping, alpha lock, merge, duplicate, delete and their
//! undo (skipped where the machine has none).
#![allow(clippy::unwrap_used, clippy::indexing_slicing)]

use procraft_engine::document::{BlendMode, Document, LayerId};
use procraft_engine::geom::Vec2;
use procraft_engine::stroke::Stamp;
use procraft_gpu::{Canvas, Filter, Gpu, Resample, StrokeStyle, StrokeTool};

const W: u32 = 16;

fn setup() -> Option<(Gpu, Document, Canvas)> {
    let gpu = match Gpu::headless() {
        Ok(g) => g,
        Err(e) => {
            eprintln!("skipped: {e}");
            return None;
        }
    };
    let doc = Document::new(W, W);
    let canvas = Canvas::new(&gpu, &doc).unwrap();
    Some((gpu, doc, canvas))
}

fn paint(canvas: &mut Canvas, doc: &Document, layer: LayerId, rgb: [u8; 3], at: Vec2, radius: f32, tool: StrokeTool) {
    let color = rgb.map(|c| f32::from(c) / 255.0);
    let preserve_alpha = doc.layer(layer).is_some_and(|l| l.alpha_lock);
    canvas.begin_stroke(layer, StrokeStyle { preserve_alpha, ..StrokeStyle::new(tool, color, 1.0) });
    canvas.add_stamps(&[Stamp::round(at, radius, 1.0)]);
    canvas.end_stroke();
}

/// Covers the whole canvas.
fn fill(canvas: &mut Canvas, doc: &Document, layer: LayerId, rgb: [u8; 3]) {
    paint(canvas, doc, layer, rgb, Vec2::new(8.0, 8.0), 100.0, StrokeTool::Paint);
}

fn composite_at(gpu: &Gpu, doc: &mut Document, canvas: &mut Canvas, x: u32, y: u32) -> [u8; 4] {
    canvas.render(gpu, doc, None);
    assert_eq!(gpu.errors(), 0, "GPU validation errors");
    let px = canvas.read_composite(gpu).unwrap();
    let i = ((y * W + x) * 4) as usize;
    [px[i], px[i + 1], px[i + 2], px[i + 3]]
}

fn layer_at(gpu: &Gpu, doc: &mut Document, canvas: &mut Canvas, id: LayerId, x: u32, y: u32) -> [u8; 4] {
    canvas.render(gpu, doc, None);
    assert_eq!(gpu.errors(), 0, "GPU validation errors");
    let px = canvas.read_layer(gpu, id).unwrap();
    let i = ((y * W + x) * 4) as usize;
    [px[i], px[i + 1], px[i + 2], px[i + 3]]
}

/// The usual compositing definitions on 0..1 values, for opaque colours.
fn reference(mode: BlendMode, b: f32, s: f32) -> f32 {
    match mode {
        BlendMode::Multiply => b * s,
        BlendMode::Screen => b + s - b * s,
        BlendMode::Darken => b.min(s),
        BlendMode::Lighten => b.max(s),
        BlendMode::Difference => (b - s).abs(),
        BlendMode::Exclusion => b + s - 2.0 * b * s,
        BlendMode::Add => (b + s).min(1.0),
        BlendMode::Subtract => (b - s).max(0.0),
        BlendMode::LinearBurn => (b + s - 1.0).max(0.0),
        BlendMode::Overlay => {
            if b <= 0.5 {
                s * 2.0 * b
            } else {
                let t = 2.0 * b - 1.0;
                s + t - s * t
            }
        }
        _ => s,
    }
}

#[test]
fn separable_blend_modes_match_the_definitions() {
    let Some((gpu, mut doc, mut canvas)) = setup() else { return };
    let bottom = doc.current();
    let top = doc.add_layer();
    let (b, s) = ([200u8, 90, 30], [60u8, 140, 250]);
    fill(&mut canvas, &doc, bottom, b);
    fill(&mut canvas, &doc, top, s);
    for mode in [
        BlendMode::Multiply,
        BlendMode::Screen,
        BlendMode::Darken,
        BlendMode::Lighten,
        BlendMode::Difference,
        BlendMode::Exclusion,
        BlendMode::Add,
        BlendMode::Subtract,
        BlendMode::LinearBurn,
        BlendMode::Overlay,
        BlendMode::Normal,
    ] {
        doc.set_blend(top, mode);
        canvas.invalidate();
        let got = composite_at(&gpu, &mut doc, &mut canvas, 8, 8);
        for c in 0..3 {
            let want = (reference(mode, f32::from(b[c]) / 255.0, f32::from(s[c]) / 255.0) * 255.0).round() as i32;
            assert!((i32::from(got[c]) - want).abs() <= 2, "{mode:?} channel {c}: got {} want {want}", got[c]);
        }
        assert_eq!(got[3], 255);
    }
}

#[test]
fn shade_darkens_and_shows_nothing_over_clear() {
    let Some((gpu, mut doc, mut canvas)) = setup() else { return };
    let bottom = doc.current();
    let top = doc.add_layer();
    let (b, s) = ([200u8, 90, 30], [60u8, 140, 250]);
    fill(&mut canvas, &doc, bottom, b);
    fill(&mut canvas, &doc, top, s);
    doc.set_blend(top, BlendMode::Shade);
    canvas.invalidate();
    let got = composite_at(&gpu, &mut doc, &mut canvas, 8, 8);
    for c in 0..3 {
        assert!((i32::from(got[c]) - i32::from(b[c].min(s[c]))).abs() <= 2, "channel {c}: {got:?}");
    }
    // with nothing below it, a shaded layer adds nothing
    doc.set_visible(bottom, false);
    doc.background_visible = false;
    canvas.invalidate();
    let got = composite_at(&gpu, &mut doc, &mut canvas, 8, 8);
    assert!(got[3] <= 1, "{got:?}");
}

#[test]
fn colour_modes_keep_the_backdrop_lightness() {
    let Some((gpu, mut doc, mut canvas)) = setup() else { return };
    let bottom = doc.current();
    let top = doc.add_layer();
    fill(&mut canvas, &doc, bottom, [128, 128, 128]);
    fill(&mut canvas, &doc, top, [255, 0, 0]);
    doc.set_blend(top, BlendMode::Color);
    let [r, g, b, _] = composite_at(&gpu, &mut doc, &mut canvas, 8, 8);
    // red hue at grey's lightness: reddish, and about as light (0.3 r + 0.59 g + 0.11 b ≈ 128)
    assert!(r > g && r > b, "{r} {g} {b}");
    let lum = 0.3 * f32::from(r) + 0.59 * f32::from(g) + 0.11 * f32::from(b);
    assert!((lum - 128.0).abs() < 4.0, "lum {lum}");
    doc.set_blend(top, BlendMode::Luminosity);
    canvas.invalidate();
    let [r, g, b, _] = composite_at(&gpu, &mut doc, &mut canvas, 8, 8);
    assert!(r == g && g == b, "grey stays grey: {r} {g} {b}");
}

#[test]
fn opacity_visibility_and_clipping() {
    let Some((gpu, mut doc, mut canvas)) = setup() else { return };
    let base = doc.current();
    let clipped = doc.add_layer();
    // the base covers the left part only; the clipped layer covers everything
    paint(&mut canvas, &doc, base, [0, 0, 255], Vec2::new(2.0, 8.0), 4.0, StrokeTool::Paint);
    fill(&mut canvas, &doc, clipped, [255, 0, 0]);
    doc.set_clipped(clipped, true);
    canvas.invalidate();
    assert_eq!(composite_at(&gpu, &mut doc, &mut canvas, 2, 8), [255, 0, 0, 255]);
    assert_eq!(composite_at(&gpu, &mut doc, &mut canvas, 14, 8), [255, 255, 255, 255], "clipped away");
    doc.set_opacity(clipped, 0.5);
    canvas.invalidate();
    let [r, _, b, _] = composite_at(&gpu, &mut doc, &mut canvas, 2, 8);
    assert!((126..=129).contains(&r) && (126..=129).contains(&b), "half red over blue: {r} {b}");
    // hiding the base hides what is clipped to it
    doc.set_visible(base, false);
    canvas.invalidate();
    assert_eq!(composite_at(&gpu, &mut doc, &mut canvas, 2, 8), [255, 255, 255, 255]);
}

#[test]
fn alpha_lock_recolours_only_painted_pixels() {
    let Some((gpu, mut doc, mut canvas)) = setup() else { return };
    let layer = doc.current();
    paint(&mut canvas, &doc, layer, [0, 0, 0], Vec2::new(4.0, 4.0), 3.0, StrokeTool::Paint);
    doc.set_alpha_lock(layer, true);
    fill(&mut canvas, &doc, layer, [255, 0, 0]);
    assert_eq!(layer_at(&gpu, &mut doc, &mut canvas, layer, 4, 4), [255, 0, 0, 255]);
    assert_eq!(layer_at(&gpu, &mut doc, &mut canvas, layer, 12, 12)[3], 0, "outside stays empty");
}

#[test]
fn merge_down_and_undo() {
    let Some((gpu, mut doc, mut canvas)) = setup() else { return };
    let lower = doc.current();
    let upper = doc.add_layer();
    fill(&mut canvas, &doc, lower, [200, 200, 200]);
    fill(&mut canvas, &doc, upper, [100, 50, 0]);
    doc.set_blend(upper, BlendMode::Multiply);
    let before = doc.clone();
    canvas.merge_down(upper, lower, before);
    assert!(doc.finish_merge_down(upper));
    assert_eq!(doc.layers().len(), 1);
    let merged = layer_at(&gpu, &mut doc, &mut canvas, lower, 8, 8);
    assert_eq!(merged[..3], [78, 39, 0], "200 × 100 / 255 and so on");
    // the composite is unchanged by merging
    assert_eq!(composite_at(&gpu, &mut doc, &mut canvas, 8, 8)[..3], [78, 39, 0]);

    canvas.undo();
    assert_eq!(layer_at(&gpu, &mut doc, &mut canvas, lower, 8, 8), [200, 200, 200, 255]);
    assert_eq!(doc.layers().len(), 2);
    assert_eq!(layer_at(&gpu, &mut doc, &mut canvas, upper, 8, 8), [100, 50, 0, 255]);
    canvas.redo();
    canvas.render(&gpu, &mut doc, None);
    assert_eq!(doc.layers().len(), 1);
}

#[test]
fn duplicate_delete_and_undo_keep_pixels() {
    let Some((gpu, mut doc, mut canvas)) = setup() else { return };
    let a = doc.current();
    paint(&mut canvas, &doc, a, [0, 255, 0], Vec2::new(8.0, 8.0), 3.0, StrokeTool::Paint);
    let before = doc.clone();
    let b = doc.duplicate_layer(a).unwrap();
    canvas.duplicate_layer(a, b, before);
    assert_eq!(layer_at(&gpu, &mut doc, &mut canvas, b, 8, 8), [0, 255, 0, 255]);

    let before = doc.clone();
    assert!(doc.delete_layer(a));
    canvas.record_document(before);
    canvas.render(&gpu, &mut doc, None);
    assert_eq!(doc.layers().len(), 1);
    // the deleted layer's pixels are kept while undo can bring it back
    assert_eq!(canvas.layer_texture_count(), 2);
    canvas.undo();
    canvas.render(&gpu, &mut doc, None);
    assert_eq!(doc.layers().len(), 2);
    assert_eq!(layer_at(&gpu, &mut doc, &mut canvas, a, 8, 8), [0, 255, 0, 255]);
}

#[test]
fn thumbnails_are_scaled_layers() {
    let Some((gpu, mut doc, mut canvas)) = setup() else { return };
    let a = doc.current();
    fill(&mut canvas, &doc, a, [10, 20, 30]);
    let t = canvas.layer_thumbnail(&gpu, &mut doc, a, 8).unwrap();
    assert_eq!((t.width, t.height), (8, 8));
    assert_eq!(t.rgba.len(), 8 * 8 * 4);
    assert_eq!(t.rgba[..4], [10, 20, 30, 255]);
}

#[test]
fn a_thumbnail_shows_what_is_drawn_never_enlarged() {
    let Some((gpu, mut doc, mut canvas)) = setup() else { return };
    let a = doc.current();
    // a 2 x 3 block near a corner of the 16 x 16 layer
    let mut pixels = vec![0u8; 16 * 16 * 4];
    for (x, y) in [(12, 1), (13, 1), (12, 2), (13, 2), (12, 3), (13, 3)] {
        pixels[(y * 16 + x) * 4..(y * 16 + x) * 4 + 4].copy_from_slice(&[0, 0, 255, 255]);
    }
    canvas.write_layer(a, pixels);
    let t = canvas.layer_thumbnail(&gpu, &mut doc, a, 8).unwrap();
    assert_eq!((t.width, t.height), (2, 3));
    assert!(t.rgba.chunks(4).all(|p| p[3] > 0));
    // an empty layer: the whole canvas, fitted
    let b = doc.add_layer();
    let t = canvas.layer_thumbnail(&gpu, &mut doc, b, 8).unwrap();
    assert_eq!((t.width, t.height), (8, 8));
}

#[test]
fn smudge_drags_colour_and_undoes() {
    let Some((gpu, mut doc, mut canvas)) = setup() else { return };
    let layer = doc.current();
    // red on the left half, blue on the right
    paint(&mut canvas, &doc, layer, [255, 0, 0], Vec2::new(-92.0, 8.0), 100.0, StrokeTool::Paint);
    paint(&mut canvas, &doc, layer, [0, 0, 255], Vec2::new(108.0, 8.0), 100.0, StrokeTool::Paint);
    let before = layer_at(&gpu, &mut doc, &mut canvas, layer, 11, 8);
    assert_eq!(before[..3], [0, 0, 255]);
    // drag from the red into the blue
    let stamps: Vec<Stamp> = (0..30).map(|i| Stamp::round(Vec2::new(2.0 + i as f32 * 0.4, 8.0), 4.0, 1.0)).collect();
    canvas.begin_stroke(layer, StrokeStyle::new(StrokeTool::Smudge, [0.0; 3], 1.0));
    canvas.add_stamps(&stamps);
    let during = layer_at(&gpu, &mut doc, &mut canvas, layer, 11, 8);
    assert!(during[0] > 60, "red carried into the blue: {during:?}");
    canvas.end_stroke();
    canvas.render(&gpu, &mut doc, None);
    assert!(canvas.can_undo());
    canvas.undo();
    assert_eq!(layer_at(&gpu, &mut doc, &mut canvas, layer, 11, 8), before);

    // a cancelled smudge leaves the layer as it was
    canvas.begin_stroke(layer, StrokeStyle::new(StrokeTool::Smudge, [0.0; 3], 1.0));
    canvas.add_stamps(&stamps);
    canvas.render(&gpu, &mut doc, None);
    canvas.cancel_stroke();
    assert_eq!(layer_at(&gpu, &mut doc, &mut canvas, layer, 11, 8), before);
}

#[test]
fn a_held_edit_is_one_undo_step_or_put_back() {
    let Some((gpu, mut doc, mut canvas)) = setup() else { return };
    let a = doc.current();
    fill(&mut canvas, &doc, a, [10, 20, 30]);
    canvas.render(&gpu, &mut doc, None);
    let steps = |c: &Canvas| c.can_undo();
    assert!(steps(&canvas));
    // many puts, kept: one step back to the fill
    let before = doc.clone();
    canvas.hold_layer(a);
    for v in [100u8, 150, 200] {
        canvas.put_layer(a, [v, v, v, 255].repeat((W * W) as usize));
    }
    canvas.release_layer(true, Some(before));
    canvas.render(&gpu, &mut doc, None);
    assert_eq!(layer_at(&gpu, &mut doc, &mut canvas, a, 3, 3), [200, 200, 200, 255]);
    canvas.undo();
    canvas.render(&gpu, &mut doc, None);
    assert_eq!(layer_at(&gpu, &mut doc, &mut canvas, a, 3, 3), [10, 20, 30, 255]);
    // put back: as if nothing happened
    canvas.hold_layer(a);
    canvas.put_layer(a, [9, 9, 9, 255].repeat((W * W) as usize));
    canvas.release_layer(false, None);
    canvas.render(&gpu, &mut doc, None);
    assert_eq!(layer_at(&gpu, &mut doc, &mut canvas, a, 3, 3), [10, 20, 30, 255]);
}

/// The same edits to an artwork composited fully and one composited around caches.
struct Twins {
    docs: [Document; 2],
    canvases: [Canvas; 2],
}

impl Twins {
    fn each(&mut self, f: impl Fn(&mut Document, &mut Canvas)) {
        for (doc, canvas) in self.docs.iter_mut().zip(self.canvases.iter_mut()) {
            f(doc, canvas);
        }
    }

    /// Both composites, every pixel within `slack` of each other (a run of plain layers above is
    /// flattened once, so its 8-bit picture can round a step apart).
    fn same(&mut self, gpu: &Gpu, slack: u8, what: &str) {
        let mut pictures = Vec::new();
        for (doc, canvas) in self.docs.iter_mut().zip(self.canvases.iter_mut()) {
            canvas.render(gpu, doc, None);
            // caches remade and layers parked a little each render: until the caches are, the
            // composite waits
            for _ in 0..1000 {
                if !canvas.wants_render() {
                    break;
                }
                canvas.render(gpu, doc, None);
            }
            assert!(!canvas.wants_render(), "{what}: caches still being remade or layers parked");
            assert_eq!(gpu.errors(), 0, "GPU validation errors");
            pictures.push(canvas.read_composite(gpu).unwrap());
        }
        let worst = pictures[0].iter().zip(&pictures[1]).map(|(a, b)| a.abs_diff(*b)).max().unwrap_or(0);
        assert!(worst <= slack, "{what}: cached composite differs by {worst}");
    }
}

#[test]
fn composites_made_around_cached_pictures_match_full_ones() {
    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);
    // bottom up: red; multiplied blue; a group of green and screened yellow; a masked layer with
    // an overlay clipped to it (worked on); two plain layers at the top
    let base = t.docs[0].current();
    t.each(|doc, canvas| {
        fill(canvas, doc, base, [200, 40, 40]);
        let multiply = doc.add_layer();
        doc.set_blend(multiply, BlendMode::Multiply);
        paint(canvas, doc, multiply, [60, 60, 230], Vec2::new(5.0, 5.0), 4.0, StrokeTool::Paint);
        let green = doc.add_layer();
        paint(canvas, doc, green, [40, 200, 40], Vec2::new(10.0, 6.0), 4.0, StrokeTool::Paint);
        let yellow = doc.add_layer();
        doc.set_blend(yellow, BlendMode::Screen);
        paint(canvas, doc, yellow, [230, 230, 30], Vec2::new(8.0, 10.0), 5.0, StrokeTool::Paint);
        doc.set_current(green);
        doc.toggle_pick(yellow);
        // what comes next goes above the group, not in it
        let group = doc.group_chosen().unwrap();
        doc.set_current(group);
        let masked = doc.add_layer();
        paint(canvas, doc, masked, [250, 250, 250], Vec2::new(8.0, 8.0), 6.0, StrokeTool::Paint);
        let mask = doc.add_mask(masked).unwrap();
        paint(canvas, doc, mask, [0, 0, 0], Vec2::new(4.0, 12.0), 3.0, StrokeTool::Paint);
        let overlay = doc.add_layer();
        doc.set_blend(overlay, BlendMode::Overlay);
        doc.set_clipped(overlay, true);
        fill(canvas, doc, overlay, [30, 120, 220]);
        let plain = doc.add_layer();
        paint(canvas, doc, plain, [255, 140, 0], Vec2::new(3.0, 3.0), 3.0, StrokeTool::Paint);
        doc.set_opacity(plain, 0.6);
        let top = doc.add_layer();
        paint(canvas, doc, top, [20, 20, 20], Vec2::new(13.0, 13.0), 2.0, StrokeTool::Paint);
        doc.set_current(masked);
        canvas.invalidate();
    });
    t.same(&gpu, 2, "as made");
    assert!(t.canvases[0].composites_cached(), "made around caches");
    // painting what is worked on keeps the caches; undoing it too
    let masked = t.docs[0].current();
    t.each(|doc, canvas| paint(canvas, doc, masked, [0, 200, 200], Vec2::new(9.0, 4.0), 3.0, StrokeTool::Paint));
    t.same(&gpu, 2, "painted");
    assert!(t.canvases[0].composites_cached());
    t.each(|_, canvas| canvas.undo());
    t.same(&gpu, 2, "undone");
    // 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];
    // 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, 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();
    t.each(|doc, canvas| {
        doc.set_current(green);
        paint(canvas, doc, green, [255, 0, 255], Vec2::new(6.0, 9.0), 3.0, StrokeTool::Paint);
    });
    t.same(&gpu, 2, "worked on inside the group");
    // the bottom layer worked on: nothing below it but the background
    t.each(|doc, canvas| {
        doc.set_current(base);
        paint(canvas, doc, base, [0, 0, 0], Vec2::new(12.0, 3.0), 2.0, StrokeTool::Erase);
    });
    t.same(&gpu, 2, "the bottom worked on");
    assert!(t.canvases[0].composites_cached());
}

#[test]
fn parked_layers_come_back_as_they_were() {
    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 };
    // room for three layers' textures only: the rest are parked
    t.canvases[0].set_resident_budget(3 * u64::from(W * W * 4));
    let modes = [BlendMode::Normal, BlendMode::Multiply, BlendMode::Screen, BlendMode::Normal, BlendMode::Overlay];
    t.each(|doc, canvas| {
        let base = doc.current();
        fill(canvas, doc, base, [180, 180, 180]);
        for i in 0..9u8 {
            let id = doc.add_layer();
            doc.set_blend(id, modes[usize::from(i) % modes.len()]);
            let at = Vec2::new(f32::from(i % 4) * 4.0 + 2.0, f32::from(i / 4) * 5.0 + 2.0);
            paint(canvas, doc, id, [i * 25, 200 - i * 20, 90], at, 3.0, StrokeTool::Paint);
        }
        canvas.invalidate();
    });
    t.same(&gpu, 2, "made");
    // the composite is made around pictures of the rest, so layers can go
    t.same(&gpu, 2, "made, parked");
    assert!(t.canvases[0].parked_layers() >= 6, "parked: {}", t.canvases[0].parked_layers());
    // a parked layer worked on again, painted, undone and redone
    let ids: Vec<LayerId> = t.docs[0].layers().iter().map(|l| l.id).collect();
    let low = ids[2];
    t.each(|doc, canvas| {
        doc.set_current(low);
        paint(canvas, doc, low, [0, 0, 250], Vec2::new(8.0, 8.0), 4.0, StrokeTool::Paint);
    });
    t.same(&gpu, 2, "a parked layer painted");
    t.each(|_, canvas| canvas.undo());
    t.same(&gpu, 2, "undone");
    t.each(|_, canvas| canvas.redo());
    t.same(&gpu, 2, "redone");
    // its pixels and picture read while parked again, as the other's
    let top = *ids.last().unwrap();
    t.each(|doc, _| {
        doc.set_current(top);
    });
    t.same(&gpu, 2, "the top worked on");
    let read: Vec<Vec<u8>> = t.canvases.iter().map(|c| c.read_layer(&gpu, low).unwrap()).collect();
    assert_eq!(read[0], read[1], "a parked layer reads as it is");
    let mut pictures = Vec::new();
    for (doc, canvas) in t.docs.iter_mut().zip(t.canvases.iter_mut()) {
        pictures.push(canvas.layer_picture(&gpu, doc, low, 8).unwrap().rgba);
    }
    // a parked layer's is box-filtered from its small picture, not sampled on the GPU: the edges
    // soften a little differently
    let near = |a: &[u8], b: &[u8]| {
        let diffs = a.iter().zip(b).map(|(x, y)| u32::from(x.abs_diff(*y)));
        a.len() == b.len() && diffs.clone().max().unwrap_or(0) <= 32 && diffs.sum::<u32>() <= 4 * a.len() as u32
    };
    assert!(near(&pictures[0], &pictures[1]), "its picture");
    let mut thumbs = Vec::new();
    for (doc, canvas) in t.docs.iter_mut().zip(t.canvases.iter_mut()) {
        thumbs.push(canvas.layer_thumbnail(&gpu, doc, low, 8).unwrap());
    }
    // what is drawn on it, cropped a pixel or so differently
    let [a, b] = [&thumbs[0], &thumbs[1]];
    assert!(a.width.abs_diff(b.width) <= 2 && a.height.abs_diff(b.height) <= 2, "its thumbnail");
    assert!(a.rgba.as_chunks::<4>().0.iter().any(|p| p[3] > 0), "something drawn on its thumbnail");
    // every layer's coverage at a point, parked ones too
    for (x, y) in [(2, 2), (8, 8), (13, 9)] {
        let mut alphas = Vec::new();
        for (doc, canvas) in t.docs.iter_mut().zip(t.canvases.iter_mut()) {
            alphas.push(canvas.alphas_at(&gpu, doc, x, y).unwrap());
        }
        assert_eq!(alphas[0], alphas[1], "coverage at {x}, {y}");
    }
    // merged down, duplicated, hidden: the layers they read and write come back first
    let (upper, lower) = (ids[5], ids[4]);
    t.each(|doc, canvas| {
        let before = doc.clone();
        canvas.merge_down(upper, lower, before);
        assert!(doc.finish_merge_down(upper));
    });
    t.same(&gpu, 2, "merged");
    t.each(|doc, canvas| {
        let before = doc.clone();
        let copy = doc.duplicate_layer(ids[1]).unwrap();
        canvas.duplicate_layer(ids[1], copy, before);
    });
    t.same(&gpu, 2, "duplicated");
    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);
}

#[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);
}

#[test]
fn an_animation_keeps_only_the_frames_shown() {
    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_resident_budget(3 * u64::from(W * W * 4));
    t.each(|doc, canvas| {
        let first = doc.current();
        paint(canvas, doc, first, [0, 0, 0], Vec2::new(2.0, 8.0), 2.0, StrokeTool::Paint);
        for i in 1..10u8 {
            let id = doc.add_layer();
            paint(
                canvas,
                doc,
                id,
                [i * 25, 100, 200 - i * 20],
                Vec2::new(2.0 + f32::from(i) * 1.3, 8.0),
                2.0,
                StrokeTool::Paint,
            );
        }
        doc.animation = Some(procraft_engine::animation::Animation { onion_frames: 1, ..Default::default() });
        canvas.invalidate();
    });
    t.same(&gpu, 2, "the last frame");
    t.same(&gpu, 2, "the last frame, the rest parked");
    assert!(t.canvases[0].parked_layers() >= 5, "parked: {}", t.canvases[0].parked_layers());
    let ids: Vec<LayerId> = t.docs[0].layers().iter().map(|l| l.id).collect();
    t.each(|doc, canvas| {
        doc.set_current(ids[3]);
        paint(canvas, doc, ids[3], [255, 255, 0], Vec2::new(8.0, 4.0), 2.0, StrokeTool::Paint);
    });
    t.same(&gpu, 2, "another frame painted");
    for f in [0, 6, 9] {
        t.each(|_, canvas| canvas.set_play_frame(Some(f)));
        t.same(&gpu, 2, "played");
    }
    t.each(|_, canvas| canvas.set_play_frame(None));
    t.same(&gpu, 2, "stopped");
}

#[test]
fn empty_and_clipped_layers_cache_as_they_composite() {
    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_resident_budget(3 * u64::from(W * W * 4));
    t.each(|doc, canvas| {
        let base = doc.current();
        fill(canvas, doc, base, [120, 160, 200]);
        for i in 0..10u8 {
            let id = doc.add_layer();
            match i % 5 {
                // left empty
                0 | 3 => {}
                // clipped to what is under it (painted, or the empty one)
                1 | 4 => {
                    doc.set_clipped(id, true);
                    fill(canvas, doc, id, [250, 40 + i * 20, 40]);
                }
                _ => paint(
                    canvas,
                    doc,
                    id,
                    [i * 20, 90, 200 - i * 15],
                    Vec2::new(3.0 + f32::from(i), 9.0),
                    3.0,
                    StrokeTool::Paint,
                ),
            }
        }
        canvas.invalidate();
    });
    t.same(&gpu, 2, "made");
    t.same(&gpu, 2, "parked");
    let ids: Vec<LayerId> = t.docs[0].layers().iter().map(|l| l.id).collect();
    for current in [ids[0], ids[6], *ids.last().unwrap()] {
        t.each(|doc, canvas| {
            doc.set_current(current);
            paint(canvas, doc, current, [10, 10, 10], Vec2::new(12.0, 4.0), 2.0, StrokeTool::Paint);
        });
        t.same(&gpu, 2, "another layer worked on");
    }
    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());
}

#[test]
fn a_layers_version_changes_with_its_pixels_only() {
    let Some((gpu, mut doc, mut canvas)) = setup() else { return };
    let a = doc.current();
    let b = doc.add_layer();
    canvas.render(&gpu, &mut doc, None);
    let (va, vb) = (canvas.layer_version(a), canvas.layer_version(b));
    paint(&mut canvas, &doc, b, [200, 0, 0], Vec2::new(8.0, 8.0), 3.0, StrokeTool::Paint);
    canvas.render(&gpu, &mut doc, None);
    assert_eq!(canvas.layer_version(a), va, "the other layer's stays");
    let painted = canvas.layer_version(b);
    assert_ne!(painted, vb, "the painted one's is new");
    // hidden, and another chosen: its pixels are as they were
    let before = doc.clone();
    doc.set_visible(b, false);
    canvas.record_document(before);
    doc.set_current(a);
    canvas.render(&gpu, &mut doc, None);
    assert_eq!(canvas.layer_version(b), painted, "hidden and left");
    // shown again, then the stroke undone: new again
    canvas.undo();
    canvas.render(&gpu, &mut doc, None);
    canvas.undo();
    canvas.render(&gpu, &mut doc, None);
    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());
}

#[test]
fn a_render_reads_back_only_a_few_layers_to_park() {
    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 };
    // drawn with room for every layer, so none has a compressed copy yet
    t.each(|doc, canvas| {
        let first = doc.current();
        paint(canvas, doc, first, [0, 0, 0], Vec2::new(2.0, 8.0), 2.0, StrokeTool::Paint);
        for i in 1..12u8 {
            let id = doc.add_layer();
            let at = Vec2::new(1.0 + f32::from(i), 8.0);
            paint(canvas, doc, id, [i * 20, 100, 200 - i * 15], at, 2.0, StrokeTool::Paint);
        }
        canvas.invalidate();
    });
    t.same(&gpu, 2, "made");
    // then room for three, and Animation Assist on: the frames not shown are parked, a few a render
    t.canvases[0].set_resident_budget(3 * u64::from(W * W * 4));
    t.each(|doc, canvas| {
        doc.animation = Some(procraft_engine::animation::Animation { onion_frames: 1, ..Default::default() });
        canvas.invalidate();
    });
    let (doc, canvas) = (&mut t.docs[0], &mut t.canvases[0]);
    canvas.render(&gpu, doc, None);
    let first = canvas.parked_layers();
    assert!((1..=4).contains(&first), "parked in one render: {first}");
    assert!(canvas.wants_render(), "more to park");
    for _ in 0..100 {
        if !canvas.wants_render() {
            break;
        }
        canvas.render(&gpu, doc, None);
    }
    assert!(!canvas.wants_render());
    assert!(canvas.parked_layers() >= 8, "parked in all: {}", canvas.parked_layers());
    t.same(&gpu, 2, "the frames shown, the rest parked");
}

#[test]
fn a_remake_part_composites_a_few_items_at_most() {
    let Some((gpu, _, _)) = setup() else { return };
    let mut doc = Document::new(W, W);
    for _ in 0..39 {
        doc.add_layer();
    }
    let ids: Vec<LayerId> = doc.layers().iter().map(|l| l.id).collect();
    // each layer a short band of its own colour
    let pixels: Vec<Vec<u8>> = (0..ids.len())
        .map(|i| {
            let mut px = vec![0u8; (W * W * 4) as usize];
            let (y, x0) = (i / 8 * 3 + 1, i % 8 * 2);
            for x in x0..x0 + 3 {
                let o = (y * W as usize + x) * 4;
                px[o..o + 4].copy_from_slice(&[(i * 6) as u8, 200 - (i * 4) 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 };
    // room for 30 of the 40, every one kept compressed (as an opening artwork's past what fits):
    // the caches are remade from layers quick to bring back, with room for many a part
    t.canvases[0].set_resident_budget(30 * u64::from(W * W * 4));
    for (id, px) in ids.iter().zip(&pixels) {
        t.canvases[0].park_pixels(*id, px).unwrap();
        t.canvases[1].upload_layer(&gpu, *id, px).unwrap();
    }
    t.same(&gpu, 2, "opened");
    let stats = t.canvases[0].last_remake().unwrap();
    assert!((1..=8).contains(&stats.largest_part), "{stats:?}");
}

#[test]
fn layers_uploaded_with_their_copies_are_let_go_without_reading_them_back() {
    let Some((gpu, _, _)) = setup() else { return };
    let mut doc = Document::new(W, W);
    for _ in 0..11 {
        doc.add_layer();
    }
    let ids: Vec<LayerId> = doc.layers().iter().map(|l| l.id).collect();
    let pixels: Vec<Vec<u8>> = (0..ids.len())
        .map(|i| {
            let mut px = vec![0u8; (W * W * 4) as usize];
            let (y, x0) = (i / 4 * 4 + 2, i % 4 * 4);
            for x in x0..x0 + 3 {
                let o = (y * W as usize + x) * 4;
                px[o..o + 4].copy_from_slice(&[(i * 20) as u8, 200 - (i * 15) 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 };
    // room for 3 of 12, every one uploaded with its compressed copy (as an opening artwork's)
    t.canvases[0].set_resident_budget(3 * u64::from(W * W * 4));
    for (id, px) in ids.iter().zip(&pixels) {
        let ready = procraft_gpu::ReadyToPark::of(px, W, W);
        t.canvases[0].upload_layer_kept(&gpu, *id, px, ready).unwrap();
        t.canvases[1].upload_layer(&gpu, *id, px).unwrap();
    }
    // one render lets all but what fits go: nothing to read back first
    let (doc, canvas) = (&mut t.docs[0], &mut t.canvases[0]);
    canvas.render(&gpu, doc, None);
    assert!(canvas.parked_layers() >= 9, "parked in one render: {}", canvas.parked_layers());
    t.same(&gpu, 2, "opened");
    for (id, px) in ids.iter().zip(&pixels) {
        assert_eq!(&t.canvases[0].read_layer(&gpu, *id).unwrap(), px, "{id:?} as uploaded");
    }
}

#[test]
fn a_remake_lets_go_only_what_its_parts_need_room_for() {
    let Some((gpu, _, _)) = setup() else { return };
    let mut doc = Document::new(W, W);
    for _ in 0..39 {
        doc.add_layer();
    }
    let ids: Vec<LayerId> = doc.layers().iter().map(|l| l.id).collect();
    let pixels: Vec<Vec<u8>> = (0..ids.len())
        .map(|i| {
            let mut px = vec![0u8; (W * W * 4) as usize];
            let (y, x0) = (i / 8 * 3 + 1, i % 8 * 2);
            for x in x0..x0 + 3 {
                let o = (y * W as usize + x) * 4;
                px[o..o + 4].copy_from_slice(&[(i * 6) as u8, 200 - (i * 4) 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 };
    // room for 30 of the 40, every one uploaded with its compressed copy: the caches are remade
    // (40 needed), and of the clean textures only what the parts need room for goes
    t.canvases[0].set_resident_budget(30 * u64::from(W * W * 4));
    for (id, px) in ids.iter().zip(&pixels) {
        let ready = procraft_gpu::ReadyToPark::of(px, W, W);
        t.canvases[0].upload_layer_kept(&gpu, *id, px, ready).unwrap();
        t.canvases[1].upload_layer(&gpu, *id, px).unwrap();
    }
    t.same(&gpu, 2, "opened");
    assert!(t.canvases[0].last_remake().is_some(), "remade");
    let parked = t.canvases[0].parked_layers();
    assert!(parked <= 26, "parked {parked}: most that fit stay");
}

/// What the GPU's allocator holds, bytes, once the work sent so far is done; none where the
/// backend gives no report.
fn allocated(gpu: &Gpu) -> Option<u64> {
    gpu.flush();
    gpu.device.generate_allocator_report().map(|r| r.total_allocated_bytes)
}

#[test]
fn a_canvas_makes_its_scratch_and_second_composite_only_once_wanted() {
    let Some(gpu) = Gpu::headless().ok() else { return eprintln!("skipped: no GPU") };
    let side = 1024u32;
    let mut doc = Document::new(side, side);
    // the first canvas makes the device's pipelines; the second is measured
    let _first = Canvas::new(&gpu, &doc).unwrap();
    let before = allocated(&gpu);
    let mut canvas = Canvas::new(&gpu, &doc).unwrap();
    canvas.render(&gpu, &mut doc, None);
    let per = u64::from(side * side);
    // the layer, the composite and the stroke (half floats), the brush images and the small ones
    let brushes = canvas.textures().iter().filter(|t| t.depth_or_array_layers() > 1).count();
    assert_eq!(brushes, 2);
    let images = procraft_gpu::textures_bytes(
        &canvas.textures().into_iter().filter(|t| t.depth_or_array_layers() > 1).collect::<Vec<_>>(),
    );
    let small = 256 * 4 + 1;
    assert_eq!(canvas.texture_bytes(), per * (4 + 4 + 8) + images + small);
    // the allocator agrees, give or take its rounding of the small ones and the buffers
    if let (Some(a), Some(b)) = (before, allocated(&gpu)) {
        let made = b.saturating_sub(a);
        assert!(
            made.abs_diff(canvas.texture_bytes()) < 2 << 20,
            "allocated {made}, counted {}",
            canvas.texture_bytes()
        );
    }
    // a layer of a blend mode wants the composite's second texture, a stroke by a mode the scratch
    let id = doc.current();
    doc.set_blend(id, BlendMode::Multiply);
    canvas.invalidate();
    canvas.render(&gpu, &mut doc, None);
    assert_eq!(canvas.texture_bytes(), per * (4 + 4 + 4 + 8) + images + small);
    let by_mode = StrokeStyle { blend: 1, ..StrokeStyle::new(StrokeTool::Paint, [1.0, 0.0, 0.0], 1.0) };
    canvas.begin_stroke(id, by_mode);
    canvas.add_stamps(&[Stamp::round(Vec2::new(8.0, 8.0), 4.0, 1.0)]);
    canvas.end_stroke();
    canvas.render(&gpu, &mut doc, None);
    // the stroke's undo snapshot besides
    let undo = 16 * 16 * 4;
    assert!(canvas.texture_bytes() >= per * (4 + 4 + 4 + 4 + 8) + images + small + undo);
    assert_eq!(gpu.errors(), 0);
}

/// What the GPU's allocator holds aside, used or not, bytes, once the work sent so far is done;
/// none where the backend gives no report.
fn reserved(gpu: &Gpu) -> Option<u64> {
    gpu.flush();
    gpu.device.generate_allocator_report().map(|r| r.total_reserved_bytes)
}

#[test]
fn the_gpu_memory_set_aside_stays_near_what_is_used() {
    let Some(gpu) = Gpu::headless().ok() else { return eprintln!("skipped: no GPU") };
    let side = 2048u32;
    let mut doc = Document::new(side, side);
    let mut canvas = Canvas::new(&gpu, &doc).unwrap();
    canvas.render(&gpu, &mut doc, None);
    let (Some(used), Some(held)) = (allocated(&gpu), reserved(&gpu)) else { return };
    // a canvas's textures (some 76 MB at this size) in blocks of 64 MB at most, not 128 to 256
    assert!(held <= used + (96 << 20), "{} MB held for {} MB", held >> 20, used >> 20);
    // the first read back of a few bytes sets aside a few MB the CPU can see, not 64
    let before = reserved(&gpu).unwrap_or(0);
    let mut small = Document::new(2, 2);
    let mut tiny = Canvas::new(&gpu, &small).unwrap();
    tiny.render(&gpu, &mut small, None);
    let between = reserved(&gpu).unwrap_or(0);
    assert_eq!(tiny.read_composite(&gpu).unwrap().len(), 16);
    let after = reserved(&gpu).unwrap_or(0);
    assert!(after.saturating_sub(between) <= 8 << 20, "{} MB for a read back", (after - between) >> 20);
    assert!(between >= before);
    assert_eq!(gpu.errors(), 0);
}