Skip to content

armgit / klad

Public Imported from GitHub
0

A drawing app built for agent/human collaboration

Rust
66.5 KB
Raw Blame
pub mod align;
pub mod aseprite;
pub mod assets;
pub mod effects;
pub mod export;
pub mod fonts;
pub mod form;
pub mod gif;
pub mod onion;
pub mod overlay;
pub mod pixelise;
pub mod pngwrite;
pub mod shapes;
pub mod sheet;
pub mod shift;
pub mod sprites;
pub mod text;
pub mod vector;

pub const RENDER_VERSION: u32 = 2;

use anyhow::{Context, Result, anyhow, bail};
use effects::{Img, Space};
use klad_brush::{Raster, TILE};
use klad_core::color::parse_hex;
use klad_core::doc::{Blend, Document, Kind, Layer, LayerContent};
use klad_core::fill::FillRef;
use klad_core::look::{self, Adjustment, Effect};
use klad_core::rng::{FNV_OFFSET, fnv};
use onion::Onions;
use rayon::prelude::*;
use skia_safe::{
    AlphaType, BlendMode, Canvas, Color4f, ColorSpace, ColorType, Data, FilterMode, IRect, Image, ImageInfo,
    MipmapMode, Paint, Pixmap, Rect, SamplingOptions, canvas::SaveLayerRec, image::CachingHint, images, png_encoder,
    surfaces,
};
use std::collections::BTreeMap;

pub type Rasters = BTreeMap<String, Raster>;

pub struct Frame {
    pub width: u32,
    pub height: u32,
    pub rgba: Vec<u8>,
}

impl Frame {
    pub fn hash(&self) -> u64 {
        fnv(FNV_OFFSET, &self.rgba)
    }

    pub fn tiled(&self, times: u32) -> Frame {
        let times = times.max(1) as usize;
        let row = self.width as usize * 4;
        let rgba = (0..self.height as usize * times)
            .flat_map(|y| {
                let line = &self.rgba[(y % self.height as usize) * row..][..row];
                (0..times).flat_map(move |_| line.iter().copied())
            })
            .collect();
        Frame {
            width: self.width * times as u32,
            height: self.height * times as u32,
            rgba,
        }
    }

    pub fn png(&mut self) -> Result<Vec<u8>> {
        let info = rgba8_info(self.width, self.height);
        let pixmap =
            Pixmap::new(&info, &mut self.rgba, self.width as usize * 4).ok_or_else(|| anyhow!("bad pixmap"))?;
        let mut options = png_encoder::Options::default();
        options.z_lib_level = 2;
        options.filter_flags = png_encoder::FilterFlag::SUB;
        let mut out = Vec::new();
        if !png_encoder::encode(&pixmap, &mut out, &options) {
            return Err(anyhow!("PNG encoding failed"));
        }
        Ok(out)
    }

    pub fn pixel(&self, x: u32, y: u32) -> [u8; 4] {
        let at = ((y * self.width + x) * 4) as usize;
        [self.rgba[at], self.rgba[at + 1], self.rgba[at + 2], self.rgba[at + 3]]
    }
}

pub(crate) fn f16_info(width: u32, height: u32) -> ImageInfo {
    ImageInfo::new(
        (width as i32, height as i32),
        ColorType::RGBAF16,
        AlphaType::Premul,
        ColorSpace::new_srgb(),
    )
}

pub(crate) fn rgba8_info(width: u32, height: u32) -> ImageInfo {
    ImageInfo::new(
        (width as i32, height as i32),
        ColorType::RGBA8888,
        AlphaType::Unpremul,
        ColorSpace::new_srgb(),
    )
}

fn blend_mode(blend: Blend) -> BlendMode {
    match blend {
        Blend::Normal => BlendMode::SrcOver,
        Blend::Multiply => BlendMode::Multiply,
        Blend::Screen => BlendMode::Screen,
        Blend::Overlay => BlendMode::Overlay,
        Blend::Add => BlendMode::Plus,
        Blend::ColorDodge => BlendMode::ColorDodge,
        Blend::SoftLight => BlendMode::SoftLight,
        Blend::HardLight => BlendMode::HardLight,
        Blend::Lighten => BlendMode::Lighten,
        Blend::Darken => BlendMode::Darken,
        Blend::Color => BlendMode::Color,
        Blend::Luminosity => BlendMode::Luminosity,
    }
}

pub(crate) fn background(hex: Option<&str>) -> Result<Color4f> {
    match hex {
        Some(hex) if hex != "none" => {
            let [r, g, b, a] = parse_hex(hex)?;
            Ok(Color4f::new(r, g, b, a))
        }
        _ => Ok(Color4f::new(0.0, 0.0, 0.0, 0.0)),
    }
}

fn tile_image(tile: &[half::f16]) -> Result<Image> {
    let bytes: &[u8] = bytemuck::cast_slice(tile);
    images::raster_from_data(&f16_info(TILE as u32, TILE as u32), Data::new_copy(bytes), TILE * 8)
        .ok_or_else(|| anyhow!("cannot wrap tile"))
}

fn draw_data(canvas: &Canvas, tile: &[half::f16], index: usize, cols: usize) -> Result<()> {
    let (tx, ty) = (index % cols, index / cols);
    canvas.draw_image(tile_image(tile)?, ((tx * TILE) as f32, (ty * TILE) as f32), None);
    Ok(())
}

fn draw_tile(canvas: &Canvas, raster: &Raster, index: usize) -> Result<()> {
    raster
        .at(index)
        .map_or(Ok(()), |tile| draw_data(canvas, tile, index, raster.cols))
}

fn tiles_in(cols: usize, rows: usize, area: IRect) -> Vec<usize> {
    let t = TILE as i32;
    if area.is_empty() || cols == 0 || rows == 0 {
        return Vec::new();
    }
    let (x0, y0) = (area.left.div_euclid(t).max(0), area.top.div_euclid(t).max(0));
    let x1 = (area.right - 1).div_euclid(t).min(cols as i32 - 1);
    let y1 = (area.bottom - 1).div_euclid(t).min(rows as i32 - 1);
    (y0..=y1)
        .flat_map(|ty| (x0..=x1).map(move |tx| ty as usize * cols + tx as usize))
        .collect()
}

pub fn raster_image(raster: &Raster) -> Result<Image> {
    let (w, h) = (raster.width as usize, raster.height as usize);
    let mut pixels = vec![half::f16::ZERO; w * h * 4];
    raster.occupied().for_each(|(index, tile)| {
        let (x0, y0) = ((index % raster.cols) * TILE, (index / raster.cols) * TILE);
        let cols = TILE.min(w - x0);
        (0..TILE.min(h - y0)).for_each(|row| {
            let to = ((y0 + row) * w + x0) * 4;
            pixels[to..to + cols * 4].copy_from_slice(&tile[row * TILE * 4..row * TILE * 4 + cols * 4]);
        });
    });
    images::raster_from_data(
        &f16_info(raster.width, raster.height),
        Data::new_copy(bytemuck::cast_slice(&pixels)),
        w * 8,
    )
    .ok_or_else(|| anyhow!("cannot wrap a {w}x{h} raster"))
}

fn draw_raster(canvas: &Canvas, raster: &Raster, ctx: Ctx) -> Result<()> {
    if ctx.detail != 1.0 {
        canvas.save();
        canvas.scale((1.0 / ctx.detail, 1.0 / ctx.detail));
        let drawn = draw_raster(
            canvas,
            raster,
            Ctx {
                detail: 1.0,
                sampling: None,
                ..ctx
            },
        );
        canvas.restore();
        return drawn;
    }
    match (ctx.area, ctx.sampling) {
        (Some(area), _) => tiles_in(raster.cols, raster.rows, area)
            .into_iter()
            .try_for_each(|i| draw_tile(canvas, raster, i)),
        (None, Some(sampling)) => {
            if raster.count() > 0 {
                let image = raster_image(raster)?;
                let image = match sampling.use_cubic || sampling.mipmap == MipmapMode::None {
                    true => image,
                    false => image
                        .with_default_mipmaps()
                        .ok_or_else(|| anyhow!("cannot build mipmaps"))?,
                };
                canvas.draw_image_with_sampling_options(image, (0, 0), sampling, None);
            }
            Ok(())
        }
        (None, None) => raster
            .occupied()
            .try_for_each(|(index, _)| draw_tile(canvas, raster, index)),
    }
}

pub type SwapTiles = BTreeMap<usize, Option<Vec<half::f16>>>;

#[derive(Clone, Copy)]
pub struct Swap<'a> {
    pub cel: &'a str,
    pub cols: usize,
    pub rows: usize,
    pub tiles: &'a SwapTiles,
}

#[derive(Clone, Copy)]
pub struct Ctx<'a> {
    pub frame: u32,
    pub rasters: &'a Rasters,
    pub area: Option<IRect>,
    pub swap: Option<Swap<'a>>,
    pub sampling: Option<SamplingOptions>,
    pub onions: Option<&'a Onions>,
    pub flat: bool,
    pub doc: Option<&'a Document>,
    pub references: bool,
    pub detail: f32,
}

impl<'a> Ctx<'a> {
    pub fn full(frame: u32, rasters: &'a Rasters) -> Self {
        Self {
            frame,
            rasters,
            area: None,
            swap: None,
            sampling: None,
            onions: None,
            flat: true,
            doc: None,
            references: false,
            detail: 1.0,
        }
    }

    fn nested(self) -> Self {
        Self { flat: false, ..self }
    }

    fn effects(self, layer: &Layer) -> std::borrow::Cow<'_, [Effect]> {
        match self.doc {
            Some(doc) => doc.effects_of(layer),
            None => std::borrow::Cow::Borrowed(&layer.effects),
        }
    }

    fn shows(self, layer: &Layer) -> bool {
        layer.visible && (self.references || !layer.reference)
    }
}

fn layer_paint(opacity: f32, blend: Blend) -> Paint {
    let mut paint = Paint::default();
    paint.set_alpha_f(opacity);
    paint.set_blend_mode(blend_mode(blend));
    paint
}

fn layer_paint_isolated(canvas: &Canvas, opacity: f32, blend: Blend) {
    canvas.save_layer(&SaveLayerRec::default().paint(&layer_paint(opacity, blend)));
}

fn mode_layer(canvas: &Canvas, mode: BlendMode) {
    let mut paint = Paint::default();
    paint.set_blend_mode(mode);
    canvas.save_layer(&SaveLayerRec::default().paint(&paint));
}

fn clip_groups<'a>(layers: impl IntoIterator<Item = &'a Layer>) -> Vec<(&'a Layer, Vec<&'a Layer>)> {
    layers.into_iter().fold(Vec::new(), |mut out, layer| {
        match out.last_mut() {
            Some((_, clipped)) if layer.clip => clipped.push(layer),
            _ => out.push((layer, Vec::new())),
        }
        out
    })
}

pub fn draw_layers(canvas: &Canvas, layers: &[Layer], ctx: Ctx) -> Result<()> {
    let groups = clip_groups(layers);
    let reads = groups.iter().any(|(base, _)| ctx.shows(base) && base.reads_under());
    let draw = |c: &Canvas, x: Ctx| {
        groups
            .iter()
            .try_for_each(|(base, clipped)| draw_clipped(c, base, clipped, x))
    };
    match reads && !ctx.flat {
        true => effected(canvas, ctx, &[], None, 1.0, Blend::Normal, &draw),
        false => draw(canvas, ctx),
    }
}

fn draw_onions<'a>(canvas: &Canvas, layers: impl Iterator<Item = &'a Layer>, ctx: Ctx) -> Result<()> {
    let Some(onions) = ctx.onions else {
        return Ok(());
    };
    layers
        .filter_map(|l| onions.get(&l.id))
        .try_for_each(|r| draw_raster(canvas, r, ctx))
}

fn occupied_in(raster: &Raster, window: IRect) -> bool {
    tiles_in(raster.cols, raster.rows, window)
        .into_iter()
        .any(|i| raster.at(i).is_some())
}

fn ghosted(layer: &Layer, ctx: Ctx, window: IRect) -> bool {
    ctx.onions
        .and_then(|o| o.get(&layer.id))
        .is_some_and(|r| occupied_in(r, window))
}

fn may_draw(layer: &Layer, ctx: Ctx, window: IRect) -> bool {
    if !ctx.shows(layer) {
        return false;
    }
    if layer.keyed(ctx.frame).1.is_some() || layer.reads_under() {
        return true;
    }
    let reach = effects::margin(&ctx.effects(layer), 1.0);
    let window = window.with_outset((reach, reach));
    ghosted(layer, ctx, window)
        || match &layer.content {
            LayerContent::Group { children } => children.iter().any(|c| may_draw(c, ctx, window)),
            LayerContent::Adjust { .. } => true,
            LayerContent::Bones {} => false,
            LayerContent::Paint { .. } | LayerContent::Vector { .. } => {
                layer.content_at(ctx.frame).is_some_and(|cel| {
                    let swapped = ctx.swap.filter(|s| s.cel == cel.id).is_some_and(|s| {
                        tiles_in(s.cols, s.rows, window)
                            .into_iter()
                            .any(|i| matches!(s.tiles.get(&i), Some(Some(_))))
                    });
                    swapped
                        || ctx
                            .rasters
                            .get(&cel.id)
                            .map_or(layer.kind() == Kind::Vector, |r| occupied_in(r, window))
                })
            }
        }
}

fn draw_clipped(canvas: &Canvas, base: &Layer, clipped: &[&Layer], ctx: Ctx) -> Result<()> {
    if !ctx.shows(base) {
        return Ok(());
    }
    if ctx.detail == 1.0
        && let Some(area) = ctx.area
        && !may_draw(base, ctx, area)
        && clipped.iter().all(|l| !ghosted(l, ctx, area))
    {
        return Ok(());
    }
    if base.reads_under() {
        return match ctx.flat {
            true => adjust_under(canvas, base, ctx),
            false => Ok(()),
        };
    }
    let shown: Vec<&Layer> = clipped.iter().copied().filter(|l| ctx.shows(l)).collect();
    draw_onions(canvas, std::iter::once(base).chain(shown.iter().copied()), ctx)?;
    let effects = ctx.effects(base);
    if !effects.is_empty() || shown.iter().any(|l| l.reads_under()) {
        return effected(
            canvas,
            ctx,
            &effects,
            Some(base),
            base.keyed(ctx.frame).0,
            base.blend,
            &|c, x| draw_unit(c, base, &shown, x),
        )
        .with_context(|| format!("layer {}", base.id));
    }
    if shown.is_empty() {
        return draw_layer(canvas, base, ctx);
    }
    let inner = ctx.nested();
    layer_paint_isolated(canvas, base.keyed(ctx.frame).0, base.blend);
    let drawn = draw_content(canvas, base, inner)
        .and_then(|_| shown.iter().try_for_each(|layer| draw_clip(canvas, base, layer, inner)));
    canvas.restore();
    drawn
}

pub(crate) fn draw_clipped_alone(canvas: &Canvas, base: &Layer, layer: &Layer, ctx: Ctx) -> Result<()> {
    layer_paint_isolated(canvas, layer.keyed(ctx.frame).0, Blend::Normal);
    let drawn = draw_styled(canvas, layer, ctx).and_then(|_| {
        mode_layer(canvas, BlendMode::DstIn);
        let base_drawn = draw_content(canvas, base, ctx.nested());
        canvas.restore();
        base_drawn
    });
    canvas.restore();
    drawn.with_context(|| format!("layer {} clipped to {}", layer.id, base.id))
}

fn draw_clip(canvas: &Canvas, base: &Layer, layer: &Layer, ctx: Ctx) -> Result<()> {
    layer_paint_isolated(canvas, layer.keyed(ctx.frame).0, layer.blend);
    let drawn = draw_styled(canvas, layer, ctx).and_then(|_| {
        mode_layer(canvas, BlendMode::DstIn);
        let base_drawn = draw_content(canvas, base, ctx);
        canvas.restore();
        base_drawn
    });
    canvas.restore();
    drawn.with_context(|| format!("layer {} clipped to {}", layer.id, base.id))
}

fn draw_unit(canvas: &Canvas, base: &Layer, shown: &[&Layer], ctx: Ctx) -> Result<()> {
    draw_content(canvas, base, ctx.nested())?;
    shown.iter().try_for_each(|layer| match layer.reads_under() {
        true => adjust_under(canvas, layer, ctx),
        false => draw_clip(canvas, base, layer, ctx.nested()),
    })
}

fn draw_styled(canvas: &Canvas, layer: &Layer, ctx: Ctx) -> Result<()> {
    let effects = ctx.effects(layer);
    match effects.is_empty() {
        true => draw_content(canvas, layer, ctx),
        false => effected(canvas, ctx, &effects, Some(layer), 1.0, Blend::Normal, &|c, x| {
            draw_content(c, layer, x)
        }),
    }
}

pub(crate) fn draw_layer(canvas: &Canvas, layer: &Layer, ctx: Ctx) -> Result<()> {
    if layer.reference && !ctx.references {
        return Ok(());
    }
    if layer.reads_under() {
        return match ctx.flat {
            true => adjust_under(canvas, layer, ctx),
            false => Ok(()),
        };
    }
    let effects = ctx.effects(layer);
    let opacity = layer.keyed(ctx.frame).0;
    if !effects.is_empty() {
        return effected(canvas, ctx, &effects, Some(layer), opacity, layer.blend, &|c, x| {
            draw_content(c, layer, x)
        })
        .with_context(|| format!("layer {}", layer.id));
    }
    let isolate = opacity < 1.0 || layer.blend != Blend::Normal || layer.mask_at(ctx.frame).is_some();
    if isolate {
        layer_paint_isolated(canvas, opacity, layer.blend);
    }
    let drawn = draw_content(canvas, layer, ctx);
    if isolate {
        canvas.restore();
    }
    drawn.with_context(|| format!("layer {}", layer.id))
}

fn device_space(canvas: &Canvas) -> Space {
    let matrix = canvas.local_to_device_as_3x3();
    Space {
        scale: matrix.scale_x().abs().max(1e-6),
        tx: matrix.translate_x(),
        ty: matrix.translate_y(),
    }
}

fn canvas_rect(window: IRect, space: Space) -> IRect {
    let to = |v: i32, t: f32| (v as f32 - t) / space.scale;
    IRect::from_ltrb(
        to(window.left, space.tx).floor() as i32,
        to(window.top, space.ty).floor() as i32,
        to(window.right, space.tx).ceil() as i32,
        to(window.bottom, space.ty).ceil() as i32,
    )
}

fn f32_info(width: u32, height: u32) -> ImageInfo {
    ImageInfo::new(
        (width as i32, height as i32),
        ColorType::RGBAF32,
        AlphaType::Premul,
        ColorSpace::new_srgb(),
    )
}

fn read_img(surface: &mut skia_safe::Surface, window: IRect) -> Result<Img> {
    let (w, h) = (window.width() as usize, window.height() as usize);
    let mut px = vec![[0.0f32; 4]; w * h];
    if !surface.read_pixels(
        &f32_info(w as u32, h as u32),
        bytemuck::cast_slice_mut(&mut px),
        w * 16,
        (0, 0),
    ) {
        bail!("cannot read {w}x{h} pixels for effects");
    }
    Ok(Img {
        x: window.left,
        y: window.top,
        w,
        h,
        px,
    })
}

fn img_image(img: &Img) -> Result<Image> {
    images::raster_from_data(
        &f32_info(img.w as u32, img.h as u32),
        Data::new_copy(bytemuck::cast_slice(&img.px)),
        img.w * 16,
    )
    .ok_or_else(|| anyhow!("cannot wrap {}x{} pixels", img.w, img.h))
}

fn offscreen(window: IRect, canvas: &Canvas, ctx: Ctx, draw: &dyn Fn(&Canvas, Ctx) -> Result<()>) -> Result<Img> {
    let (w, h) = (window.width().max(1) as u32, window.height().max(1) as u32);
    let mut surface =
        surfaces::raster(&f16_info(w, h), None, None).ok_or_else(|| anyhow!("cannot allocate {w}x{h} pixels"))?;
    let inner = surface.canvas();
    inner.translate((-window.left as f32, -window.top as f32));
    inner.concat(&canvas.local_to_device_as_3x3());
    let area = ctx.area.map(|_| canvas_rect(window, device_space(canvas)));
    draw(
        inner,
        Ctx {
            area,
            flat: true,
            ..ctx
        },
    )?;
    read_img(&mut surface, window)
}

fn find<'a>(layers: &'a [Layer], id: &str) -> Option<&'a Layer> {
    layers
        .iter()
        .find_map(|l| (l.id == id).then_some(l).or_else(|| find(l.children(), id)))
}

fn painted_cels(layer: &Layer, ctx: Ctx) -> Vec<String> {
    if !ctx.shows(layer) {
        return Vec::new();
    }
    match &layer.content {
        LayerContent::Paint { .. } => layer.content_at(ctx.frame).map(|c| c.id.clone()).into_iter().collect(),
        LayerContent::Group { children } => children.iter().flat_map(|l| painted_cels(l, ctx)).collect(),
        _ => Vec::new(),
    }
}

fn height_at(heights: &klad_brush::tiles::Heights, x: i32, y: i32) -> f32 {
    if x < 0 || y < 0 || x as u32 >= heights.width || y as u32 >= heights.height {
        return 0.0;
    }
    let (x, y) = (x as usize, y as usize);
    heights
        .get(x / TILE, y / TILE)
        .map_or(0.0, |t| t[(y % TILE) * TILE + x % TILE].to_f32())
}

fn sampled_height(heights: &klad_brush::tiles::Heights, cx: f32, cy: f32) -> f32 {
    let (fx, fy) = (cx - 0.5, cy - 0.5);
    let (x, y) = (fx.floor(), fy.floor());
    let (ax, ay) = (fx - x, fy - y);
    let (x, y) = (x as i32, y as i32);
    let top = height_at(heights, x, y) * (1.0 - ax) + height_at(heights, x + 1, y) * ax;
    let bottom = height_at(heights, x, y + 1) * (1.0 - ax) + height_at(heights, x + 1, y + 1) * ax;
    top * (1.0 - ay) + bottom * ay
}

fn height_img(window: IRect, space: Space, layer: &Layer, ctx: Ctx) -> Option<Img> {
    let maps: Vec<&klad_brush::tiles::Heights> = painted_cels(layer, ctx)
        .iter()
        .filter_map(|id| ctx.rasters.get(id).and_then(Raster::heights))
        .collect();
    if maps.is_empty() {
        return None;
    }
    let (w, h) = (window.width().max(0) as usize, window.height().max(0) as usize);
    let taps = ((ctx.detail / space.scale).ceil() as usize).clamp(1, 4);
    let step = ctx.detail / (space.scale * taps as f32);
    let px = (0..h)
        .into_par_iter()
        .flat_map_iter(|row| {
            let maps = &maps;
            (0..w).map(move |col| {
                let (gx, gy) = (window.left + col as i32, window.top + row as i32);
                let (cx, cy) = (
                    (gx as f32 - space.tx) / space.scale * ctx.detail,
                    (gy as f32 - space.ty) / space.scale * ctx.detail,
                );
                let sum: f32 = (0..taps * taps)
                    .map(|k| {
                        let (sx, sy) = (
                            cx + (k % taps) as f32 * step + step * 0.5,
                            cy + (k / taps) as f32 * step + step * 0.5,
                        );
                        maps.iter().map(|m| sampled_height(m, sx, sy)).sum::<f32>()
                    })
                    .sum();
                [sum / (taps * taps) as f32, 0.0, 0.0, 0.0]
            })
        })
        .collect();
    Some(Img {
        x: window.left,
        y: window.top,
        w,
        h,
        px,
    })
}

#[allow(clippy::too_many_arguments)]
fn effected(
    canvas: &Canvas,
    ctx: Ctx,
    list: &[Effect],
    owner: Option<&Layer>,
    opacity: f32,
    blend: Blend,
    draw: &dyn Fn(&Canvas, Ctx) -> Result<()>,
) -> Result<()> {
    let Some(device) = canvas.device_clip_bounds().filter(|d| !d.is_empty()) else {
        return Ok(());
    };
    let space = device_space(canvas);
    let m = effects::margin(list, space.scale);
    let window = device.with_outset((m, m));
    let img = offscreen(window, canvas, ctx, draw)?;
    let by = |id: &str| -> Result<Option<Img>> {
        let Some(layer) = find(ctx.doc.map_or(&[][..], |d| &d.layers[..]), id) else {
            bail!("the displacement layer {id} is gone");
        };
        offscreen(window, canvas, ctx, &|c, x| draw_content(c, layer, x.nested())).map(Some)
    };
    let height = || Ok(owner.and_then(|layer| height_img(window, space, layer, ctx)));
    let (passes, image) = match list.is_empty() {
        true => (Vec::new(), img),
        false => effects::run(list, img, space, &by, &height)?,
    };
    canvas.save();
    canvas.reset_matrix();
    let drawn = passes
        .iter()
        .map(|p| (&p.img, p.blend))
        .chain(std::iter::once((&image, blend)))
        .try_for_each(|(img, mode)| {
            let part = match m {
                0 => img_image(img)?,
                _ => img_image(&img.crop(
                    device.left,
                    device.top,
                    device.width() as usize,
                    device.height() as usize,
                ))?,
            };
            canvas.draw_image(
                part,
                (device.left as f32, device.top as f32),
                Some(&layer_paint(opacity, mode)),
            );
            Ok(())
        });
    canvas.restore();
    drawn
}

fn adjust_under(canvas: &Canvas, layer: &Layer, ctx: Ctx) -> Result<()> {
    let Some(adjust) = layer.adjustment() else {
        return Ok(());
    };
    let prepared = adjust.prepare().with_context(|| format!("layer {}", layer.id))?;
    let size = canvas.base_layer_size();
    let (w, h) = (size.width.max(0) as usize, size.height.max(0) as usize);
    if w == 0 || h == 0 {
        return Ok(());
    }
    let info = f32_info(w as u32, h as u32);
    let mut pixels = vec![[0.0f32; 4]; w * h];
    if !canvas.read_pixels(&info, bytemuck::cast_slice_mut(&mut pixels), w * 16, (0, 0)) {
        bail!("cannot read the pixels under adjustment layer {}", layer.id);
    }
    let mask = match layer.mask_at(ctx.frame) {
        Some((mask, cel)) => {
            let window = IRect::from_wh(w as i32, h as i32);
            let cel = layer_cel(mask, cel);
            let img = offscreen(window, canvas, ctx, &|c, x| draw_paint_cel(c, &cel, x))?;
            Some(img.px.iter().map(|p| p[3]).collect::<Vec<f32>>())
        }
        None => None,
    };
    let (opacity, blend) = (layer.opacity, layer.blend);
    pixels.par_iter_mut().enumerate().for_each(|(i, px)| {
        let a = px[3];
        let k = opacity * (1.0 - mask.as_ref().map_or(0.0, |m| m[i]));
        if a <= 0.0 || k <= 0.0 {
            return;
        }
        let un = [px[0] / a, px[1] / a, px[2] / a];
        let mixed = look::blend_rgb(blend, un, prepared.apply(un));
        (0..3).for_each(|c| px[c] = (un[c] + (mixed[c] - un[c]) * k) * a);
    });
    if !canvas.write_pixels(&info, bytemuck::cast_slice(&pixels), w * 16, (0, 0)) {
        bail!("cannot write the pixels under adjustment layer {}", layer.id);
    }
    Ok(())
}

fn draw_paint_cel(canvas: &Canvas, cel: &str, ctx: Ctx) -> Result<()> {
    match ctx.swap {
        Some(swap) if swap.cel == cel => {
            let raster = ctx.rasters.get(cel);
            let indices = match ctx.area {
                Some(area) => tiles_in(swap.cols, swap.rows, area),
                None => (0..swap.cols * swap.rows).collect(),
            };
            indices.into_iter().try_for_each(|i| match swap.tiles.get(&i) {
                Some(Some(tile)) => draw_data(canvas, tile, i, swap.cols),
                Some(None) => Ok(()),
                None => raster.map_or(Ok(()), |r| draw_tile(canvas, r, i)),
            })
        }
        _ => ctx.rasters.get(cel).map_or(Ok(()), |r| draw_raster(canvas, r, ctx)),
    }
}

fn draw_content(canvas: &Canvas, layer: &Layer, ctx: Ctx) -> Result<()> {
    let Some(moved) = layer.keyed(ctx.frame).1 else {
        return draw_unmoved(canvas, layer, ctx);
    };
    let pivot = ctx.doc.map_or((0.0, 0.0), |d| {
        (d.canvas.width as f32 / 2.0, d.canvas.height as f32 / 2.0)
    });
    let grid = layer.grid_only();
    let (x, y) = match grid {
        true => (moved.x.round(), moved.y.round()),
        false => (moved.x, moved.y),
    };
    canvas.save();
    canvas.translate((x + pivot.0, y + pivot.1));
    canvas.rotate(moved.rotate, None);
    canvas.scale((moved.sx, moved.sy));
    canvas.translate((-pivot.0, -pivot.1));
    let whole = Ctx {
        area: None,
        sampling: Some(match grid {
            true => SamplingOptions::new(FilterMode::Nearest, MipmapMode::None),
            false => ctx
                .sampling
                .unwrap_or(SamplingOptions::new(FilterMode::Linear, MipmapMode::None)),
        }),
        ..ctx
    };
    let drawn = draw_unmoved(canvas, layer, whole);
    canvas.restore();
    drawn
}

fn draw_unmoved(canvas: &Canvas, layer: &Layer, ctx: Ctx) -> Result<()> {
    match &layer.content {
        LayerContent::Paint { .. } => layer
            .content_at(ctx.frame)
            .map_or(Ok(()), |cel| draw_paint_cel(canvas, &cel.id, ctx)),
        LayerContent::Vector { .. } => {
            layer
                .content_at(ctx.frame)
                .map_or(Ok(()), |cel| match ctx.rasters.get(&cel.id) {
                    Some(r) => draw_raster(canvas, r, ctx),
                    None => vector::draw_nodes(canvas, &klad_core::doc::nodes_at(&cel.nodes, ctx.frame)),
                })
        }
        LayerContent::Group { children } => draw_layers(canvas, children, ctx.nested()),
        LayerContent::Bones {} => Ok(()),
        LayerContent::Adjust {
            adjust: Adjustment::Fill(fill),
        } => {
            if let Some(paint) = vector::shader_paint(&fill.paint)? {
                canvas.draw_paint(&paint);
            }
            Ok(())
        }
        LayerContent::Adjust { .. } => Ok(()),
    }?;
    if let Some((mask, cel)) = layer.mask_at(ctx.frame) {
        mode_layer(canvas, BlendMode::DstOut);
        let drawn = draw_paint_cel(canvas, &layer_cel(mask, cel), ctx);
        canvas.restore();
        drawn.with_context(|| format!("mask {}", mask.id))?;
    }
    Ok(())
}

fn layer_cel(layer: &Layer, cel: &klad_core::doc::Cel) -> String {
    layer.content_of(cel).id.clone()
}

pub fn rasterize_nodes(nodes: &[klad_core::doc::Node], width: u32, height: u32) -> Result<Raster> {
    rasterize_nodes_at(nodes, width, height, 1.0)
}

pub fn rasterize_nodes_at(nodes: &[klad_core::doc::Node], width: u32, height: u32, detail: f32) -> Result<Raster> {
    let (width, height) = (
        (width as f32 * detail).ceil() as u32,
        (height as f32 * detail).ceil() as u32,
    );
    let info = f16_info(width, height);
    let mut surface = surfaces::raster(&info, None, None).ok_or_else(|| anyhow!("cannot allocate {width}x{height}"))?;
    surface.canvas().scale((detail, detail));
    vector::draw_nodes(surface.canvas(), nodes)?;
    let (w, h) = (width as usize, height as usize);
    let mut pixels = vec![half::f16::ZERO; w * h * 4];
    if !surface.read_pixels(&info, bytemuck::cast_slice_mut(&mut pixels), w * 8, (0, 0)) {
        return Err(anyhow!("cannot read pixels"));
    }
    let mut raster = Raster::new(width, height);
    (0..raster.rows).for_each(|ty| {
        (0..raster.cols).for_each(|tx| {
            let mut tile = vec![half::f16::ZERO; TILE * TILE * 4];
            let (x0, y0) = (tx * TILE, ty * TILE);
            let cols = TILE.min(w - x0);
            (0..TILE.min(h - y0)).for_each(|row| {
                let from = ((y0 + row) * w + x0) * 4;
                tile[row * TILE * 4..row * TILE * 4 + cols * 4].copy_from_slice(&pixels[from..from + cols * 4]);
            });
            if tile.as_chunks::<4>().0.iter().any(|px| px[3].to_f32() > 0.0) {
                let index = raster.index(tx, ty);
                raster.put(index, tile.into_boxed_slice());
            }
        })
    });
    Ok(raster)
}

pub type NodeTiles = Vec<(usize, Option<Vec<half::f16>>)>;

pub fn changed_tiles(
    old: &[klad_core::doc::Node],
    new: &[klad_core::doc::Node],
    width: u32,
    height: u32,
) -> Result<Option<Vec<usize>>> {
    let ids = |nodes: &[klad_core::doc::Node]| -> BTreeMap<String, usize> {
        nodes.iter().enumerate().map(|(i, n)| (n.id.clone(), i)).collect()
    };
    let (before, after) = (ids(old), ids(new));
    let kept = |nodes: &[klad_core::doc::Node], other: &BTreeMap<String, usize>| -> Vec<String> {
        nodes
            .iter()
            .filter(|n| other.contains_key(&n.id))
            .map(|n| n.id.clone())
            .collect()
    };
    if before.len() != old.len() || after.len() != new.len() || kept(old, &after) != kept(new, &before) {
        return Ok(None);
    }
    let touched = old
        .iter()
        .filter(|n| after.get(&n.id).is_none_or(|&i| new[i] != **n))
        .chain(new.iter().filter(|n| before.get(&n.id).is_none_or(|&i| old[i] != **n)))
        .filter(|n| n.visible);
    let reach = touched
        .map(|n| vector::node_reach(n).with_context(|| format!("node {}", n.id)))
        .collect::<Result<Vec<Option<Rect>>>>()?
        .into_iter()
        .flatten()
        .collect::<Vec<Rect>>();
    let cols = (width as usize).div_ceil(TILE);
    let rows = (height as usize).div_ceil(TILE);
    Ok(Some(
        (0..cols * rows)
            .filter(|i| {
                let cell = Rect::from_xywh(
                    (i % cols * TILE) as f32,
                    (i / cols * TILE) as f32,
                    TILE as f32,
                    TILE as f32,
                );
                reach.iter().any(|r| r.intersects(cell))
            })
            .collect(),
    ))
}

pub fn rasterize_tiles(nodes: &[klad_core::doc::Node], width: u32, height: u32, tiles: &[usize]) -> Result<NodeTiles> {
    let cols = (width as usize).div_ceil(TILE);
    let canvas = IRect::from_wh(width as i32, height as i32);
    let cell = |index: usize| {
        IRect::from_xywh(
            (index % cols * TILE) as i32,
            (index / cols * TILE) as i32,
            TILE as i32,
            TILE as i32,
        )
    };
    let Some(wanted) = tiles
        .iter()
        .filter_map(|&i| IRect::intersect(&cell(i), &canvas))
        .reduce(|a, b| IRect::join(&a, &b))
    else {
        return Ok(tiles.iter().map(|&i| (i, None)).collect());
    };
    let shown: Vec<(&klad_core::doc::Node, IRect)> = nodes
        .iter()
        .filter(|n| n.visible)
        .map(|n| {
            let reach = vector::node_reach(n).with_context(|| format!("node {}", n.id))?;
            Ok(reach.map(|r| (n, skia_safe::RoundOut::<IRect>::round_out(&r))))
        })
        .collect::<Result<Vec<_>>>()?
        .into_iter()
        .flatten()
        .collect();
    let touching: Vec<&(&klad_core::doc::Node, IRect)> = shown
        .iter()
        .filter(|(_, reach)| IRect::intersects(reach, &wanted))
        .collect();
    let joined = touching.iter().fold(wanted, |region, (_, reach)| {
        IRect::join(&region, &IRect::intersect(reach, &canvas).unwrap_or(region))
    });
    let t = TILE as i32;
    let region = IRect::from_ltrb(
        joined.left.div_euclid(t) * t,
        joined.top.div_euclid(t) * t,
        joined.right,
        joined.bottom,
    );
    let info = f16_info(region.width() as u32, region.height() as u32);
    let mut surface = surfaces::raster(&info, None, None)
        .ok_or_else(|| anyhow!("cannot allocate {}x{}", region.width(), region.height()))?;
    let drawn = surface.canvas();
    drawn.translate((-region.left as f32, -region.top as f32));
    touching.iter().try_for_each(|(n, _)| vector::draw_node(drawn, n))?;
    tiles
        .iter()
        .map(|&index| {
            let Some(part) = IRect::intersect(&cell(index), &canvas) else {
                return Ok((index, None));
            };
            let mut tile = vec![half::f16::ZERO; TILE * TILE * 4];
            let (w, h) = (part.width() as usize, part.height() as usize);
            let mut rows = vec![half::f16::ZERO; w * h * 4];
            if !surface.read_pixels(
                &f16_info(w as u32, h as u32),
                bytemuck::cast_slice_mut(&mut rows),
                w * 8,
                (part.left - region.left, part.top - region.top),
            ) {
                return Err(anyhow!("cannot read tile {index}"));
            }
            rows.chunks(w * 4)
                .enumerate()
                .for_each(|(row, line)| tile[row * TILE * 4..row * TILE * 4 + w * 4].copy_from_slice(line));
            Ok((
                index,
                tile.as_chunks::<4>()
                    .0
                    .iter()
                    .any(|px| px[3].to_f32() > 0.0)
                    .then_some(tile),
            ))
        })
        .collect()
}

#[derive(Clone, Copy, Debug)]
pub struct View {
    pub scale: f32,
    pub region: Option<[i32; 4]>,
    pub references: bool,
}

impl View {
    pub fn scaled(scale: f32) -> Self {
        Self {
            scale,
            region: None,
            references: false,
        }
    }
}

pub fn compose(doc: &Document, frame: u32, rasters: &Rasters, view: View) -> Result<Frame> {
    compose_view(doc, frame, rasters, view, None, None)
}

pub fn compose_view(
    doc: &Document,
    frame: u32,
    rasters: &Rasters,
    view: View,
    overlay: Option<&overlay::Overlay>,
    onions: Option<&Onions>,
) -> Result<Frame> {
    let (width, height) = (doc.canvas.width, doc.canvas.height);
    let mut surface = surfaces::raster(&f16_info(width, height), None, None)
        .ok_or_else(|| anyhow!("cannot allocate {width}x{height}"))?;
    let canvas = surface.canvas();
    canvas.clear(background(doc.canvas.background.as_deref())?);
    let ctx = Ctx {
        onions,
        doc: Some(doc),
        references: view.references,
        ..Ctx::full(frame, rasters)
    };
    draw_layers(canvas, &doc.layers, ctx)?;
    let image = match view.region {
        Some([x, y, w, h]) => surface
            .image_snapshot_with_bounds(IRect::from_xywh(x, y, w, h))
            .ok_or_else(|| anyhow!("region {x},{y} {w}x{h} is outside the canvas"))?,
        None => surface.image_snapshot(),
    };
    let out = if (view.scale - 1.0).abs() < f32::EPSILON {
        image
    } else {
        resample(&image, view.scale)?
    };
    match overlay {
        Some(overlay) => overlay::apply(&out, overlay, &view),
        None => read_rgba8(&out),
    }
}

pub fn compose_image(doc: &Document, frame: u32, rasters: &Rasters) -> Result<Image> {
    let (width, height) = (doc.canvas.width, doc.canvas.height);
    let mut surface = surfaces::raster(&f16_info(width, height), None, None)
        .ok_or_else(|| anyhow!("cannot allocate {width}x{height}"))?;
    let canvas = surface.canvas();
    canvas.clear(background(doc.canvas.background.as_deref())?);
    let ctx = Ctx {
        doc: Some(doc),
        ..Ctx::full(frame, rasters)
    };
    draw_layers(canvas, &doc.layers, ctx)?;
    Ok(surface.image_snapshot())
}

pub(crate) fn resample(image: &Image, scale: f32) -> Result<Image> {
    let (w, h) = (
        ((image.width() as f32 * scale).round() as u32).max(1),
        ((image.height() as f32 * scale).round() as u32).max(1),
    );
    let source = if scale < 1.0 {
        image
            .with_default_mipmaps()
            .ok_or_else(|| anyhow!("cannot build mipmaps"))?
    } else {
        image.clone()
    };
    let mut surface =
        surfaces::raster(&f16_info(w, h), None, None).ok_or_else(|| anyhow!("cannot allocate {w}x{h}"))?;
    let sampling = if scale < 1.0 {
        SamplingOptions::new(FilterMode::Linear, MipmapMode::Linear)
    } else {
        SamplingOptions::new(FilterMode::Nearest, MipmapMode::None)
    };
    surface.canvas().draw_image_rect_with_sampling_options(
        &source,
        None,
        Rect::from_wh(w as f32, h as f32),
        sampling,
        &Paint::default(),
    );
    Ok(surface.image_snapshot())
}

pub fn read_rgba8(image: &Image) -> Result<Frame> {
    let (width, height) = (image.width() as u32, image.height() as u32);
    let mut rgba = vec![0u8; width as usize * height as usize * 4];
    if !image.read_pixels(
        &rgba8_info(width, height),
        &mut rgba,
        width as usize * 4,
        (0, 0),
        CachingHint::Allow,
    ) {
        return Err(anyhow!("cannot read pixels"));
    }
    Ok(Frame { width, height, rgba })
}

pub enum TileItem<'a> {
    Pixels {
        tile: &'a [half::f16],
        opacity: f32,
        blend: Blend,
    },
    Layer(&'a Layer),
}

enum Unit<'a> {
    Pixels {
        tile: &'a [half::f16],
        opacity: f32,
        blend: Blend,
    },
    Layers(&'a Layer, Vec<&'a Layer>),
}

fn units<'a>(items: &[TileItem<'a>]) -> Vec<Unit<'a>> {
    items.iter().fold(Vec::new(), |mut out, item| {
        match (item, out.last_mut()) {
            (TileItem::Layer(layer), Some(Unit::Layers(_, clipped))) if layer.clip => clipped.push(layer),
            (TileItem::Layer(layer), _) => out.push(Unit::Layers(layer, Vec::new())),
            (TileItem::Pixels { tile, opacity, blend }, _) => out.push(Unit::Pixels {
                tile,
                opacity: *opacity,
                blend: *blend,
            }),
        }
        out
    })
}

pub struct TileJob<'a> {
    pub frame: u32,
    pub rasters: &'a Rasters,
    pub background: Option<&'a str>,
    pub tx: usize,
    pub ty: usize,
    pub swap: Option<Swap<'a>>,
    pub onions: Option<&'a Onions>,
    pub doc: &'a Document,
    pub references: bool,
}

pub fn flatten(
    doc: &Document,
    frame: u32,
    rasters: &Rasters,
    layers: &[&Layer],
    background: Option<&str>,
) -> Result<Raster> {
    flatten_with(doc, frame, rasters, layers, background, None, false)
}

pub fn flatten_with(
    doc: &Document,
    frame: u32,
    rasters: &Rasters,
    layers: &[&Layer],
    background: Option<&str>,
    onions: Option<&Onions>,
    references: bool,
) -> Result<Raster> {
    let mut out = Raster::new(doc.canvas.width, doc.canvas.height);
    let items: Vec<TileItem> = layers.iter().map(|l| TileItem::Layer(l)).collect();
    let tiles = (0..out.cols * out.rows)
        .into_par_iter()
        .map(|index| {
            let job = TileJob {
                frame,
                rasters,
                background,
                tx: index % out.cols,
                ty: index / out.cols,
                swap: None,
                onions,
                doc,
                references,
            };
            let tile = compose_tile(&items, &job)?;
            let used = tile.as_chunks::<4>().0.iter().any(|px| px[3].to_f32() > 0.0);
            Ok(used.then_some((index, tile)))
        })
        .collect::<Result<Vec<_>>>()?;
    tiles
        .into_iter()
        .flatten()
        .for_each(|(index, tile)| out.put(index, tile.into_boxed_slice()));
    Ok(out)
}

pub fn fill_reference(doc: &Document, frame: u32, rasters: &Rasters, cel: &str, reference: &FillRef) -> Result<Raster> {
    let (w, h) = (doc.canvas.width, doc.canvas.height);
    match reference {
        FillRef::This => Ok(rasters.get(cel).cloned().unwrap_or_else(|| Raster::new(w, h))),
        FillRef::All => {
            let layers: Vec<&Layer> = doc.layers.iter().collect();
            flatten(doc, frame, rasters, &layers, doc.canvas.background.as_deref())
        }
        FillRef::Layer(id) => {
            let layer = doc
                .layer(id)
                .ok_or_else(|| anyhow!("the fill reference layer {id} is gone"))?;
            if layer.kind() == Kind::Paint {
                return Ok(layer
                    .content_at(frame)
                    .and_then(|c| rasters.get(&c.id))
                    .cloned()
                    .unwrap_or_else(|| Raster::new(w, h)));
            }
            let mut alone = layer.clone();
            alone.visible = true;
            alone.opacity = 1.0;
            alone.blend = Blend::Normal;
            alone.reference = false;
            flatten(doc, frame, rasters, &[&alone], None)
        }
    }
}

pub fn compose_tile(items: &[TileItem], job: &TileJob) -> Result<Vec<half::f16>> {
    let info = f16_info(TILE as u32, TILE as u32);
    let mut surface = surfaces::raster(&info, None, None).ok_or_else(|| anyhow!("cannot allocate a tile"))?;
    let canvas = surface.canvas();
    canvas.clear(background(job.background)?);
    let (ox, oy) = ((job.tx * TILE) as f32, (job.ty * TILE) as f32);
    canvas.translate((-ox, -oy));
    let ctx = Ctx {
        frame: job.frame,
        rasters: job.rasters,
        area: Some(IRect::from_xywh(ox as i32, oy as i32, TILE as i32, TILE as i32)),
        swap: job.swap,
        sampling: None,
        onions: job.onions,
        flat: true,
        doc: Some(job.doc),
        references: job.references,
        detail: 1.0,
    };
    units(items).into_iter().try_for_each(|unit| match unit {
        Unit::Pixels { tile, opacity, blend } => {
            canvas.draw_image(tile_image(tile)?, (ox, oy), Some(&layer_paint(opacity, blend)));
            Ok(())
        }
        Unit::Layers(base, clipped) => draw_clipped(canvas, base, &clipped, ctx),
    })?;
    let mut out = vec![half::f16::ZERO; TILE * TILE * 4];
    if !surface.read_pixels(&info, bytemuck::cast_slice_mut(&mut out), TILE * 8, (0, 0)) {
        return Err(anyhow!("cannot read tile pixels"));
    }
    Ok(out)
}

#[cfg(test)]
mod look_tests;

#[cfg(test)]
mod tests {
    use super::*;
    use klad_brush::{BrushSet, replay};
    use klad_core::doc::{Cel, Linear, Node, Paint as Fill, Shape, Stop, StrokeStyle};
    use klad_core::stroke::Stroke;

    fn rect(id: &str, x: f32, y: f32, w: f32, h: f32, fill: &str) -> Node {
        Node::new(
            id,
            Shape::Rect {
                x,
                y,
                w,
                h,
                radius: 0.0,
            },
        )
        .filled(fill)
    }

    fn close(a: [u8; 4], b: [u8; 4]) -> bool {
        a.iter().zip(&b).all(|(x, y)| x.abs_diff(*y) <= 2)
    }

    #[test]
    fn vector_and_paint_layers_compose_in_order() {
        let mut doc = Document::new(64, 64);
        doc.layers.push(Layer::vector(
            "bg",
            "bg",
            "c1",
            vec![rect("n1", 0.0, 0.0, 64.0, 64.0, "#0000ff")],
        ));
        doc.layers.push(Layer::paint("ink", "ink", "c2"));
        let stroke = Stroke::new(1, "ink", [1.0, 0.0, 0.0, 1.0], 12.0, 1).with_points(&[(32.0, 32.0, 1.0)], 0.0);
        let raster = replay(64, 64, &[stroke.into()], &BrushSet::presets()).unwrap().raster;
        let rasters = Rasters::from([("c2".to_string(), raster)]);
        let mut frame = compose(&doc, 0, &rasters, View::scaled(1.0)).unwrap();
        assert_eq!(frame.pixel(32, 32), [255, 0, 0, 255]);
        assert_eq!(frame.pixel(2, 2), [0, 0, 255, 255]);
        assert_eq!(compose(&doc, 0, &rasters, View::scaled(0.5)).unwrap().width, 32);
        assert!(frame.png().unwrap().starts_with(&[0x89, b'P', b'N', b'G']));
        let zoomed = compose(
            &doc,
            0,
            &rasters,
            View {
                scale: 2.0,
                region: Some([28, 28, 8, 8]),
                references: false,
            },
        )
        .unwrap();
        assert_eq!((zoomed.width, zoomed.height), (16, 16));
        assert_eq!(zoomed.pixel(8, 8), [255, 0, 0, 255]);
    }

    #[test]
    fn groups_isolate_opacity_and_blend() {
        let mut doc = Document::new(8, 8);
        doc.layers.push(Layer::vector(
            "a",
            "a",
            "c1",
            vec![rect("n1", 0.0, 0.0, 8.0, 8.0, "#ffffff")],
        ));
        let black = Layer::vector("b", "b", "c2", vec![rect("n2", 0.0, 0.0, 8.0, 8.0, "#000000")]);
        let mut group = Layer::group("g", "g", vec![black]);
        group.opacity = 0.5;
        doc.layers.push(group);
        let grey = compose(&doc, 0, &Rasters::new(), View::scaled(1.0))
            .unwrap()
            .pixel(4, 4);
        assert!((126..=129).contains(&grey[0]), "{grey:?}");
        doc.layers[1].opacity = 1.0;
        doc.layers[1].blend = Blend::Multiply;
        assert_eq!(
            compose(&doc, 0, &Rasters::new(), View::scaled(1.0))
                .unwrap()
                .pixel(4, 4),
            [0, 0, 0, 255]
        );
        doc.layers[1].visible = false;
        assert_eq!(
            compose(&doc, 0, &Rasters::new(), View::scaled(1.0))
                .unwrap()
                .pixel(4, 4),
            [255, 255, 255, 255]
        );
    }

    #[test]
    fn frames_pick_their_cels() {
        let mut doc = Document::new(4, 4);
        doc.timeline.frames = 3;
        let mut layer = Layer::vector("v", "v", "c1", vec![rect("n1", 0.0, 0.0, 4.0, 4.0, "#ff0000")]);
        if let Some(cels) = layer.cels_mut() {
            cels[0].hold = Some(1);
            let mut second = Cel::at("c2", 1);
            second.nodes = vec![rect("n2", 0.0, 0.0, 4.0, 4.0, "#00ff00")];
            second.hold = Some(1);
            cels.push(second);
            cels.push(Cel {
                link: Some("c1".into()),
                ..Cel::at("c3", 2)
            });
        }
        doc.layers.push(layer);
        let at = |f| {
            compose(&doc, f, &Rasters::new(), View::scaled(1.0))
                .unwrap()
                .pixel(1, 1)
        };
        assert_eq!(
            [at(0), at(1), at(2)],
            [[255, 0, 0, 255], [0, 255, 0, 255], [255, 0, 0, 255]]
        );
    }

    #[test]
    fn transforms_gradients_and_strokes_render() {
        let mut doc = Document::new(100, 100);
        let mut bar = rect("bar", 40.0, 0.0, 20.0, 100.0, "#000000");
        bar.transform.rotate = 90.0;
        let mut sky = rect("sky", 0.0, 0.0, 100.0, 100.0, "#000000");
        sky.fill = Some(Fill::Linear {
            linear: Linear {
                from: [0.0, 0.0],
                to: [0.0, 100.0],
                stops: vec![Stop(0.0, "#ff0000".into()), Stop(1.0, "#0000ff".into())],
            },
        });
        let mut ring = Node::new(
            "ring",
            Shape::Ellipse {
                cx: 80.0,
                cy: 80.0,
                rx: 10.0,
                ry: 10.0,
            },
        );
        ring.fill = Some(Fill::Solid("none".into()));
        ring.stroke = Some(StrokeStyle {
            paint: Fill::Solid("#00ff00".into()),
            width: 4.0,
            cap: Default::default(),
            join: Default::default(),
            dash: Vec::new(),
        });
        doc.layers.push(Layer::vector("v", "v", "c1", vec![sky, bar, ring]));
        let frame = compose(&doc, 0, &Rasters::new(), View::scaled(1.0)).unwrap();
        let top = frame.pixel(5, 2);
        let bottom = frame.pixel(5, 97);
        assert!(top[0] > 240 && top[2] < 15, "{top:?}");
        assert!(bottom[2] > 240 && bottom[0] < 15, "{bottom:?}");
        assert_eq!(frame.pixel(5, 50), [0, 0, 0, 255]);
        assert_ne!(frame.pixel(50, 5), [0, 0, 0, 255]);
        assert!(close(frame.pixel(90, 80), [0, 255, 0, 255]));
        assert_ne!(frame.pixel(80, 80)[1], 255);
        let bounds = vector::node_bounds(&doc.layers[0].cels()[0].nodes[1], &skia_safe::Matrix::new_identity())
            .unwrap()
            .unwrap();
        assert!((bounds.left - 0.0).abs() < 0.01 && (bounds.width() - 100.0).abs() < 0.01);
    }

    #[test]
    fn blur_softens_edges() {
        let mut doc = Document::new(100, 40);
        let mut soft = rect("soft", 50.0, 0.0, 50.0, 40.0, "#000000");
        soft.blur = 6.0;
        doc.layers.push(Layer::vector(
            "v",
            "v",
            "c1",
            vec![rect("hard", 0.0, 0.0, 50.0, 40.0, "#000000"), soft],
        ));
        let frame = compose(&doc, 0, &Rasters::new(), View::scaled(1.0)).unwrap();
        assert_eq!(frame.pixel(25, 20)[3], 255);
        assert_eq!(frame.pixel(75, 20)[3], 255);
        let edge = frame.pixel(98, 20)[3];
        assert!(edge > 20 && edge < 200, "{edge}");
        assert_eq!(frame.pixel(48, 2)[3], 255);
    }

    #[test]
    fn clip_paths_cut_children() {
        let mut doc = Document::new(100, 100);
        let mut g = Node::new(
            "g",
            Shape::Group {
                children: vec![rect("r", 0.0, 0.0, 100.0, 100.0, "#ff0000")],
            },
        );
        g.clip = Some("M0 0 L50 0 L50 100 L0 100 Z".into());
        doc.layers.push(Layer::vector("v", "v", "c1", vec![g]));
        let frame = compose(&doc, 0, &Rasters::new(), View::scaled(1.0)).unwrap();
        assert_eq!(frame.pixel(25, 50), [255, 0, 0, 255]);
        assert_eq!(frame.pixel(75, 50)[3], 0);
        let b = vector::node_box(&doc.layers[0].cels()[0].nodes[0]).unwrap().unwrap();
        assert!((b[2] - 50.0).abs() < 0.01, "{b:?}");
    }

    fn tiled_scene() -> Vec<Node> {
        let stroke = |hex: &str, width: f32| StrokeStyle {
            paint: Fill::Solid(hex.into()),
            width,
            cap: klad_core::doc::Cap::Butt,
            join: klad_core::doc::Join::Miter,
            dash: Vec::new(),
        };
        let mut frame = rect("frame", 180.0, 200.0, 190.0, 90.0, "#e0b040");
        frame.stroke = Some(stroke("#202840", 18.0));
        frame.transform.rotate = 17.0;
        let mut star = Node::new(
            "star",
            Shape::Path {
                d: "M 250 40 L 275 230 L 330 60 L 300 250 L 420 120 Z".into(),
            },
        )
        .filled("#90c0a0");
        star.stroke = Some(stroke("#103020", 9.0));
        let mut mist = Node::new(
            "mist",
            Shape::Ellipse {
                cx: 470.0,
                cy: 250.0,
                rx: 90.0,
                ry: 40.0,
            },
        )
        .filled("#5070c0");
        mist.blur = 24.0;
        mist.opacity = 0.8;
        let mut bead = Node::new(
            "bead",
            Shape::Ellipse {
                cx: 0.0,
                cy: 0.0,
                rx: 14.0,
                ry: 9.0,
            },
        )
        .filled("#c04060");
        bead.stroke = Some(stroke("#401020", 5.0));
        let row = Node::new(
            "row",
            Shape::Repeat(klad_core::generators::Repeat {
                count: 5,
                step: [60.0, 25.0],
                scale: 1.3,
                children: vec![bead],
                ..Default::default()
            }),
        );
        let mut row = row;
        row.transform.x = 20.0;
        row.transform.y = 30.0;
        let mut clipped = rect("clipped", 60.0, 150.0, 220.0, 160.0, "#a0a0f0");
        clipped.clip = Some("M 60 150 L 280 230 L 60 310 Z".into());
        let edge = rect("edge", -40.0, 250.0, 700.0, 80.0, "#30303080");
        vec![edge, frame, star, mist, row, clipped]
    }

    #[test]
    fn vector_tiles_patched_where_a_node_moved_match_a_whole_render() {
        let nodes = tiled_scene();
        let (w, h) = (600u32, 300u32);
        let whole = rasterize_nodes(&nodes, w, h).unwrap();
        rasterize_tiles(&nodes, w, h, &[1, 4, 5])
            .unwrap()
            .iter()
            .for_each(|(i, tile)| {
                assert_eq!(tile.as_deref(), whole.at(*i), "tile {i} drawn alone");
            });
        let patched = |before: &[Node], after: &[Node]| -> Option<(Vec<usize>, Raster)> {
            let dirty = changed_tiles(before, after, w, h).unwrap()?;
            let mut raster = rasterize_nodes(before, w, h).unwrap();
            rasterize_tiles(after, w, h, &dirty)
                .unwrap()
                .into_iter()
                .for_each(|(i, tile)| match tile {
                    Some(tile) => raster.put(i, tile.into_boxed_slice()),
                    None => raster.clear(i),
                });
            Some((dirty, raster))
        };
        let agrees = |what: &str, before: &[Node], after: &[Node]| {
            let (dirty, raster) = patched(before, after).unwrap();
            let fresh = rasterize_nodes(after, w, h).unwrap();
            assert!(raster.differs(&fresh).is_empty(), "{what}: patched {dirty:?}");
            dirty
        };
        (1..nodes.len()).for_each(|k| {
            let mut moved = nodes.clone();
            moved[k].transform.x += 150.0;
            moved[k].transform.y -= 60.0;
            agrees(&format!("{} moved", nodes[k].id), &nodes, &moved);
        });
        let mut recoloured = nodes.clone();
        recoloured[2].fill = Some(Fill::Solid("#ff0000".into()));
        agrees("recoloured", &nodes, &recoloured);
        let added: Vec<Node> = nodes
            .iter()
            .cloned()
            .chain([rect("new", 520.0, 20.0, 40.0, 40.0, "#000000")])
            .collect();
        assert_eq!(agrees("added", &nodes, &added), vec![2]);
        agrees("removed", &added, &nodes);
        let mut hidden = nodes.clone();
        hidden[3].visible = false;
        agrees("hidden", &nodes, &hidden);
        assert_eq!(changed_tiles(&nodes, &nodes, w, h).unwrap(), Some(Vec::new()));
        let swapped: Vec<Node> = [1, 0, 2, 3, 4, 5].iter().map(|&i| nodes[i].clone()).collect();
        assert_eq!(
            changed_tiles(&nodes, &swapped, w, h).unwrap(),
            None,
            "a new order redraws the layer"
        );
    }

    #[test]
    fn vector_patches_away_from_the_origin_keep_big_blurs_and_skip_what_draws_nothing() {
        let (w, h) = (1300u32, 900u32);
        let mut mist = Node::new(
            "mist",
            Shape::Ellipse {
                cx: 733.0,
                cy: 571.0,
                rx: 170.0,
                ry: 55.0,
            },
        )
        .filled("#7088c0");
        mist.blur = 26.0;
        let chip = rect("chip", 905.0, 610.0, 120.0, 70.0, "#e04030");
        let mut ghost = Node::new(
            "ghost",
            Shape::Text(klad_core::generators::Text {
                text: "gone".into(),
                font: "Missing.ttf".into(),
                ..Default::default()
            }),
        );
        ghost.visible = false;
        let empty = Node::new("empty", Shape::Group { children: Vec::new() });
        let nodes = vec![mist, empty, ghost, chip];
        let mut moved = nodes.clone();
        moved[3].transform.x = 37.5;
        moved[3].transform.y = -21.25;
        moved.remove(2);
        let without_ghost: Vec<Node> = nodes.iter().filter(|n| n.id != "ghost").cloned().collect();
        let dirty = changed_tiles(&nodes, &moved, w, h).unwrap().unwrap();
        assert!(
            dirty.iter().all(|&i| i % 6 >= 3 && i / 6 >= 2),
            "the dirty tiles sit away from the origin: {dirty:?}"
        );
        let mut patched = rasterize_nodes(&without_ghost, w, h).unwrap();
        rasterize_tiles(&moved, w, h, &dirty)
            .unwrap()
            .into_iter()
            .for_each(|(i, tile)| match tile {
                Some(tile) => patched.put(i, tile.into_boxed_slice()),
                None => patched.clear(i),
            });
        assert!(patched.differs(&rasterize_nodes(&moved, w, h).unwrap()).is_empty());
    }

    #[test]
    fn rasterized_vectors_and_swapped_tiles_match() {
        let mut doc = Document::new(600, 300);
        let mut ring = Node::new(
            "ring",
            Shape::Ellipse {
                cx: 300.0,
                cy: 150.0,
                rx: 200.0,
                ry: 100.0,
            },
        )
        .filled("#3366aa");
        ring.blur = 3.0;
        doc.layers.push(Layer::vector("v", "v", "cv", vec![ring]));
        let ink = Layer::paint("p", "p", "cp");
        doc.layers.push(Layer::group("g", "g", vec![ink]));
        let stroke = Stroke::new(1, "ink", [0.9, 0.1, 0.1, 1.0], 40.0, 1)
            .with_points(&[(20.0, 20.0, 1.0), (580.0, 280.0, 1.0)], 5.0);
        let raster = replay(600, 300, &[stroke.into()], &BrushSet::presets()).unwrap().raster;
        let plain = Rasters::from([("cp".to_string(), raster.clone())]);
        let full = compose(&doc, 0, &plain, View::scaled(1.0)).unwrap();
        let mut cached = plain.clone();
        cached.insert(
            "cv".into(),
            rasterize_nodes(&doc.layers[0].cels()[0].nodes, 600, 300).unwrap(),
        );
        let items: Vec<TileItem> = doc.layers.iter().map(TileItem::Layer).collect();
        let empty = SwapTiles::from([(1usize, None)]);
        let tile = |swap| {
            compose_tile(
                &items,
                &TileJob {
                    frame: 0,
                    rasters: &cached,
                    background: None,
                    tx: 1,
                    ty: 0,
                    swap,
                    onions: None,
                    doc: &doc,
                    references: false,
                },
            )
            .unwrap()
        };
        let px = |t: &[half::f16], x: usize, y: usize| -> [u8; 3] {
            let at = (y * TILE + x) * 4;
            let a = t[at + 3].to_f32().max(1e-6);
            [0, 1, 2].map(|c| (t[at + c].to_f32() / a * 255.0).round() as u8)
        };
        let ours = tile(None);
        [(10usize, 150usize), (60, 120), (200, 30)].iter().for_each(|&(x, y)| {
            let reference = full.pixel((256 + x) as u32, y as u32);
            let got = px(&ours, x, y);
            assert!(
                got.iter().zip(&reference[..3]).all(|(a, b)| a.abs_diff(*b) <= 1),
                "({x},{y}) {got:?} vs {reference:?}"
            );
        });
        let without_ink = tile(Some(Swap {
            cel: "cp",
            cols: 3,
            rows: 2,
            tiles: &empty,
        }));
        let ring_only = compose(&doc, 0, &Rasters::new(), View::scaled(1.0)).unwrap();
        let reference = ring_only.pixel(256 + 60, 120);
        assert_eq!(px(&without_ink, 60, 120), [reference[0], reference[1], reference[2]]);
    }

    #[test]
    fn tiles_match_the_full_composite() {
        let mut doc = Document::new(512, 300);
        doc.layers.push(Layer::vector(
            "bg",
            "bg",
            "c1",
            vec![
                Node::new(
                    "n1",
                    Shape::Ellipse {
                        cx: 256.0,
                        cy: 150.0,
                        rx: 200.0,
                        ry: 120.0,
                    },
                )
                .filled("#336699"),
            ],
        ));
        let mut ink = Layer::paint("ink", "ink", "c2");
        ink.opacity = 0.7;
        doc.layers.push(ink);
        let stroke = Stroke::new(1, "ink", [0.9, 0.2, 0.1, 1.0], 30.0, 1)
            .with_points(&[(40.0, 40.0, 1.0), (300.0, 260.0, 0.6), (480.0, 60.0, 0.9)], 5.0);
        let raster = replay(512, 300, &[stroke.into()], &BrushSet::presets()).unwrap().raster;
        let rasters = Rasters::from([("c2".to_string(), raster)]);
        let full = compose(&doc, 0, &rasters, View::scaled(1.0)).unwrap();
        let tile = rasters["c2"].get(1, 0).unwrap();
        let items = [
            TileItem::Layer(&doc.layers[0]),
            TileItem::Pixels {
                tile,
                opacity: 0.7,
                blend: Blend::Normal,
            },
        ];
        let job = TileJob {
            frame: 0,
            rasters: &rasters,
            background: None,
            tx: 1,
            ty: 0,
            swap: None,
            onions: None,
            doc: &doc,
            references: false,
        };
        let composed = compose_tile(&items, &job).unwrap();
        let px = &composed[(100 * TILE + 44) * 4..(100 * TILE + 44) * 4 + 4];
        let a = px[3].to_f32();
        let rgb: Vec<u8> = px[..3].iter().map(|v| (v.to_f32() / a * 255.0).round() as u8).collect();
        let reference = full.pixel(256 + 44, 100);
        assert!(
            rgb.iter().zip(&reference[..3]).all(|(x, y)| x.abs_diff(*y) <= 1),
            "{rgb:?} vs {reference:?}"
        );
    }

    #[test]
    fn onion_skin_sits_under_its_layer_and_tiles_agree() {
        let mut doc = Document::new(256, 64);
        doc.canvas.background = Some("#ffffff".into());
        doc.timeline.frames = 3;
        let mut ball = Layer::paint("ball", "ball", "c1");
        *ball.cels_mut().unwrap() = vec![
            Cel {
                hold: Some(1),
                ..Cel::at("c1", 0)
            },
            Cel {
                hold: Some(1),
                ..Cel::at("c2", 1)
            },
            Cel::at("c3", 2),
        ];
        let mut cover = Layer::paint("top", "top", "c9");
        cover.opacity = 0.5;
        doc.layers = vec![ball, cover];
        let dot = |x: f32| {
            let stroke = Stroke::new(1, "ink", [0.0, 0.0, 0.0, 1.0], 30.0, 1).with_points(&[(x, 32.0, 1.0)], 0.0);
            replay(256, 64, &[stroke.into()], &BrushSet::presets()).unwrap().raster
        };
        let rasters = Rasters::from([
            ("c1".to_string(), dot(40.0)),
            ("c2".to_string(), dot(128.0)),
            ("c3".to_string(), dot(216.0)),
            ("c9".to_string(), dot(40.0)),
        ]);
        let plan = onion::plan(&doc, 1, &onion::animated(&doc), &onion::Onion::default());
        assert_eq!(plan.len(), 1);
        let onions = onion::build(&doc, &plan, &rasters);
        let full = compose_view(&doc, 1, &rasters, View::scaled(1.0), None, Some(&onions)).unwrap();
        let plain = compose(&doc, 1, &rasters, View::scaled(1.0)).unwrap();
        let before = full.pixel(216 - 176, 32);
        let after = full.pixel(216, 32);
        assert!(
            before[0] > before[1] + 25,
            "red before, under the top layer: {before:?}"
        );
        assert!(after[1] > after[0] + 40, "green after: {after:?}");
        assert_eq!(full.pixel(128, 32), plain.pixel(128, 32));
        assert_eq!(plain.pixel(216, 32), [255, 255, 255, 255]);
        let items: Vec<TileItem> = doc.layers.iter().map(TileItem::Layer).collect();
        let tile = compose_tile(
            &items,
            &TileJob {
                frame: 1,
                rasters: &rasters,
                background: Some("#ffffff"),
                tx: 0,
                ty: 0,
                swap: None,
                onions: Some(&onions),
                doc: &doc,
                references: false,
            },
        )
        .unwrap();
        [40usize, 128, 216].iter().for_each(|&x| {
            let at = (32 * TILE + x) * 4;
            let got: Vec<u8> = (0..3).map(|c| (tile[at + c].to_f32() * 255.0).round() as u8).collect();
            let want = full.pixel(x as u32, 32);
            assert!(
                got.iter().zip(&want[..3]).all(|(a, b)| a.abs_diff(*b) <= 1),
                "{x}: {got:?} vs {want:?}"
            );
        });
    }

    #[test]
    fn masks_hide_and_clipped_layers_stay_inside_their_base() {
        let mut doc = Document::new(256, 128);
        doc.canvas.background = Some("#ffffff".into());
        let flat = Layer::vector(
            "flat",
            "flat",
            "c1",
            vec![rect("n1", 40.0, 20.0, 120.0, 80.0, "#d0a060")],
        );
        let mut shade = Layer::paint("shade", "shade", "c2");
        shade.clip = true;
        shade.blend = Blend::Multiply;
        let mut light = Layer::paint("light", "light", "c3");
        light.clip = true;
        light.mask = Some(Box::new(Layer::paint("m", "mask", "c4")));
        doc.layers = vec![flat, shade, light];
        let line = |id: u32, y: f32, color: [f32; 4], size: f32| {
            Stroke::new(id, "ink", color, size, 1).with_points(&[(0.0, y, 1.0), (256.0, y, 1.0)], 5.0)
        };
        let paint = |strokes: Vec<Stroke>| {
            replay(
                256,
                128,
                &strokes.into_iter().map(Into::into).collect::<Vec<_>>(),
                &BrushSet::presets(),
            )
            .unwrap()
            .raster
        };
        let rasters = Rasters::from([
            ("c2".to_string(), paint(vec![line(1, 60.0, [0.2, 0.2, 0.5, 1.0], 30.0)])),
            ("c3".to_string(), paint(vec![line(1, 30.0, [1.0, 1.0, 1.0, 1.0], 12.0)])),
            (
                "c4".to_string(),
                paint(vec![
                    Stroke::new(1, "ink", [0.0, 0.0, 0.0, 1.0], 30.0, 1)
                        .with_points(&[(100.0, 30.0, 1.0), (256.0, 30.0, 1.0)], 5.0),
                ]),
            ),
        ]);
        let frame = compose(&doc, 0, &rasters, View::scaled(1.0)).unwrap();
        let shaded = frame.pixel(100, 60);
        assert!(shaded[2] < 140 && shaded[0] < 60, "{shaded:?}");
        assert_eq!(frame.pixel(10, 60), [255, 255, 255, 255]);
        assert_eq!(frame.pixel(200, 60), [255, 255, 255, 255]);
        assert_eq!(frame.pixel(60, 30), [255, 255, 255, 255]);
        assert_eq!(frame.pixel(10, 30), [255, 255, 255, 255]);
        assert!(
            close(frame.pixel(130, 30), [0xd0, 0xa0, 0x60, 255]),
            "{:?}",
            frame.pixel(130, 30)
        );
        let items: Vec<TileItem> = doc.layers.iter().map(TileItem::Layer).collect();
        let tile = compose_tile(
            &items,
            &TileJob {
                frame: 0,
                rasters: &rasters,
                background: Some("#ffffff"),
                tx: 0,
                ty: 0,
                swap: None,
                onions: None,
                doc: &doc,
                references: false,
            },
        )
        .unwrap();
        [(100usize, 60usize), (60, 30), (130, 30), (200, 60)]
            .iter()
            .for_each(|&(x, y)| {
                let at = (y * TILE + x) * 4;
                let got: Vec<u8> = (0..3).map(|c| (tile[at + c].to_f32() * 255.0).round() as u8).collect();
                let want = frame.pixel(x as u32, y as u32);
                assert!(
                    got.iter().zip(&want[..3]).all(|(a, b)| a.abs_diff(*b) <= 1),
                    "({x},{y}) {got:?} vs {want:?}"
                );
            });
        doc.layers[0].visible = false;
        let hidden = compose(&doc, 0, &rasters, View::scaled(1.0)).unwrap();
        assert_eq!(hidden.pixel(100, 60), [255, 255, 255, 255]);
        doc.layers.remove(0);
        let leading = compose(&doc, 0, &rasters, View::scaled(1.0)).unwrap();
        assert!(leading.pixel(10, 60)[2] < 200, "{:?}", leading.pixel(10, 60));
    }
}