A drawing app built for agent/human collaboration
Rust
Vector edits redraw only the tiles they touch
Indicode BV3cfec3f04f19
diff --git a/crates/app/src/composite.rs b/crates/app/src/composite.rsindex 8496a86..8ee8b48 100644--- a/crates/app/src/composite.rs+++ b/crates/app/src/composite.rs@@ -900,6 +900,22 @@ fn paint_cels(doc: &Document, frame: u32) -> Vec<(String, String)> {.collect()}+fn redraw(nodes: &[Node], before: Option<(&[Node], &Raster)>, (w, h): (u32, u32)) -> Result<Raster> {+ if let Some((old, raster)) = before+ && let Some(tiles) = klad_render::changed_tiles(old, nodes, w, h)?+ {+ let mut patched = raster.clone();+ klad_render::rasterize_tiles(nodes, w, h, &tiles)?+ .into_iter()+ .for_each(|(i, tile)| match tile {+ Some(tile) => patched.put(i, tile.into_boxed_slice()),+ None => patched.clear(i),+ });+ return Ok(patched);+ }+ rasterize_nodes(nodes, w, h)+}+fn nodes_hash(nodes: &[Node]) -> u64 {fnv(FNV_OFFSET, &serde_json::to_vec(nodes).unwrap_or_default())}@@ -2284,7 +2300,10 @@ impl Scene {}fn swap_vector(&mut self, cel: String, raster: Raster, dirty: &mut BTreeSet<usize>) {- dirty.extend(occupied(self.rasters.get(&cel)).chain(occupied(Some(&raster))));+ match self.rasters.get(&cel) {+ Some(old) => dirty.extend(old.differs(&raster)),+ None => dirty.extend(occupied(Some(&raster))),+ }let previous = self.vector_hash.get(&cel).copied();if let (Some(hash), Some(old)) = (previous, self.rasters.insert(cel.clone(), raster)) {self.retire(&cel, hash, old);@@ -2564,7 +2583,14 @@ impl Scene {let doc = &self.bundle.doc;let fresh = missing.par_iter()- .map(|(cel, _)| rasterize_nodes(&nodes_of(doc, cel), w, h).map(|r| (cel.clone(), r)))+ .map(|(cel, _)| {+ let before = nodes_of(old, cel);+ let drawn = self+ .rasters+ .get(cel)+ .filter(|_| self.vector_hash.get(cel) == Some(&nodes_hash(&before)));+ redraw(&nodes_of(doc, cel), drawn.map(|r| (&before[..], r)), (w, h)).map(|r| (cel.clone(), r))+ }).collect::<Result<Vec<_>>>()?;recalled.into_iter()diff --git a/crates/brush/src/tiles.rs b/crates/brush/src/tiles.rsindex 2a9be1f..43094d6 100644--- a/crates/brush/src/tiles.rs+++ b/crates/brush/src/tiles.rs@@ -96,6 +96,24 @@ impl<T: Copy + Default, const C: usize> TileGrid<T, C> {self.tiles.iter().filter(|t| t.is_some()).count()}+ pub fn differs(&self, other: &Self) -> Vec<usize>+ where+ T: PartialEq,+ {+ (0..self.tiles.len().max(other.tiles.len()))+ .filter(|&i| {+ match (+ self.tiles.get(i).and_then(Option::as_ref),+ other.tiles.get(i).and_then(Option::as_ref),+ ) {+ (None, None) => false,+ (Some(a), Some(b)) => !Arc::ptr_eq(a, b) && a[..] != b[..],+ _ => true,+ }+ })+ .collect()+ }+pub fn bytes(&self) -> usize {self.count() * TILE_PX * C * std::mem::size_of::<T>()}@@ -456,6 +474,24 @@ mod tests {assert_eq!(grid.count(), 0);}+ #[test]+ fn grids_tell_which_tiles_differ_without_comparing_shared_ones() {+ let mut a = Raster::new(600, 300);+ a.put(0, vec![f16::ONE; TILE_PX * 4].into_boxed_slice());+ a.put(2, vec![f16::ONE; TILE_PX * 4].into_boxed_slice());+ let mut b = a.clone();+ assert!(a.differs(&b).is_empty());+ b.put(2, vec![f16::ONE; TILE_PX * 4].into_boxed_slice());+ assert!(+ a.differs(&b).is_empty(),+ "equal pixels in a new tile are not a difference"+ );+ b.ensure(2)[7] = f16::ZERO;+ b.clear(0);+ b.put(4, vec![f16::ONE; TILE_PX * 4].into_boxed_slice());+ assert_eq!(a.differs(&b), vec![0, 2, 4]);+ }+#[test]fn raster_encode_round_trip() {let mut raster = Raster::new(600, 300);diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rsindex e93ae5c..c299d7c 100644--- a/crates/render/src/lib.rs+++ b/crates/render/src/lib.rs@@ -809,6 +809,129 @@ pub fn rasterize_nodes_at(nodes: &[klad_core::doc::Node], width: u32, height: u3Ok(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)));+ let Some(reach) = touched+ .map(|n| vector::node_reach(n).with_context(|| format!("node {}", n.id)))+ .collect::<Result<Option<Vec<Rect>>>>()?+ else {+ return Ok(None);+ };+ 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, Option<IRect>)> = nodes+ .iter()+ .filter(|n| n.visible)+ .map(|n| {+ let reach = vector::node_reach(n).with_context(|| format!("node {}", n.id))?;+ Ok((n, reach.map(|r| skia_safe::RoundOut::<IRect>::round_out(&r))))+ })+ .collect::<Result<_>>()?;+ let touching: Vec<&(&klad_core::doc::Node, Option<IRect>)> = shown+ .iter()+ .filter(|(_, reach)| reach.is_none_or(|r| IRect::intersects(&r, &wanted)))+ .collect();+ let region = touching+ .iter()+ .try_fold(wanted, |region, (_, reach)| {+ reach.map(|r| IRect::join(®ion, &IRect::intersect(&r, &canvas).unwrap_or(region)))+ })+ .unwrap_or(canvas);+ 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,@@ -1285,6 +1408,124 @@ mod tests {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 rasterized_vectors_and_swapped_tiles_match() {let mut doc = Document::new(600, 300);diff --git a/crates/render/src/vector.rs b/crates/render/src/vector.rsindex d51fb40..20b6958 100644--- a/crates/render/src/vector.rs+++ b/crates/render/src/vector.rs@@ -250,7 +250,30 @@ pub fn draw_nodes(canvas: &Canvas, nodes: &[Node]) -> Result<()> {.try_for_each(|n| draw_node(canvas, n))}-fn draw_node(canvas: &Canvas, node: &Node) -> Result<()> {+pub fn node_reach(node: &Node) -> Result<Option<Rect>> {+ fn pad(node: &Node) -> Result<f32> {+ let own = node.stroke.as_ref().map_or(0.0, |s| s.width * 4.0) + node.blur * 4.0 + 4.0;+ let grow = instances(&node.shape)+ .iter()+ .map(Matrix::max_scale)+ .fold(1.0f32, f32::max);+ node.shape.children().iter().try_fold(own, |most, child| {+ Ok(most.max(pad(child)? * grow * node_matrix(child)?.max_scale().max(1.0)))+ })+ }+ let Some(local) = local_bounds(node)? else {+ return Ok(None);+ };+ let pad = pad(node)?;+ Ok(Some(+ node_matrix(node)?+ .map_rect(local.with_outset((pad, pad)))+ .0+ .with_outset((4.0, 4.0)),+ ))+}++pub(crate) fn draw_node(canvas: &Canvas, node: &Node) -> Result<()> {let context = || format!("node {}", node.id);let matrix = node_matrix(node).with_context(context)?;let depth = canvas.save();