Skip to content

armgit / klad

Public Imported from GitHub
0

A drawing app built for agent/human collaboration

Rust

Drag previews give way to edits, tool switches and refills

Indicode BV7cc9aa737673
diff --git a/crates/app/src/composite.rs b/crates/app/src/composite.rs
index ddb6913..49a31d6 100644
--- a/crates/app/src/composite.rs
+++ b/crates/app/src/composite.rs
@@ -2312,6 +2312,10 @@ impl Scene {
compose_tile(items, &job)
}
+ pub fn uses_caches(&self) -> bool {
+ self.fast
+ }
+
pub fn preview_snapshot(&self, cels: &[String], brushes: &BrushSet) -> Option<crate::preview::Snapshot> {
if self.slimmed() || self.stale || (self.tint_mask && self.active_is_mask()) {
return None;
@@ -2331,6 +2335,7 @@ impl Scene {
cels: replays,
onions: self.onion_map().cloned(),
brushes: brushes.clone(),
+ vectors: std::sync::OnceLock::new(),
})
}
@@ -3333,6 +3338,7 @@ mod tests {
snap: std::sync::Arc::new(scene.preview_snapshot(cels, brushes).unwrap()),
shown: BTreeSet::new(),
visible: scene.all_tiles().into_iter().collect(),
+ cancel: std::sync::Arc::default(),
}
.run()
.unwrap()
diff --git a/crates/app/src/editor.rs b/crates/app/src/editor.rs
index 1c3083e..ef2c122 100644
--- a/crates/app/src/editor.rs
+++ b/crates/app/src/editor.rs
@@ -70,6 +70,7 @@ use serde_json::{Map, Value, json};
use std::collections::{BTreeMap, BTreeSet, VecDeque};
use std::ops::RangeInclusive;
use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
use std::sync::mpsc::{Receiver, channel};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
@@ -443,13 +444,26 @@ struct Finish {
struct PreviewState {
snap: Arc<preview::Snapshot>,
+ pending: BTreeSet<usize>,
+ cancel: Arc<AtomicBool>,
asked: Option<Vec<Op>>,
+ asked_at: Option<Vec2>,
job: Option<Receiver<Result<preview::Done>>>,
shown: BTreeSet<usize>,
done: Option<(Vec<Op>, bool, BTreeSet<usize>)>,
finish: Option<Finish>,
}
+impl PreviewState {
+ fn release(&mut self) -> Vec<usize> {
+ self.cancel.store(true, AtomicOrdering::Relaxed);
+ std::mem::take(&mut self.shown)
+ .into_iter()
+ .chain(self.finish.take().into_iter().flat_map(|f| f.dirty))
+ .collect()
+ }
+}
+
struct Live {
stroke: Stroke,
painter: StrokePainter,
@@ -1392,26 +1406,36 @@ impl Editor {
}
fn drop_preview(&mut self) {
- if let Some(state) = self.preview.take() {
- self.dirty.extend(state.shown);
- if let Some(finish) = state.finish {
- self.dirty.extend(finish.dirty);
- }
+ if let Some(mut state) = self.preview.take() {
+ self.dirty.extend(state.release());
}
}
- fn finish_preview(&mut self, ops: Vec<Op>, dirty: Vec<usize>) {
+ fn settle(&mut self, pending: &BTreeSet<usize>, settled: &BTreeSet<usize>, rest: Vec<usize>) {
+ self.dirty.retain(|i| !(settled.contains(i) && pending.contains(i)));
+ self.dirty.extend(rest.into_iter().filter(|i| !settled.contains(i)));
+ }
+
+ fn finish_preview(&mut self, ops: Vec<Op>, dirty: Vec<usize>, before: u64) {
let Some(mut state) = self.preview.take() else {
self.dirty.extend(dirty);
return;
};
+ if state.snap.rev != before {
+ self.dirty.extend(dirty.into_iter().chain(state.release()));
+ return;
+ }
match state.done.take() {
Some((done, exact, composed)) if state.job.is_none() && done == ops => {
- let settled = |i: &usize| exact && composed.contains(i);
- self.dirty.retain(|i| !settled(i));
- self.dirty
- .extend(dirty.into_iter().chain(state.shown).filter(|i| !settled(i)));
+ let settled = match exact && !self.scene.uses_caches() {
+ true => composed,
+ false => BTreeSet::new(),
+ };
+ let pending = std::mem::take(&mut state.pending);
+ let rest = dirty.into_iter().chain(state.release()).collect();
+ self.settle(&pending, &settled, rest);
}
+ Some((_, false, _)) => self.dirty.extend(dirty.into_iter().chain(state.release())),
done => {
state.done = done;
state.finish = Some(Finish {
@@ -1426,6 +1450,9 @@ impl Editor {
}
fn tend_preview(&mut self, visible: BTreeSet<usize>) -> Result<Tiles> {
+ if self.drag.is_some() && !matches!(self.tool, Tool::Select | Tool::Strokes) {
+ self.drag = None;
+ }
let mut uploads = Vec::new();
let rev = self.scene.bundle.doc.rev;
if let Some(mut state) = self.preview.take() {
@@ -1444,50 +1471,48 @@ impl Editor {
if current {
uploads = done.tiles;
}
- if last || !current {
+ if !current {
keep = false;
- let settled: BTreeSet<usize> = match current && done.exact {
+ self.dirty.extend(earlier.into_iter().chain(done.hidden));
+ self.dirty.extend(state.release());
+ } else if last {
+ keep = false;
+ let settled = match done.exact && !self.scene.uses_caches() {
true => composed,
false => BTreeSet::new(),
};
- self.dirty.retain(|i| !settled.contains(i));
- let finished = state.finish.take().map(|f| f.dirty).unwrap_or_default();
- self.dirty.extend(
- finished
- .into_iter()
- .chain(earlier)
- .chain(state.shown.iter().copied())
- .chain(done.hidden)
- .filter(|i| !settled.contains(i)),
- );
+ let pending = std::mem::take(&mut state.pending);
+ let rest = earlier.into_iter().chain(done.hidden).chain(state.release()).collect();
+ self.settle(&pending, &settled, rest);
} else {
state.done = Some((done.ops, done.exact, composed));
}
}
Some(Err(e)) => {
keep = false;
- self.dirty.extend(state.shown.iter().copied());
- self.dirty
- .extend(state.finish.iter().flat_map(|f| f.dirty.iter().copied()));
+ self.dirty.extend(state.release());
self.failed(e.context("the moved picture could not be drawn"));
}
None => {}
}
- let abandoned = state.finish.is_none() && self.drag.is_none();
- if keep && (abandoned || state.finish.as_ref().is_some_and(|f| f.since.elapsed() > FINISH_WAIT)) {
- keep = false;
- self.dirty.extend(state.shown.iter().copied());
- self.dirty
- .extend(state.finish.iter().flat_map(|f| f.dirty.iter().copied()));
- }
if keep {
- self.preview = Some(state);
+ let stale =
+ state.finish.is_none() && (self.drag.is_none() || state.snap.rev != rev || !self.canvas_current());
+ let late = state.finish.as_ref().is_some_and(|f| f.since.elapsed() > FINISH_WAIT);
+ match stale || late {
+ true => {
+ uploads.clear();
+ self.dirty.extend(state.release());
+ }
+ false => self.preview = Some(state),
+ }
}
}
if self.preview.is_none()
&& self.live.is_none()
&& self.drag.as_ref().is_some_and(|d| d.moved() && !d.copy)
&& self.canvas_current()
+ && self.dirty.len() <= timeline::FILL
{
let cels = self.preview_cels();
self.preview = self
@@ -1495,36 +1520,46 @@ impl Editor {
.preview_snapshot(&cels, &self.brushes)
.map(|snap| PreviewState {
snap: Arc::new(snap),
+ pending: self.dirty.clone(),
+ cancel: Arc::default(),
asked: None,
+ asked_at: None,
job: None,
shown: BTreeSet::new(),
done: None,
finish: None,
});
}
- let wanted = match self.preview.as_ref().map(|p| p.finish.as_ref()) {
- Some(Some(finish)) => Some(finish.ops.clone()),
- Some(None) => self.drag_ops(),
- None => None,
+ let position = self.drag.as_ref().map(|d| d.now);
+ let ready = self
+ .preview
+ .as_ref()
+ .filter(|p| p.job.is_none())
+ .map(|p| p.finish.as_ref().map(|f| f.ops.clone()).ok_or(p.asked_at != position));
+ let wanted = match ready {
+ Some(Ok(finish)) => Some(finish),
+ Some(Err(true)) => self.drag_ops(),
+ _ => None,
};
- if let (Some(state), Some(ops)) = (self.preview.as_mut(), wanted)
- && state.job.is_none()
- && state.asked.as_ref() != Some(&ops)
- {
- let job = preview::Job {
- ops: ops.clone(),
- snap: state.snap.clone(),
- shown: state.shown.clone(),
- visible,
- };
- state.asked = Some(ops);
- let (tx, rx) = channel();
- let ctx = self.ctx.clone();
- crate::background().spawn(move || {
- let _ = tx.send(job.run());
- ctx.request_repaint();
- });
- state.job = Some(rx);
+ if let (Some(state), Some(ops)) = (self.preview.as_mut(), wanted) {
+ state.asked_at = position;
+ if state.asked.as_ref() != Some(&ops) {
+ let job = preview::Job {
+ ops: ops.clone(),
+ snap: state.snap.clone(),
+ shown: state.shown.clone(),
+ visible,
+ cancel: state.cancel.clone(),
+ };
+ state.asked = Some(ops);
+ let (tx, rx) = channel();
+ let ctx = self.ctx.clone();
+ crate::background().spawn(move || {
+ let _ = tx.send(job.run());
+ ctx.request_repaint();
+ });
+ state.job = Some(rx);
+ }
}
Ok(uploads)
}
@@ -1652,8 +1687,9 @@ impl Editor {
self.drop_preview();
return Ok(());
};
+ let before = self.scene.bundle.doc.rev;
let dirty = self.commit(ops.clone())?;
- self.finish_preview(ops, dirty);
+ self.finish_preview(ops, dirty, before);
Ok(())
}
@@ -1765,10 +1801,11 @@ impl Editor {
let start = Instant::now();
match self.picked_ops(LassoAction::Transform(drag.mark_transform())) {
Some((ops, after)) => {
+ let before = self.scene.bundle.doc.rev;
let dirty = self.commit(ops.clone())?;
self.picked = after;
self.forget_missing_selection();
- self.finish_preview(ops, dirty);
+ self.finish_preview(ops, dirty, before);
}
None => self.drop_preview(),
}
@@ -2960,7 +2997,7 @@ impl Editor {
opacity: l.stroke.opacity,
blend: stroke_blend(&l.brush, l.stroke.lock).unwrap_or(l.brush.blend),
});
- let mut uploads = if tiles.is_empty() && stroke.is_empty() {
+ let uploads = if tiles.is_empty() && stroke.is_empty() {
Vec::new()
} else {
self.scene.compose_painting(&stroke, &tiles, preview.as_ref())?
@@ -2974,7 +3011,7 @@ impl Editor {
stats.compose_ms.push(spent as f32);
stats.tiles.push(uploads.len() as f32);
}
- uploads.extend(previewed);
+ let uploads: Tiles = previewed.into_iter().chain(uploads).collect();
let (frame_uploads, frame_drops) = self.frames.take();
lock(&self.outbox).send(uploads, frame_uploads, frame_drops);
ui.painter().add(egui_wgpu::Callback::new_paint_callback(
diff --git a/crates/app/src/editor/ui_tests.rs b/crates/app/src/editor/ui_tests.rs
index af90ccb..0a656a5 100644
--- a/crates/app/src/editor/ui_tests.rs
+++ b/crates/app/src/editor/ui_tests.rs
@@ -1278,6 +1278,53 @@ fn a_tap_that_wobbles_selects_and_a_drag_past_three_points_moves() {
let _ = std::fs::remove_dir_all(&path);
}
+#[test]
+fn an_edit_or_a_tool_switch_during_a_drag_leaves_the_right_picture() {
+ let path = sample("interrupted");
+ let mut h = harness(editor(&path), vec2(1440.0, 900.0));
+ activate(&mut h, "shapes");
+ h.state_mut().tool = Tool::Select;
+ let view = h.state().view.unwrap();
+ let rect = h.state().canvas_rect;
+ let corner = rect.min + view.to_screen(egui::Vec2::new(120.0, 30.0), rect.size());
+ let press = |h: &mut Harness<'static, Editor>, from: egui::Pos2, steps: usize| {
+ h.hover_at(from);
+ h.run_steps(1);
+ h.drag_at(from);
+ h.run_steps(1);
+ (1..=steps).for_each(|i| {
+ h.hover_at(from + vec2(12.0 * i as f32, 6.0 * i as f32));
+ h.run_steps(1);
+ std::thread::sleep(std::time::Duration::from_millis(10));
+ h.run_steps(1);
+ });
+ };
+ press(&mut h, corner, 3);
+ settle(&mut h, |ed| ed.preview.as_ref().is_some_and(|p| p.done.is_some()));
+ let lines = h.state().scene.bundle.doc.find_layer("lines").unwrap().id.clone();
+ h.state_mut()
+ .apply(parse_lines(&format!(r#"{{"op":"set","id":"{lines}","opacity":0.4}}"#)).unwrap())
+ .unwrap();
+ (4..=6).for_each(|i| {
+ h.hover_at(corner + vec2(12.0 * i as f32, 6.0 * i as f32));
+ h.run_steps(1);
+ std::thread::sleep(std::time::Duration::from_millis(10));
+ h.run_steps(1);
+ });
+ h.drop_at(corner + vec2(72.0, 36.0));
+ h.run_steps(1);
+ canvas_shows_the_committed_picture(&mut h);
+ let moved = h.state().scene.bundle.doc.rev;
+ press(&mut h, corner + vec2(72.0, 36.0), 4);
+ settle(&mut h, |ed| ed.preview.as_ref().is_some_and(|p| p.done.is_some()));
+ h.state_mut().tool = Tool::Brush;
+ h.run_steps(2);
+ assert!(h.state().drag.is_none(), "a tool switch ends the drag");
+ canvas_shows_the_committed_picture(&mut h);
+ assert_eq!(h.state().scene.bundle.doc.rev, moved, "an ended drag commits nothing");
+ let _ = std::fs::remove_dir_all(&path);
+}
+
#[test]
fn a_layer_made_and_activated_at_once_or_mid_refill_still_draws() {
let path = sample("made");
diff --git a/crates/app/src/preview.rs b/crates/app/src/preview.rs
index d60437e..9b5609a 100644
--- a/crates/app/src/preview.rs
+++ b/crates/app/src/preview.rs
@@ -1,5 +1,5 @@
use crate::composite::{compose_items, dilate, effect_reach};
-use anyhow::{Result, anyhow};
+use anyhow::{Result, anyhow, bail};
use half::f16;
use klad_brush::tiles::TILE_PX;
use klad_brush::{BrushSet, CelReplay, Raster};
@@ -10,7 +10,8 @@ use klad_render::onion::Onions;
use klad_render::{Rasters, changed_tiles, rasterize_nodes, rasterize_tiles};
use rayon::prelude::*;
use std::collections::{BTreeMap, BTreeSet};
-use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, OnceLock};
pub struct Snapshot {
pub rev: u64,
@@ -20,6 +21,7 @@ pub struct Snapshot {
pub cels: BTreeMap<String, CelReplay>,
pub onions: Option<Onions>,
pub brushes: BrushSet,
+ pub vectors: OnceLock<BTreeMap<String, Vec<Node>>>,
}
pub struct Job {
@@ -27,6 +29,7 @@ pub struct Job {
pub snap: Arc<Snapshot>,
pub shown: BTreeSet<usize>,
pub visible: BTreeSet<usize>,
+ pub cancel: Arc<AtomicBool>,
}
pub struct Done {
@@ -47,13 +50,21 @@ fn vector_nodes(doc: &klad_core::doc::Document, frame: u32) -> BTreeMap<String,
}
impl Job {
+ fn check(&self) -> Result<()> {
+ if self.cancel.load(Ordering::Relaxed) {
+ bail!("the drag ended");
+ }
+ Ok(())
+ }
+
pub fn run(self) -> Result<Done> {
let snap = &self.snap;
let (doc, mut applied) = apply_all(&snap.bundle.doc, &self.ops)?;
+ self.check()?;
let (w, h) = (doc.canvas.width, doc.canvas.height);
let mut rasters = snap.rasters.clone();
let mut changed = BTreeSet::new();
- let before = vector_nodes(&snap.bundle.doc, snap.frame);
+ let before = snap.vectors.get_or_init(|| vector_nodes(&snap.bundle.doc, snap.frame));
let redrawn = vector_nodes(&doc, snap.frame)
.into_iter()
.filter(|(cel, nodes)| before.get(cel) != Some(nodes))
@@ -108,6 +119,7 @@ impl Job {
rasters.insert(pending.cel.clone(), raster);
Ok::<_, anyhow::Error>(())
})?;
+ self.check()?;
let cols = (w as usize).div_ceil(klad_brush::TILE);
let rows = (h as usize).div_ceil(klad_brush::TILE);
let reach = effect_reach(&doc, &doc.layers);
@@ -121,6 +133,7 @@ impl Job {
let tiles = now
.par_iter()
.map(|&i| {
+ self.check()?;
let tile = compose_items(
&doc,
snap.frame,