A drawing app built for agent/human collaboration
Rust
mod between;
mod bones;
mod brushwin;
mod buffer;
mod cells;
mod checks;
mod clips;
mod commands;
mod compare;
mod copy;
mod depth;
mod export;
mod first;
mod history;
mod keys;
mod layers;
mod look;
mod make;
mod options;
mod paintover;
mod panels;
mod pins;
mod pixels;
mod prefs;
mod selection;
mod shift;
mod text;
mod timeline;
mod tweens;
#[cfg(test)]
pub(crate) use commands::install_job;
#[cfg(test)]
mod drag_time;
#[cfg(test)]
mod ui_tests;
use crate::color::{self, Hsva};
use crate::commands::Cmd;
use crate::composite::{Preview, Scene, Tiles};
use crate::frames::FrameCache;
use crate::gpu::{CanvasPaint, Outbox};
use crate::jobs::Jobs;
use crate::lift;
use crate::messages::{Messages, Tone};
use crate::pen::{self, Pen, PenEvent, Phase, device_key};
use crate::preview;
use crate::settings::{self, Settings};
use crate::stats::{Stats, lock};
use crate::sync::{Watch, watch};
use crate::theme::Hint;
use crate::view::View;
use anyhow::{Result, anyhow};
use egui::{Color32, Key, Pos2, Rect, Sense, Vec2, vec2};
use klad_brush::{
Brush, BrushSet, PressureCurve, Raster, Raw, Recorder, StrokeBuffer, StrokePainter, flood, needs_repaint, polygon,
stroke_blend,
};
use klad_core::brushes::{BrushDef, Curve, TipDef, pick_id};
use klad_core::bundle::now_ms;
use klad_core::color::parse_hex;
use klad_core::doc::{Item, Kind, Linear, Loc, MASK, Node, Paint, Radial, Shape, Stop};
use klad_core::fill::{self, Fill, FillRef, FillSource, Seed};
use klad_core::history::Stack;
use klad_core::markedit::{self, LassoAction, MarkTransform, address, apply_affine, invert};
use klad_core::notes::{self, Note};
use klad_core::ops::{LassoSpec, Op, apply_all};
use klad_core::pathedit::{self, PathEdit, Side, Subpath};
use klad_core::rng::{FNV_OFFSET, Rng, fnv};
use klad_core::stroke::{Mark, Stroke, encode_cel};
use klad_render::{overlay, vector};
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};
const HANDLE: f32 = 12.0;
const REFILL_MS: f64 = 8.0;
const FINISH_WAIT: Duration = Duration::from_secs(2);
const DRAG_SLOP: f32 = 3.0;
const KNOB: f32 = 30.0;
const IDENTITY: [f32; 6] = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0];
const GRID_FROM: f32 = 8.0;
pub(crate) const REAL_MAX: u32 = 512;
type RealKey = (u64, u32, u64);
fn raw_of(e: &PenEvent, c: Vec2, dt_ms: f32) -> Raw {
Raw {
x: c.x,
y: c.y,
pressure: e.recorded_pressure(),
tilt: e.tilt,
dt_ms,
}
}
fn to_canvas(m: [f32; 6], p: [f32; 2]) -> Vec2 {
let (x, y) = apply_affine(m, (p[0], p[1]));
vec2(x, y)
}
fn to_local(m: [f32; 6], c: Vec2) -> [f32; 2] {
invert(m).map_or([c.x, c.y], |inverse| {
let (x, y) = apply_affine(inverse, (c.x, c.y));
[x, y]
})
}
fn ms(start: Instant) -> f64 {
start.elapsed().as_secs_f64() * 1000.0
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Tool {
Brush,
Fill,
Select,
Strokes,
Direct,
Pen,
Shape,
Text,
Note,
Bone,
}
struct PenPath {
anchors: Vec<pathedit::Anchor>,
dragging: bool,
}
#[derive(Clone, Debug, PartialEq)]
struct Part {
layer: String,
cel: String,
ids: Vec<u32>,
}
#[derive(Clone, Debug, PartialEq)]
struct Picked {
cel: String,
ids: Vec<u32>,
cut: Option<Vec<[f32; 2]>>,
more: Vec<Part>,
}
type PartMarks<'a> = (String, String, &'a [Mark], &'a [u32]);
impl Picked {
fn whole(cel: String, ids: Vec<u32>) -> Self {
Self {
cel,
ids,
cut: None,
more: Vec::new(),
}
}
fn key(&self) -> String {
let list = |cel: &str, ids: &[u32]| {
let ids: Vec<String> = ids.iter().map(u32::to_string).collect();
format!("{cel}:{}", ids.join(","))
};
let base = std::iter::once(list(&self.cel, &self.ids))
.chain(self.more.iter().map(|p| list(&p.cel, &p.ids)))
.collect::<Vec<_>>()
.join(";");
match &self.cut {
Some(polygon) => {
let bytes: Vec<u8> = polygon.iter().flatten().flat_map(|v| v.to_le_bytes()).collect();
format!("{base}:cut{:x}", fnv(FNV_OFFSET, &bytes))
}
None => base,
}
}
fn addresses(&self) -> Vec<String> {
self.ids
.iter()
.map(|id| address(&self.cel, *id))
.chain(
self.more
.iter()
.flat_map(|p| p.ids.iter().map(|id| address(&p.cel, *id))),
)
.collect()
}
fn count(&self) -> usize {
self.ids.len() + self.more.iter().map(|p| p.ids.len()).sum::<usize>()
}
}
fn union_box(a: Option<[f32; 4]>, b: Option<[f32; 4]>) -> Option<[f32; 4]> {
match (a, b) {
(Some(a), Some(b)) => Some([a[0].min(b[0]), a[1].min(b[1]), a[2].max(b[2]), a[3].max(b[3])]),
(a, b) => a.or(b),
}
}
#[derive(Clone, Debug, PartialEq)]
struct Direct {
node: String,
points: BTreeSet<usize>,
also: BTreeMap<String, BTreeSet<usize>>,
}
#[derive(Clone, Copy, Debug, PartialEq)]
enum PointGrab {
Anchors,
Handle(usize, Side),
Marquee { on_shape: bool },
}
#[derive(Clone, Copy, Debug)]
struct PointDrag {
grab: PointGrab,
start: Vec2,
now: Vec2,
free: bool,
}
struct PathCommit {
job: Receiver<Result<(u64, Raster)>>,
ops: Vec<Op>,
cel: String,
preview: Vec<Subpath>,
also: Vec<Shaped>,
node: String,
}
#[derive(Clone)]
struct Shaped {
node: String,
rev: u64,
subs: Vec<Subpath>,
matrix: [f32; 6],
}
#[derive(Clone, Debug, PartialEq)]
struct FillTool {
reference: FillRef,
tolerance: f32,
gap: f32,
expand: f32,
opacity: f32,
}
impl Default for FillTool {
fn default() -> Self {
Self {
reference: FillRef::This,
tolerance: fill::TOLERANCE,
gap: 4.0,
expand: fill::EXPAND,
opacity: 1.0,
}
}
}
struct Lasso {
points: Vec<Vec2>,
start: Pos2,
far: bool,
}
struct CutView {
key: String,
rev: u64,
marks: Vec<Mark>,
lassoed: Vec<u32>,
chosen: Vec<u32>,
more: Vec<PartView>,
}
struct PartView {
layer: String,
cel: String,
marks: Vec<Mark>,
lassoed: Vec<u32>,
chosen: Vec<u32>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Grab {
Move,
Scale,
Rotate,
Stretch(usize),
}
fn grab(screen: [Pos2; 4], pos: Pos2, edges: bool) -> Option<Grab> {
let reach = crate::theme::GRAB;
let top = screen[0].lerp(screen[1], 0.5);
let center = screen.iter().fold(Vec2::ZERO, |a, p| a + p.to_vec2()) / 4.0;
let knob = top + (top.to_vec2() - center).normalized() * KNOB;
if pos.distance(knob) <= reach {
return Some(Grab::Rotate);
}
if screen.iter().any(|c| pos.distance(*c) <= reach) {
return Some(Grab::Scale);
}
let flat = screen.map(|p| p.to_vec2());
if let Some(side) = (0..4).find(|&side| edges && pos.distance(edge(&flat, side).to_pos2()) <= reach) {
return Some(Grab::Stretch(side));
}
let (min, max) = screen
.iter()
.fold((screen[0], screen[0]), |(lo, hi), p| (lo.min(*p), hi.max(*p)));
Rect::from_min_max(min, max).contains(pos).then_some(Grab::Move)
}
fn edge(corners: &[Vec2; 4], side: usize) -> Vec2 {
(corners[side] + corners[(side + 1) % 4]) / 2.0
}
fn transform_props(t: &klad_core::doc::Transform) -> Map<String, Value> {
[
("transform.x", json!(t.x)),
("transform.y", json!(t.y)),
("transform.rotate", json!(t.rotate)),
("transform.sx", json!(t.sx)),
("transform.sy", json!(t.sy)),
]
.into_iter()
.map(|(k, v)| (k.to_string(), v))
.collect()
}
struct Drag {
grab: Grab,
node: String,
strokes: bool,
whole: bool,
fresh: bool,
copy: bool,
start: Vec2,
now: Vec2,
center: Vec2,
corners: [Vec2; 4],
slop: f32,
crossed: bool,
}
impl Drag {
fn to(&mut self, at: Vec2) {
self.now = at;
self.crossed |= (self.now - self.start).length() > self.slop;
}
fn scale(&self) -> f32 {
if self.grab != Grab::Scale {
return 1.0;
}
let free = ((self.now - self.center).length() / (self.start - self.center).length().max(1.0)).clamp(0.02, 50.0);
match self.whole {
true => free.round().max(1.0),
false => free,
}
}
fn angle(&self) -> f32 {
if self.grab != Grab::Rotate {
return 0.0;
}
let free = (self.now - self.center).angle() - (self.start - self.center).angle();
match self.whole {
true => (free / std::f32::consts::FRAC_PI_2).round() * std::f32::consts::FRAC_PI_2,
false => free,
}
}
fn slide(&self) -> Vec2 {
let d = self.now - self.start;
match self.whole {
true => vec2(d.x.round(), d.y.round()),
false => d,
}
}
fn stretch(&self) -> Option<(usize, Vec2, f32)> {
let Grab::Stretch(side) = self.grab else {
return None;
};
let pivot = edge(&self.corners, (side + 2) % 4);
let axis = if side % 2 == 0 { 1 } else { 0 };
let span = self.start[axis] - pivot[axis];
let k = if span.abs() < 1.0 {
1.0
} else {
(self.now[axis] - pivot[axis]) / span
};
let k = if k.abs() < 0.02 {
0.02f32.copysign(k)
} else {
k.clamp(-50.0, 50.0)
};
let k = match self.whole {
true if k.round() == 0.0 => 1.0f32.copysign(k),
true => k.round(),
false => k,
};
Some((axis, pivot, k))
}
fn affine(&self) -> [f32; 6] {
let c = self.center;
if let Some((axis, pivot, k)) = self.stretch() {
return match axis {
0 => [k, 0.0, 0.0, 1.0, pivot.x * (1.0 - k), 0.0],
_ => [1.0, 0.0, 0.0, k, 0.0, pivot.y * (1.0 - k)],
};
}
match self.grab {
Grab::Move => {
let d = self.slide();
[1.0, 0.0, 0.0, 1.0, d.x, d.y]
}
Grab::Scale => {
let k = self.scale();
[k, 0.0, 0.0, k, c.x * (1.0 - k), c.y * (1.0 - k)]
}
Grab::Rotate => {
let (s, k) = self.angle().sin_cos();
[k, -s, s, k, c.x - k * c.x + s * c.y, c.y - s * c.x - k * c.y]
}
Grab::Stretch(_) => IDENTITY,
}
}
fn preview(&self) -> [Vec2; 4] {
let a = self.affine();
self.corners.map(|c| {
let (x, y) = lift::affine_apply(a, (c.x, c.y));
vec2(x, y)
})
}
fn moved(&self) -> bool {
self.crossed
}
fn mark_transform(&self) -> MarkTransform {
let pivot = Some([self.center.x, self.center.y]);
if let Some((axis, at, k)) = self.stretch() {
return MarkTransform {
sx: if axis == 0 { k } else { 1.0 },
sy: if axis == 1 { k } else { 1.0 },
pivot: Some([at.x, at.y]),
..Default::default()
};
}
match self.grab {
Grab::Move => {
let d = self.slide();
MarkTransform {
x: d.x,
y: d.y,
..Default::default()
}
}
Grab::Scale => MarkTransform {
sx: self.scale(),
sy: self.scale(),
pivot,
..Default::default()
},
Grab::Rotate => MarkTransform {
rotate: self.angle().to_degrees(),
pivot,
..Default::default()
},
Grab::Stretch(_) => MarkTransform::default(),
}
}
}
struct Finish {
ops: Vec<Op>,
rev: u64,
dirty: BTreeSet<usize>,
since: Instant,
}
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>,
posed: Option<(u64, u32, String, klad_core::rig::Pose)>,
}
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()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum PixelMode {
Draw,
Lighter,
Darker,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum PixelShape {
Rect,
Ellipse,
Line,
}
struct PixelLive {
run: Vec<klad_core::pixel::Cell>,
erase: bool,
}
struct Live {
stroke: Stroke,
painter: StrokePainter,
brush: Brush,
recorder: Recorder,
last_at: Instant,
twin: Option<(f32, Stroke, StrokePainter)>,
}
#[derive(Clone, Copy, Debug, PartialEq)]
struct Tuning {
hardness: Option<f32>,
feather: f32,
size_min: f32,
size_gamma: f32,
taper: [f32; 2],
stabilizer: f32,
smoothing: f32,
}
impl Tuning {
fn of(def: &BrushDef) -> Self {
let curve = def.dynamics.size.pressure.unwrap_or(Curve {
min: 1.0,
max: 1.0,
gamma: 1.0,
});
Self {
hardness: def.hardness(),
feather: def.feather,
size_min: curve.min,
size_gamma: curve.gamma,
taper: def.taper,
stabilizer: def.stabilizer,
smoothing: def.smoothing,
}
}
fn shape(&self, base: &BrushDef) -> BrushDef {
let mut def = base.clone();
if let (Some(hardness), TipDef::Round { .. }) = (self.hardness, &def.tip) {
def.tip = TipDef::Round { hardness };
}
def.feather = self.feather;
let old = Tuning::of(base);
if (self.size_min, self.size_gamma) != (old.size_min, old.size_gamma) {
def.dynamics.size.pressure = Some(Curve {
min: self.size_min,
max: 1.0,
gamma: self.size_gamma,
});
}
def
}
}
#[derive(Default)]
struct Readout {
pressure: f32,
device: u64,
tilt: (f32, f32),
eraser: bool,
tablet: bool,
samples: VecDeque<Instant>,
}
#[derive(Default)]
struct Windows {
settings: bool,
brush: bool,
log: bool,
onion: bool,
link: bool,
clip: bool,
between: bool,
import: bool,
palettes: bool,
about: bool,
export: bool,
pixels: bool,
tiles: bool,
report: bool,
font: bool,
paintover: bool,
compare: bool,
}
#[derive(Default)]
struct PaletteState {
query: String,
selected: usize,
opened: bool,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) enum Want {
New,
Open,
Recent,
Close,
Path(std::path::PathBuf),
}
pub(crate) struct Editor {
pub(crate) scene: Scene,
brushes: BrushSet,
embedded: BTreeMap<String, BrushDef>,
buffer: StrokeBuffer,
live: Option<Live>,
tool: Tool,
brush: String,
previous_brush: String,
tuning: Tuning,
size: f32,
color: [f32; 4],
hsva: Hsva,
swatch_name: String,
fill: FillTool,
lasso: Option<Lasso>,
modifiers: egui::Modifiers,
opacity: f32,
flow: f32,
pub(crate) settings: Settings,
pub(crate) settings_path: Option<PathBuf>,
pub(crate) settings_dirty: bool,
pub(crate) update: Option<crate::updates::Release>,
pub(crate) update_feed: String,
update_check: Option<std::sync::mpsc::Receiver<crate::updates::Checked>>,
update_said: Option<String>,
pub(crate) wants: Option<Want>,
view: Option<View>,
canvas_rect: Rect,
navigating: bool,
focused: bool,
pen: Option<Pen>,
readout: Readout,
dirty: BTreeSet<usize>,
pending: Option<Instant>,
stats: Arc<Mutex<Stats>>,
watch: Option<Watch>,
external: Option<u64>,
rng: Rng,
spin: bool,
messages: Messages,
measured: BTreeMap<&'static str, String>,
pointer: Option<Pos2>,
jobs: Jobs,
windows: Windows,
palette: Option<PaletteState>,
queued: Vec<Cmd>,
tabs: Vec<bool>,
themed: bool,
key_shift: bool,
held: selection::Held,
sizing: Option<(f32, f32, Pos2)>,
second: [f32; 4],
samples: options::Samples,
swatch_drag: Option<usize>,
renaming: Option<layers::Rename>,
queued_activate: Option<Vec<usize>>,
solo_later: Option<String>,
layer_drag: Option<(layers::LayerRow, layers::Where)>,
canvas_wait: Option<timeline::CanvasWait>,
canvas_gen: u64,
buffering: buffer::BufferState,
custom: Option<BrushDef>,
brush_window: brushwin::BrushWindow,
look: look::LookState,
shapes: make::ShapeTool,
text_tool: text::TextTool,
text_edit: Option<text::Typing>,
picker: text::Picker,
mirror: Option<f32>,
mirror_buffer: StrokeBuffer,
typing: BTreeMap<String, String>,
import_path: String,
palette_path: String,
swatch_picked: Option<usize>,
depth: depth::Parallax,
batch: usize,
pen_path: Option<PenPath>,
pen_fill: bool,
pen_stroke: bool,
pen_width: f32,
thumbs: layers::Thumbs,
between: between::Between,
checks: checks::Checks,
export: export::Form,
pixels: pixels::Form,
tile_size: [u32; 2],
paintover: paintover::Form,
compare: Option<compare::Compared>,
bones: bones::BoneTool,
shifting: Option<shift::Shifting>,
first: first::FirstSteps,
settings_section: prefs::Section,
report_drawing: bool,
#[cfg(test)]
pub(crate) opened: Vec<String>,
soloed: Option<(String, Vec<(String, bool)>)>,
strip_tools: [f32; 2],
strip_foot: [f32; 2],
key_ease: klad_core::keys::Ease,
bindings: crate::commands::Bindings,
capturing: Option<Cmd>,
keys_busy: bool,
key_filter: String,
selection: Option<String>,
group: Vec<String>,
drag: Option<Drag>,
edits: BTreeMap<String, f32>,
texts: BTreeMap<String, String>,
pins: Vec<Note>,
note_at: Option<Vec2>,
note_text: String,
note_open: Option<u32>,
note_edit: String,
history: Option<(u64, Vec<history::Row>)>,
shared: (Option<String>, Vec<String>, u32),
ctx: egui::Context,
sel_box: Option<(String, u64, [Vec2; 4])>,
group_boxes: Vec<[Vec2; 4]>,
preview: Option<PreviewState>,
outbox: Arc<Mutex<Outbox>>,
zoom_px: f32,
zoom_wanted: Option<f32>,
pub(crate) pixel_size: u32,
pub(crate) pixel_perfect: bool,
pub(crate) pixel_shape: PixelShape,
pub(crate) pixel_filled: bool,
pub(crate) pixel_diagonal: bool,
pub(crate) pixel_fill_all: bool,
pub(crate) pixel_box: bool,
pub(crate) pixel_mode: PixelMode,
pub(crate) pixel_dither: u32,
pub(crate) pixel_two: bool,
pixel_live: Option<PixelLive>,
pixel_last: Option<klad_core::pixel::Cell>,
hover_cell: Option<[i32; 2]>,
painted: u64,
real: Option<(RealKey, egui::TextureHandle)>,
picked: Option<Picked>,
also: Vec<String>,
direct: Option<Direct>,
shaped: Option<Shaped>,
point_drag: Option<PointDrag>,
pick_later: bool,
also_shaped: Vec<Shaped>,
path_commit: Option<PathCommit>,
simplify_px: f32,
under: Vec<String>,
cut_lasso: bool,
cut_view: Option<CutView>,
timeline: timeline::Timeline,
frames: FrameCache,
clipboard: Option<copy::Copied>,
}
fn hex_of(c: Color32) -> String {
let [r, g, b, a] = c.to_srgba_unmultiplied();
if a == 255 {
format!("#{r:02x}{g:02x}{b:02x}")
} else {
format!("#{r:02x}{g:02x}{b:02x}{a:02x}")
}
}
fn color_of(hex: &str) -> Option<Color32> {
let [r, g, b, a] = parse_hex(hex).ok()?.map(|v| (v * 255.0).round() as u8);
Some(Color32::from_rgba_unmultiplied(r, g, b, a))
}
impl Editor {
pub(crate) fn open(ctx: egui::Context, path: &Path) -> Result<Self> {
let start = Instant::now();
let scene = Scene::open_lazy(path)?;
let brushes = BrushSet::for_bundle(&scene.bundle)?;
let embedded = scene.bundle.brushes()?;
let tuning = Tuning::of(
brushes
.def("ink")
.ok_or_else(|| crate::report::bug("the ink brush is missing from the library"))?,
);
let settings_path = settings::default_path();
let mut settings = settings_path.as_deref().map(Settings::load).unwrap_or_default();
let offered = settings.offer_real_size(scene.bundle.doc.pixel_art());
let open = format!(
"{} layers, opened in {:.0} ms",
scene.bundle.doc.all_layers().len(),
ms(start)
);
let size = scene.size();
let watch = watch(path, ctx.clone());
let mut messages = Messages::default();
if let Err(e) = &watch {
messages.say(
Tone::Error,
format!("not watching the bundle, so agent edits will not show: {e}"),
Instant::now(),
);
}
let measured = BTreeMap::from([("open", open)]);
let pins = notes::read(&scene.bundle);
let repaint = ctx.clone();
let mut frames = FrameCache::new(Arc::new(move || repaint.request_repaint()));
frames.disk = Some(scene.pictures());
let mut editor = Self {
dirty: scene.all_tiles().into_iter().collect(),
buffer: StrokeBuffer::new(size.0, size.1),
scene,
brushes,
embedded,
live: None,
tool: Tool::Brush,
brush: "ink".into(),
previous_brush: "ink".into(),
tuning,
size: 12.0,
color: [0.08, 0.08, 0.1, 1.0],
hsva: Hsva::from_rgba([0.08, 0.08, 0.1, 1.0], 0.0),
swatch_name: String::new(),
fill: FillTool::default(),
lasso: None,
modifiers: egui::Modifiers::default(),
opacity: 1.0,
flow: 1.0,
settings,
settings_path,
settings_dirty: offered,
update: None,
update_feed: crate::updates::feed(),
update_check: None,
update_said: None,
wants: None,
view: None,
canvas_rect: Rect::NOTHING,
navigating: false,
focused: false,
pen: if cfg!(test) { None } else { Pen::install() },
readout: Readout::default(),
pending: None,
stats: Arc::default(),
watch: watch.ok(),
external: None,
rng: Rng::new(now_ms()),
spin: false,
messages,
measured,
pointer: None,
jobs: Jobs::default(),
windows: Windows::default(),
palette: None,
queued: Vec::new(),
tabs: Vec::new(),
themed: false,
key_shift: false,
held: selection::Held::default(),
sizing: None,
second: [1.0, 1.0, 1.0, 1.0],
samples: options::Samples::default(),
swatch_drag: None,
renaming: None,
queued_activate: None,
solo_later: None,
layer_drag: None,
canvas_wait: None,
canvas_gen: 0,
buffering: buffer::BufferState::default(),
custom: None,
brush_window: brushwin::BrushWindow::default(),
look: look::LookState::default(),
shapes: make::ShapeTool::default(),
text_tool: text::TextTool::default(),
text_edit: None,
picker: text::Picker::default(),
mirror: None,
mirror_buffer: StrokeBuffer::new(size.0, size.1),
typing: BTreeMap::new(),
import_path: String::new(),
palette_path: String::new(),
swatch_picked: None,
depth: depth::Parallax::default(),
batch: timeline::FILL,
pen_path: None,
pen_fill: true,
pen_stroke: true,
pen_width: 3.0,
thumbs: layers::Thumbs::default(),
between: between::Between::default(),
checks: checks::Checks::default(),
export: export::Form::default(),
pixels: pixels::Form::default(),
tile_size: [16, 16],
paintover: paintover::Form::default(),
compare: None,
bones: bones::BoneTool::default(),
shifting: None,
first: first::FirstSteps::default(),
settings_section: prefs::Section::default(),
report_drawing: false,
#[cfg(test)]
opened: Vec::new(),
soloed: None,
strip_tools: [570.0, 480.0],
strip_foot: [186.0, 166.0],
key_ease: klad_core::keys::Ease::Linear,
bindings: crate::commands::Bindings::default(),
capturing: None,
keys_busy: false,
key_filter: String::new(),
selection: None,
group: Vec::new(),
drag: None,
edits: BTreeMap::new(),
texts: BTreeMap::new(),
pins,
note_at: None,
note_text: String::new(),
note_open: None,
note_edit: String::new(),
history: None,
shared: (None, Vec::new(), 0),
ctx,
sel_box: None,
group_boxes: Vec::new(),
preview: None,
outbox: Arc::default(),
zoom_px: 1.0,
zoom_wanted: None,
pixel_size: 1,
pixel_perfect: true,
pixel_shape: PixelShape::Rect,
pixel_filled: false,
pixel_diagonal: false,
pixel_fill_all: false,
pixel_box: true,
pixel_mode: PixelMode::Draw,
pixel_dither: 100,
pixel_two: false,
pixel_live: None,
pixel_last: None,
hover_cell: None,
painted: 0,
real: None,
picked: None,
also: Vec::new(),
direct: None,
shaped: None,
point_drag: None,
pick_later: false,
also_shaped: Vec::new(),
path_commit: None,
simplify_px: 1.5,
under: Vec::new(),
cut_lasso: true,
cut_view: None,
clipboard: None,
timeline: timeline::Timeline::default(),
frames,
};
editor.use_defaults();
editor.request_canvas();
editor.tend_canvas(timeline::OPEN_WAIT)?;
Ok(editor)
}
pub(super) fn use_defaults(&mut self) {
let d = self.settings.defaults.clone();
if let Some(brush) = d.brush.filter(|b| self.brushes.def(b).is_some()) {
self.brush = brush;
}
if let Some(size) = d.size {
self.size = size.clamp(0.5, 500.0);
}
self.timeline.on = d.exposure.clamp(1, 8);
self.scene.onion.before = d.onion_before;
self.scene.onion.after = d.onion_after;
self.scene.onion.opacity = d.onion_opacity.clamp(0.05, 1.0);
self.bindings = crate::commands::Bindings::from_settings(&self.settings.keys);
}
pub(super) fn capture_key(&mut self, ui: &egui::Ui) {
let Some(cmd) = self.capturing else {
return;
};
let pressed = ui.input(|i| {
i.events.iter().find_map(|e| match e {
egui::Event::Key {
key,
pressed: true,
modifiers,
..
} => Some((*key, *modifiers)),
_ => None,
})
});
let Some((key, modifiers)) = pressed else {
return;
};
ui.ctx().input_mut(|i| i.consume_key(modifiers, key));
self.capturing = None;
if key == egui::Key::Escape {
self.say(Tone::Info, "the key stays as it was");
return;
}
let keys = crate::commands::Keys::pressed(key, modifiers);
match self.bindings.bind(cmd, keys) {
Ok(()) => {
self.settings.keys = self.bindings.to_settings();
self.settings_dirty = true;
self.say(Tone::Done, format!("{} is now {}", cmd.spec().name, keys.label()));
}
Err(why) => self.say(Tone::Refused, why),
}
}
fn canvas_size(&self) -> Vec2 {
let (w, h) = self.scene.size();
vec2(w as f32, h as f32)
}
pub(crate) fn say(&mut self, tone: Tone, text: impl Into<String>) {
let text = text.into();
if tone == Tone::Error {
crate::report::log(&format!("editor: {text}"));
}
self.messages.say(tone, text, Instant::now());
self.ctx.request_repaint();
}
pub(crate) fn error(&mut self, e: impl std::fmt::Display) {
self.say(Tone::Error, format!("{e:#}"));
}
pub(crate) fn failed(&mut self, e: anyhow::Error) {
match crate::report::is_bug(&e) {
true => self.say(Tone::Error, crate::report::bug_message(&e)),
false => self.error(e),
}
}
fn measure(&mut self, key: &'static str, text: String) {
self.measured.insert(key, text);
}
fn share_selection(&mut self) {
let items: Vec<String> = self
.shapes()
.iter()
.chain(self.direct.as_ref().map(|d| &d.node))
.cloned()
.chain(self.picked.iter().flat_map(Picked::addresses))
.collect();
let now = (self.scene.active_id(), items, self.scene.frame);
if now != self.shared {
let nodes = now.1.clone();
if let Err(e) = notes::write_selection(&self.scene.bundle, now.0.clone(), nodes, self.scene.frame) {
self.failed(e.context("the selection could not be shared with the agent"));
}
self.shared = now;
}
}
fn sync(&mut self) -> Result<()> {
if let Some(first) = self.watch.as_ref().and_then(|w| w.events.try_iter().min()) {
self.external.get_or_insert(first);
self.pins = notes::read(&self.scene.bundle);
}
let committing = self.path_commit.is_some();
if self.live.is_some()
|| self.drag.is_some()
|| self.point_drag.is_some()
|| committing
|| self.external.is_none()
{
return Ok(());
}
if !self.scene.bundle.changed_on_disk() {
self.external = None;
return Ok(());
}
self.reload()
}
fn reload(&mut self) -> Result<()> {
let seen = self.external.take();
self.forget_typing_preview();
self.checks.gaps = None;
self.checks.arcs = None;
let start = Instant::now();
self.brushes.refresh(&self.scene.bundle)?;
self.embedded = self.scene.bundle.brushes()?;
let dirty = self.scene.reload(&self.brushes)?;
let (w, h) = self.scene.size();
if (self.buffer.grid().width, self.buffer.grid().height) != (w, h) {
self.buffer = StrokeBuffer::new(w, h);
self.mirror_buffer = StrokeBuffer::new(w, h);
self.view = None;
}
let tiles = dirty.len();
self.dirty.extend(dirty);
self.forget_missing_selection();
let took = ms(start);
let text = match self.scene.bundle.read_stamp() {
Some(s) => format!(
"rev {} by {}\nfile event after {} ms\n{tiles} tiles refreshed after {} ms ({took:.0} ms to reload)",
s.rev,
s.author,
seen.map_or(-1, |t| t as i64 - s.at_ms as i64),
now_ms() as i64 - s.at_ms as i64
),
None => format!("{tiles} tiles refreshed in {took:.0} ms"),
};
self.measure("sync", text);
Ok(())
}
pub(super) fn shapes(&self) -> Vec<String> {
match &self.selection {
Some(id) if self.group.len() > 1 && self.group.contains(id) => self.group.clone(),
Some(id) => vec![id.clone()],
None => Vec::new(),
}
}
pub(super) fn select_shapes(&mut self, ids: Vec<String>) {
self.selection = ids.last().cloned();
self.group = if ids.len() > 1 { ids } else { Vec::new() };
self.refresh_box();
}
fn forget_missing_selection(&mut self) {
let doc = &self.scene.bundle.doc;
self.group.retain(|id| matches!(doc.item(id), Some(Item::Node(..))));
if self.group.len() < 2 || !self.selection.as_ref().is_some_and(|id| self.group.contains(id)) {
self.group.clear();
}
if self
.selection
.as_ref()
.is_some_and(|id| !matches!(doc.item(id), Some(Item::Node(..))))
{
self.selection = None;
}
let gone = |id: &str| match markedit::parse_address(id) {
Some((cel, mark)) => {
self.scene.active_cel().as_deref() != Some(cel)
|| !self.scene.active_marks().iter().any(|m| m.id() == mark)
}
None => !matches!(doc.item(id), Some(Item::Node(..))),
};
if self.direct.as_ref().is_some_and(|d| gone(&d.node)) {
self.direct = None;
}
let active = self.scene.active_cel();
let active_id = self.scene.active_id();
let present: BTreeSet<u32> = self.scene.active_marks().iter().map(Mark::id).collect();
let frame = self.scene.frame;
let scene = &self.scene;
let shown = |layer: &str| {
scene
.bundle
.doc
.layer(layer)
.and_then(|l| l.content_at(frame))
.map(|c| c.id.clone())
};
self.picked = self.picked.take().and_then(|mut p| {
p.ids.retain(|id| present.contains(id));
let cut = p.cut.is_some();
p.more.retain_mut(|part| {
if shown(&part.layer).as_deref() != Some(part.cel.as_str()) {
return false;
}
let have: BTreeSet<u32> = scene.marks_of(&part.cel).iter().map(Mark::id).collect();
part.ids.retain(|id| have.contains(id));
!part.ids.is_empty() || cut
});
(Some(&p.cel) == active.as_ref() && (!p.ids.is_empty() || cut || !p.more.is_empty())).then_some(p)
});
self.also.retain(|id| {
Some(id) != active_id.as_ref() && scene.bundle.doc.layer(id).is_some_and(|l| l.kind() == Kind::Paint)
});
}
fn apply(&mut self, ops: Vec<Op>) -> Result<()> {
let dirty = self.commit(ops)?;
self.dirty.extend(dirty);
Ok(())
}
fn commit(&mut self, ops: Vec<Op>) -> Result<Vec<usize>> {
self.checks.gaps = None;
self.checks.arcs = None;
if ops.is_empty() {
return Ok(Vec::new());
}
self.end_look_preview()?;
self.end_typing_preview()?;
let start = Instant::now();
let dirty = self.scene.apply(&ops, &self.brushes)?;
self.measure(
"edit",
format!("edit applied, {} tiles refreshed in {:.0} ms", dirty.len(), ms(start)),
);
self.forget_missing_selection();
Ok(dirty)
}
fn set(&mut self, id: &str, props: Vec<(String, Value)>) -> Result<()> {
if props.is_empty() {
return Ok(());
}
self.apply(vec![Op::Set {
id: id.to_string(),
props: props.into_iter().collect::<Map<String, Value>>(),
}])
}
fn step(&mut self, stack: Stack) -> Result<()> {
if self.live.is_some() || self.drag.is_some() || self.point_drag.is_some() || self.path_commit.is_some() {
return Ok(());
}
let start = Instant::now();
let word = if stack == Stack::Undo { "undid" } else { "redid" };
match self.scene.step(stack, &self.brushes)? {
Some((summary, dirty)) => {
self.measure("undo", format!("{word} {summary} in {:.0} ms", ms(start)));
self.say(Tone::Info, format!("{word} {}", self.plain(&summary)));
self.dirty.extend(dirty);
self.forget_missing_selection();
}
None => self.say(
Tone::Refused,
format!("nothing to {}", if stack == Stack::Undo { "undo" } else { "redo" }),
),
}
Ok(())
}
pub(super) fn plain(&self, text: &str) -> String {
let doc = &self.scene.bundle.doc;
let drawing = |cel: &str| match doc.locate(cel) {
Some(Loc::Cel(path, c)) => Some(format!(
"the drawing at frame {} on {}",
doc.layer_at(&path).cels()[c].frame,
doc.layer_at(&path).name
)),
_ => None,
};
let word = |w: &str| -> Option<String> {
if let Some((cel, id)) = klad_core::markedit::parse_address(w) {
return Some(drawing(cel).map_or(format!("mark {id}"), |d| format!("mark {id} of {d}")));
}
let digits = w.len() > 1 && w[1..].chars().all(|c| c.is_ascii_digit());
match w.chars().next() {
Some('c') if digits => drawing(w),
Some('l') if digits => doc.layer(w).map(|l| l.name.clone()),
Some('n') if digits => match doc.item(w) {
Some(Item::Node(_, _, node)) => Some(format!("a {}", node.type_name())),
_ => None,
},
_ => None,
}
};
text.split(' ')
.map(|w| {
let bare = w.trim_end_matches([',', ')', ':', '.', ';']);
let lead = bare.trim_start_matches('(');
let (head, tail) = (&bare[..bare.len() - lead.len()], &w[bare.len()..]);
word(lead).map_or(w.to_string(), |p| format!("{head}{p}{tail}"))
})
.collect::<Vec<_>>()
.join(" ")
}
fn refresh_box(&mut self) {
let rev = self.scene.bundle.doc.rev;
let ids = self.shapes();
if ids.is_empty() {
self.sel_box = None;
self.group_boxes.clear();
return;
}
let key = ids.join(" ");
if self.sel_box.as_ref().is_some_and(|(s, r, _)| *s == key && *r == rev) {
return;
}
let boxes: Vec<[f32; 4]> = ids
.iter()
.filter_map(|id| overlay::node_world_box(&self.scene.bundle.doc, id).ok().flatten())
.collect();
let corners = |[x, y, w, h]: [f32; 4]| [vec2(x, y), vec2(x + w, y), vec2(x + w, y + h), vec2(x, y + h)];
self.group_boxes = match boxes.len() {
0 | 1 => Vec::new(),
_ => boxes.iter().map(|b| corners(*b)).collect(),
};
self.sel_box = boxes
.iter()
.copied()
.reduce(|a, b| {
let (x, y) = (a[0].min(b[0]), a[1].min(b[1]));
[
x,
y,
(a[0] + a[2]).max(b[0] + b[2]) - x,
(a[1] + a[3]).max(b[1] + b[3]) - y,
]
})
.map(|all| (key, rev, corners(all)));
}
fn selection_corners(&self) -> Option<(String, [Vec2; 4])> {
let (key, _, corners) = self.sel_box.as_ref()?;
let id = self.selection.clone()?;
(self.shapes().join(" ") == *key).then_some((id, *corners))
}
fn refresh_cut(&mut self) {
let rev = self.scene.bundle.doc.rev;
let Some((key, cel, polygon, ids, more)) = self.picked.as_ref().and_then(|p| {
p.cut
.clone()
.map(|polygon| (p.key(), p.cel.clone(), polygon, p.ids.clone(), p.more.clone()))
}) else {
self.cut_view = None;
return;
};
if self.cut_view.as_ref().is_some_and(|v| v.key == key && v.rev == rev) {
return;
}
let doc = &self.scene.bundle.doc;
let split = |cel: &str, source: &[Mark], ids: Vec<u32>| {
let mut marks = source.to_vec();
let lassoed = markedit::split(&mut marks, &polygon, true, doc.mark_ids(cel));
let chosen: Vec<u32> = lassoed
.iter()
.copied()
.chain(ids.into_iter().filter(|id| !lassoed.contains(id)))
.collect();
(marks, lassoed, chosen)
};
let (marks, lassoed, chosen) = split(&cel, self.scene.active_marks(), ids);
let more = more
.into_iter()
.map(|p| {
let (marks, lassoed, chosen) = split(&p.cel, self.scene.marks_of(&p.cel), p.ids);
PartView {
layer: p.layer,
cel: p.cel,
marks,
lassoed,
chosen,
}
})
.collect();
self.cut_view = Some(CutView {
key,
rev,
marks,
lassoed,
chosen,
more,
});
}
fn picked_parts(&self) -> Vec<PartMarks<'_>> {
let Some(picked) = self.picked.as_ref() else {
return Vec::new();
};
let view = self
.cut_view
.as_ref()
.filter(|v| picked.cut.is_some() && v.key == picked.key());
if picked.cut.is_some() && view.is_none() {
return Vec::new();
}
let active = self.scene.active_id().unwrap_or_default();
let first: PartMarks = match view {
Some(v) => (active, picked.cel.clone(), &v.marks[..], &v.chosen[..]),
None => (active, picked.cel.clone(), self.scene.active_marks(), &picked.ids[..]),
};
std::iter::once(first)
.chain(
picked
.more
.iter()
.enumerate()
.map(|(k, p)| match view.and_then(|v| v.more.get(k)) {
Some(pv) => (p.layer.clone(), p.cel.clone(), &pv.marks[..], &pv.chosen[..]),
None => (p.layer.clone(), p.cel.clone(), self.scene.marks_of(&p.cel), &p.ids[..]),
}),
)
.collect()
}
fn picked_corners(&self) -> Option<(String, [Vec2; 4])> {
let picked = self.picked.as_ref()?;
let area = picked.cut.as_ref().filter(|_| self.scene.on_grid()).map(|polygon| {
polygon.iter().fold([f32::MAX, f32::MAX, f32::MIN, f32::MIN], |b, p| {
[b[0].min(p[0]), b[1].min(p[1]), b[2].max(p[0]), b[3].max(p[1])]
})
});
let [x0, y0, x1, y1] = self
.picked_parts()
.iter()
.map(|(_, _, marks, ids)| markedit::bounds_of(marks, ids))
.chain(std::iter::once(area))
.fold(None, union_box)?;
Some((picked.key(), [vec2(x0, y0), vec2(x1, y0), vec2(x1, y1), vec2(x0, y1)]))
}
fn across(&self, action: LassoAction) -> LassoAction {
let spans = self.picked.as_ref().is_some_and(|p| !p.more.is_empty());
match action {
LassoAction::Transform(t) if spans && t.pivot.is_none() => {
let pivot = self
.picked_corners()
.map(|(_, c)| [(c[0].x + c[2].x) / 2.0, (c[0].y + c[2].y) / 2.0]);
LassoAction::Transform(MarkTransform { pivot, ..t })
}
other => other,
}
}
fn picked_ops(&self, action: LassoAction) -> Option<(Vec<Op>, Option<Picked>)> {
let picked = self.picked.clone()?;
let action = self.across(action);
let Some(polygon) = picked.cut.clone() else {
return Some(match action {
LassoAction::Transform(transform) => (
vec![Op::Transform {
ids: picked.addresses(),
transform,
}],
Some(picked),
),
LassoAction::Remove => (
vec![Op::Remove {
ids: picked.addresses(),
}],
None,
),
});
};
let view = self.cut_view.as_ref().filter(|v| v.key == picked.key())?;
let layer = self.scene.active_id()?;
let frame = self.scene.frame;
let views: Vec<(String, &str, &[u32], &[u32])> =
std::iter::once((layer, picked.cel.as_str(), &view.lassoed[..], &view.chosen[..]))
.chain(
view.more
.iter()
.map(|v| (v.layer.clone(), v.cel.as_str(), &v.lassoed[..], &v.chosen[..])),
)
.collect();
let lassos: Vec<Op> = views
.iter()
.filter(|(_, _, lassoed, _)| !lassoed.is_empty())
.map(|(layer, ..)| {
Op::Lasso(LassoSpec {
layer: layer.clone(),
frame,
polygon: polygon.clone(),
cut: true,
action: action.clone(),
})
})
.collect();
let extras: Vec<String> = views
.iter()
.flat_map(|(_, cel, lassoed, chosen)| {
chosen
.iter()
.filter(|id| !lassoed.contains(id))
.map(|id| address(cel, *id))
})
.collect();
let rest = (!extras.is_empty()).then_some(match &action {
LassoAction::Transform(transform) => Op::Transform {
ids: extras,
transform: *transform,
},
LassoAction::Remove => Op::Remove { ids: extras },
});
let after = match action {
LassoAction::Remove => None,
LassoAction::Transform(_) => Some(Picked {
cel: picked.cel.clone(),
ids: view.chosen.clone(),
cut: None,
more: view
.more
.iter()
.map(|v| Part {
layer: v.layer.clone(),
cel: v.cel.clone(),
ids: v.chosen.clone(),
})
.collect(),
}),
};
Some((lassos.into_iter().chain(rest).collect(), after))
}
fn edit_picked(&mut self, action: LassoAction) -> Result<()> {
let Some((ops, after)) = self.picked_ops(action) else {
return Ok(());
};
self.apply(ops)?;
self.picked = after;
self.forget_missing_selection();
Ok(())
}
fn on_marks(&self) -> bool {
match self.tool {
Tool::Strokes => true,
Tool::Select => self.selection.is_none() && self.picked.is_some(),
_ => false,
}
}
fn handles(&self) -> Option<(String, [Vec2; 4])> {
if let Some(found) = self.shift_handles() {
return Some(found);
}
match self.tool {
Tool::Direct => None,
_ if self.on_marks() => self.picked_corners(),
_ => self.selection_corners(),
}
}
fn node_ops(&self, drag: &Drag) -> Result<Option<Vec<Op>>> {
let ids = match self.shapes() {
all if all.len() > 1 && all.contains(&drag.node) => all,
_ => vec![drag.node.clone()],
};
let together = ids.len() > 1;
let affine = drag.affine();
let ops = ids
.into_iter()
.filter_map(|id| match self.scene.bundle.doc.item(&id) {
Some(Item::Node(_, _, node)) => Some((id, node.clone())),
_ => None,
})
.map(|(id, node)| {
let t = match drag.stretch().filter(|_| !together) {
Some((axis, _, k)) => lift::stretched(&node, affine, axis, k)?,
None => lift::committed(&node, affine, drag.scale(), drag.angle().to_degrees())?,
};
Ok(Op::Set {
id,
props: transform_props(&t),
})
})
.collect::<Result<Vec<Op>>>()?;
Ok((!ops.is_empty()).then_some(ops))
}
fn drag_ops(&self) -> Option<Vec<Op>> {
let drag = self.drag.as_ref().filter(|d| d.moved() && !d.copy)?;
if self.shifting.is_some() {
return self.shift_ops(drag, false).ok().flatten();
}
match drag.strokes {
true => self
.picked_ops(LassoAction::Transform(drag.mark_transform()))
.map(|(ops, _)| ops),
false => self.node_ops(drag).ok().flatten(),
}
}
fn preview_cels(&self) -> Vec<String> {
if self.shifting.is_some() {
return self.shift_cels();
}
match self.drag.as_ref().is_some_and(|d| d.strokes) {
true => self
.picked
.iter()
.flat_map(|p| std::iter::once(p.cel.clone()).chain(p.more.iter().map(|m| m.cel.clone())))
.collect(),
false => Vec::new(),
}
}
fn drop_preview(&mut self) {
if let Some(mut state) = self.preview.take() {
self.dirty.extend(state.release());
}
}
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 = 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 {
ops,
rev: self.scene.bundle.doc.rev,
dirty: dirty.into_iter().collect(),
since: Instant::now(),
});
self.preview = Some(state);
}
}
}
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;
let posing = self.live_pose();
if let Some(mut state) = self.preview.take() {
let mut keep = true;
match state.job.as_ref().and_then(|rx| rx.try_recv().ok()) {
Some(Ok(done)) => {
state.job = None;
let composed: BTreeSet<usize> = done.tiles.iter().map(|(i, _)| *i).collect();
let earlier = std::mem::replace(
&mut state.shown,
done.changed.intersection(&composed).copied().collect(),
);
state.shown.extend(earlier.difference(&composed));
let current = state.finish.as_ref().map_or(state.snap.rev, |f| f.rev) == rev;
let last = state.finish.as_ref().is_some_and(|f| f.ops == done.ops);
if current {
uploads = done.tiles;
}
if !current {
keep = false;
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(),
};
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.release());
self.failed(e.context("the moved picture could not be drawn"));
}
None => {}
}
if keep {
let gone = match &state.posed {
Some(_) => posing.is_none(),
None => self.drag.is_none(),
};
let stale = state.finish.is_none() && (gone || 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()
&& (posing.is_some() || self.drag.as_ref().is_some_and(|d| d.moved() && !d.copy))
&& self.canvas_current()
&& self.dirty.len() <= timeline::FILL
{
let cels = match &posing {
Some(p) => p.cels.to_vec(),
None => self.preview_cels(),
};
self.preview = self
.scene
.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,
posed: 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, &posing) {
(Some(Ok(finish)), _) => Some(finish),
(Some(Err(_)), Some(p)) => match self.preview.as_ref().is_some_and(|s| s.posed.as_ref() == Some(&p.key)) {
true => None,
false => Some(p.ops.to_vec()),
},
(Some(Err(true)), None) => self.drag_ops(),
_ => None,
};
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);
state.posed = posing.as_ref().map(|p| p.key.clone());
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)
}
fn screen(&self, view: View, rect: Rect, c: Vec2) -> Pos2 {
rect.min + view.to_screen(c, rect.size())
}
fn visible_tiles(&self, view: View, rect: Rect) -> BTreeSet<usize> {
if self.scene.bundle.doc.canvas.wrap {
return self.scene.all_tiles().into_iter().collect();
}
let size = rect.size();
let corners = [vec2(0.0, 0.0), vec2(size.x, 0.0), vec2(0.0, size.y), size].map(|p| view.to_canvas(p, size));
let range = |lo: f32, hi: f32, count: usize| {
let at = |v: f32| ((v / klad_brush::TILE as f32).floor() as i64).clamp(0, count as i64 - 1) as usize;
at(lo).saturating_sub(1)..=(at(hi) + 1).min(count - 1)
};
let (xs, ys) = (corners.map(|c| c.x), corners.map(|c| c.y));
let low = |v: [f32; 4]| v.into_iter().fold(f32::MAX, f32::min);
let high = |v: [f32; 4]| v.into_iter().fold(f32::MIN, f32::max);
let cols = self.scene.cols();
range(low(ys), high(ys), self.scene.rows())
.flat_map(|ty| range(low(xs), high(xs), cols).map(move |tx| ty * cols + tx))
.collect()
}
fn edges(&self) -> bool {
match self.tool {
_ if self.on_marks() => true,
Tool::Select if self.group.len() > 1 => false,
Tool::Select => self
.selection
.as_ref()
.and_then(|id| match self.scene.bundle.doc.item(id) {
Some(Item::Node(_, _, node)) => Some(lift::square(node)),
_ => None,
})
.unwrap_or(false),
_ => false,
}
}
fn grab_at(&self, view: View, rect: Rect, pos: Pos2) -> Option<(String, Grab, [Vec2; 4])> {
let (id, corners) = self.handles()?;
let screen = corners.map(|c| self.screen(view, rect, c));
grab(screen, pos, self.edges()).map(|g| (id, g, corners))
}
fn start_drag(&mut self, id: String, grab: Grab, corners: [Vec2; 4], at: Vec2, fresh: bool) {
self.drop_preview();
let strokes = self.on_marks() && self.shifting.is_none();
if !strokes && self.shifting.is_none() && !matches!(self.scene.bundle.doc.item(&id), Some(Item::Node(..))) {
return;
}
let whole = strokes && self.scene.on_grid();
let center = corners.iter().fold(Vec2::ZERO, |a, c| a + *c) / 4.0;
let center = match whole {
true => vec2(center.x.round(), center.y.round()),
false => center,
};
self.drag = Some(Drag {
grab,
node: id,
strokes,
whole,
fresh,
copy: grab == Grab::Move && self.modifiers.alt,
start: at,
now: at,
center,
corners,
slop: DRAG_SLOP / self.view.map_or(1.0, |v| v.zoom),
crossed: false,
});
}
fn erased(&self) -> impl Fn(&[Mark], &Mark) -> bool + Copy + '_ {
move |marks: &[Mark], m: &Mark| {
let eraser = m.as_stroke().is_some_and(|s| {
self.brushes
.get(&s.brush)
.is_ok_and(|b| b.blend == klad_brush::brush::StrokeBlend::Erase)
});
eraser || !self.wiped(marks, &[m.id()]).is_empty()
}
}
fn wiped(&self, marks: &[Mark], among: &[u32]) -> BTreeSet<u32> {
let attached = klad_core::stroke::strokes_of(marks).any(|s| s.on.iter().any(|t| among.contains(t)));
match attached {
false => BTreeSet::new(),
true => {
let (w, h) = self.scene.size();
klad_brush::scope::hidden(w, h, marks, &self.brushes, Some(among))
}
}
}
fn layer_rank(&self, id: &str) -> Option<usize> {
self.scene.bundle.doc.all_layers().iter().position(|l| l.id == id)
}
fn shape_hits(&self, at: Vec2) -> Result<Vec<(String, String)>> {
let active = self.scene.active_id();
Ok(overlay::hits(&self.scene.bundle.doc, self.scene.frame, (at.x, at.y))?
.into_iter()
.filter(|(_, layer)| self.settings.pick_all_layers || active.as_deref() == Some(layer.as_str()))
.collect())
}
pub(super) fn mark_at(&self, at: Vec2, slack: f32) -> Option<(Vec<usize>, u32)> {
self.scene
.marks_at((at.x, at.y), slack, self.settings.pick_all_layers, self.erased())
}
fn select_at(&mut self, at: Vec2, cycle: bool) -> Result<()> {
let hits = self.shape_hits(at)?;
let current = self
.selection
.as_ref()
.and_then(|id| hits.iter().position(|(n, _)| n == id));
let next = match (current, cycle) {
(Some(i), true) => hits.get((i + 1) % hits.len().max(1)),
_ => hits.first(),
};
self.selection = next.map(|(n, _)| n.clone());
self.group.clear();
self.refresh_box();
Ok(())
}
fn toggle_shape(&mut self, at: Vec2) -> Result<bool> {
let Some((hit, _)) = self.shape_hits(at)?.into_iter().next() else {
return Ok(false);
};
let held = self.shapes();
let next: Vec<String> = match held.contains(&hit) {
true => held.into_iter().filter(|id| *id != hit).collect(),
false => held.into_iter().chain([hit]).collect(),
};
self.picked = None;
self.select_shapes(next);
Ok(true)
}
fn lasso_shapes(&mut self) -> Result<bool> {
let vector = self
.scene
.active_layer()
.is_some_and(|l| l.kind() == klad_core::doc::Kind::Vector);
let Some(polygon) = self
.lasso
.as_ref()
.filter(|l| vector && l.far && l.points.len() >= 3)
.map(|l| l.points.iter().map(|p| [p.x, p.y]).collect::<Vec<_>>())
else {
return Ok(false);
};
let active = self.scene.active_id();
let found: Vec<String> = overlay::shapes_inside(&self.scene.bundle.doc, self.scene.frame, &polygon)?
.into_iter()
.filter(|(_, layer)| self.settings.pick_all_layers || active.as_deref() == Some(layer.as_str()))
.map(|(node, _)| node)
.collect();
self.lasso = None;
self.picked = None;
self.select_shapes(found);
Ok(true)
}
fn finish_drag(&mut self) -> Result<()> {
let Some(drag) = self.drag.take() else {
return Ok(());
};
if self.shifting.is_some() {
return self.finish_shift_drag(&drag);
}
if drag.strokes {
return self.finish_stroke_drag(&drag);
}
if !drag.moved() {
if drag.grab == Grab::Move && !drag.fresh {
self.select_at(drag.start, true)?;
}
return Ok(());
}
let Some(ops) = self.node_ops(&drag)? else {
self.drop_preview();
return Ok(());
};
let before = self.scene.bundle.doc.rev;
let dirty = self.commit(ops.clone())?;
self.finish_preview(ops, dirty, before);
Ok(())
}
fn grab_under(&mut self, c: Vec2, pos: Pos2) -> Result<()> {
let zoom = self.view.map_or(1.0, |v| v.zoom);
let slack = 5.0 / zoom;
let on_picked = self.picked.as_ref().is_some_and(|p| !p.more.is_empty())
&& self
.picked_parts()
.iter()
.any(|(_, _, marks, ids)| markedit::hit(marks, (c.x, c.y), slack).is_some_and(|id| ids.contains(&id)));
if on_picked && let Some((key, corners)) = self.picked_corners() {
self.selection = None;
self.start_drag(key, Grab::Move, corners, c, true);
return Ok(());
}
let stroke = self.mark_at(c, slack);
let shape = self
.shape_hits(c)?
.first()
.and_then(|(_, layer)| self.layer_rank(layer));
let stroke_first = match (&stroke, shape) {
(Some((path, _)), Some(shape)) => self
.scene
.bundle
.doc
.locate_path(path)
.and_then(|l| self.layer_rank(&l.id))
.is_some_and(|rank| rank > shape),
(_, None) => true,
(None, Some(_)) => false,
};
if !stroke_first && self.modifiers.shift && self.selection.is_some() && self.toggle_shape(c)? {
return Ok(());
}
if !stroke_first {
self.select_at(c, false)?;
if let Some((id, corners)) = self.selection_corners() {
self.picked = None;
self.start_drag(id, Grab::Move, corners, c, true);
return Ok(());
}
}
self.selection = None;
let Some((path, id)) = stroke else {
self.lasso = Some(Lasso {
points: vec![c],
start: pos,
far: false,
});
return Ok(());
};
if path != self.scene.active {
self.activate(path)?;
let name = self.scene.active_layer().map(|l| l.name.clone()).unwrap_or_default();
self.say(Tone::Info, format!("on layer {name}"));
if !self.ensure_canvas()? {
self.say(Tone::Info, format!("{name} is still loading; press again in a moment"));
return Ok(());
}
}
let Some(cel) = self.scene.active_cel() else {
return Ok(());
};
let held: Vec<u32> = self
.picked
.as_ref()
.filter(|p| p.cel == cel && p.cut.is_none())
.map_or(Vec::new(), |p| p.ids.clone());
let ids = match (self.modifiers.shift, held.contains(&id)) {
(true, true) => held.into_iter().filter(|x| *x != id).collect(),
(true, false) => held.into_iter().chain([id]).collect(),
(false, true) => held,
(false, false) => vec![id],
};
self.picked = (!ids.is_empty()).then(|| Picked::whole(cel, ids));
if let Some((key, corners)) = self.picked_corners() {
self.start_drag(key, Grab::Move, corners, c, true);
}
Ok(())
}
fn copy_for_drag(&mut self) -> Result<()> {
let Some(drag) = self.drag.as_mut().filter(|d| d.copy && d.moved()) else {
return Ok(());
};
drag.copy = false;
let strokes = drag.strokes;
self.drop_preview();
self.duplicate_in_place()?;
if !strokes && let (Some(drag), Some(id)) = (self.drag.as_mut(), self.selection.clone()) {
drag.node = id;
}
Ok(())
}
fn finish_stroke_drag(&mut self, drag: &Drag) -> Result<()> {
let Some(picked) = self.picked.clone() else {
return Ok(());
};
if !drag.moved() && drag.fresh {
return Ok(());
}
if !drag.moved() {
self.lasso = Some(Lasso {
points: vec![drag.start],
start: Pos2::ZERO,
far: false,
});
return self.finish_pick();
}
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, before);
}
None => self.drop_preview(),
}
let text = format!(
"{} strokes and fills {} and redrawn in {:.0} ms",
self.picked.as_ref().map_or(0, Picked::count),
if picked.cut.is_some() { "cut, moved" } else { "moved" },
ms(start)
);
self.measure("strokes", text);
Ok(())
}
fn also_cels(&self) -> Vec<(String, String)> {
self.pick_cels(false)
}
fn pick_cels(&self, every: bool) -> Vec<(String, String)> {
let doc = &self.scene.bundle.doc;
let active = self.scene.active_id();
let layers: Vec<&klad_core::doc::Layer> = match every {
true => doc.all_layers(),
false => self.also.iter().filter_map(|id| doc.layer(id)).collect(),
};
layers
.into_iter()
.filter(|l| l.kind() == Kind::Paint && l.visible && !l.locked)
.filter(|l| !every || active.as_deref() != Some(l.id.as_str()))
.filter_map(|l| l.content_at(self.scene.frame).map(|c| (l.id.clone(), c.id.clone())))
.collect()
}
fn lasso_outline(&self, lasso: &Lasso) -> Vec<Vec2> {
let boxed = self.pixel_box && self.scene.on_grid() && matches!(self.tool, Tool::Strokes | Tool::Select);
match (boxed, lasso.points.first(), lasso.points.last()) {
(true, Some(a), Some(b)) => {
let (x0, y0) = (a.x.min(b.x).floor(), a.y.min(b.y).floor());
let (x1, y1) = (a.x.max(b.x).ceil(), a.y.max(b.y).ceil());
vec![vec2(x0, y0), vec2(x1, y0), vec2(x1, y1), vec2(x0, y1)]
}
_ => lasso.points.clone(),
}
}
fn finish_pick(&mut self) -> Result<()> {
let Some(lasso) = self.lasso.take() else {
return Ok(());
};
let zoom = self.view.map_or(1.0, |v| v.zoom);
let click = !lasso.far || lasso.points.len() < 3;
if click
&& !self.modifiers.shift
&& let Some((path, _)) = self.mark_at(lasso.points[0], 5.0 / zoom)
&& path != self.scene.active
{
self.activate(path)?;
}
let every = !click && self.settings.pick_all_layers;
if every
&& self.scene.active_cel().is_none()
&& let Some((layer, _)) = self.pick_cels(true).into_iter().next()
&& let Some(klad_core::doc::Loc::Layer(path)) = self.scene.bundle.doc.locate(&layer)
{
self.activate(path)?;
}
let Some(cel) = self.scene.active_cel() else {
self.say(Tone::Refused, "make a paint layer active to select its strokes");
return Ok(());
};
let at = lasso.points[0];
let erased = self.erased();
let polygon: Option<Vec<[f32; 2]>> = (lasso.far && lasso.points.len() >= 3)
.then(|| self.lasso_outline(&lasso).iter().map(|p| [p.x, p.y]).collect());
let pick = |marks: &[Mark]| -> (Vec<u32>, bool) {
match &polygon {
Some(polygon) => {
let sides = markedit::sides(marks, polygon);
let crossing = sides.iter().any(|(_, side)| *side == markedit::Side::Crossing);
let mut inside: Vec<u32> = sides
.into_iter()
.filter(|(_, side)| *side == markedit::Side::Inside)
.map(|(id, _)| id)
.collect();
let wiped = self.wiped(marks, &inside);
inside.retain(|id| !wiped.contains(id));
(inside, crossing)
}
None => (
markedit::pick(marks, (at.x, at.y), 5.0 / zoom, |m| erased(marks, m))
.into_iter()
.collect(),
false,
),
}
};
let (found, crossing) = pick(self.scene.active_marks());
let others: Vec<(String, String, Vec<u32>, bool)> = self
.pick_cels(every)
.into_iter()
.map(|(layer, cel)| {
let (ids, crossing) = pick(self.scene.marks_of(&cel));
(layer, cel, ids, crossing)
})
.collect();
let adding = self.modifiers.shift;
let previous = self.picked.clone().filter(|p| adding && p.cel == cel);
let crossed = crossing || others.iter().any(|o| o.3);
let cut = polygon
.clone()
.filter(|_| self.cut_lasso && crossed)
.or_else(|| previous.as_ref().and_then(|p| p.cut.clone()));
let merge = |held: Vec<u32>, found: &[u32]| {
found.iter().fold(held, |mut ids, id| {
if adding && !lasso.far && ids.contains(id) {
ids.retain(|x| x != id);
} else if !ids.contains(id) {
ids.push(*id);
}
ids
})
};
let ids = merge(previous.as_ref().map_or(Vec::new(), |p| p.ids.clone()), &found);
let more: Vec<Part> = others
.into_iter()
.filter_map(|(layer, cel, found, crossing)| {
let held = previous
.as_ref()
.and_then(|p| p.more.iter().find(|q| q.cel == cel))
.map_or(Vec::new(), |q| q.ids.clone());
let ids = merge(held, &found);
(!ids.is_empty() || (cut.is_some() && crossing)).then_some(Part { layer, cel, ids })
})
.collect();
self.picked = (!ids.is_empty() || cut.is_some() || !more.is_empty()).then_some(Picked { cel, ids, cut, more });
Ok(())
}
fn shape_of(&self, id: &str) -> Option<Shaped> {
let rev = self.scene.bundle.doc.rev;
if let Some(subs) = self.stroke_path(id) {
return Some(Shaped {
node: id.to_string(),
rev,
subs,
matrix: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0],
});
}
let doc = &self.scene.bundle.doc;
match doc.item(id) {
Some(Item::Node(_, _, node)) => pathedit::from_shape(&node.shape)
.ok()
.zip(overlay::local_to_canvas(doc, id).ok().flatten())
.map(|(subs, matrix)| Shaped {
node: id.to_string(),
rev,
subs,
matrix,
}),
_ => None,
}
}
fn refresh_shape(&mut self) {
let rev = self.scene.bundle.doc.rev;
let Some(direct) = self.direct.as_ref() else {
self.shaped = None;
self.also_shaped.clear();
return;
};
let (id, also): (String, Vec<String>) = (direct.node.clone(), direct.also.keys().cloned().collect());
if !self.shaped.as_ref().is_some_and(|s| s.node == id && s.rev == rev) {
self.shaped = self.shape_of(&id);
}
let kept = std::mem::take(&mut self.also_shaped);
self.also_shaped = also
.iter()
.filter_map(|id| {
kept.iter()
.find(|s| s.node == *id && s.rev == rev)
.cloned()
.or_else(|| self.shape_of(id))
})
.collect();
let alive: Vec<&String> = self.also_shaped.iter().map(|s| &s.node).collect();
if let Some(d) = self.direct.as_mut() {
d.also.retain(|id, points| alive.contains(&id) && !points.is_empty());
}
}
fn point_edit(&self, drag: &PointDrag) -> Option<PathEdit> {
let shaped = self.shaped.as_ref()?;
let direct = self.direct.as_ref()?;
let (a, b) = (to_local(shaped.matrix, drag.start), to_local(shaped.matrix, drag.now));
match drag.grab {
PointGrab::Anchors => Some(PathEdit::Move {
points: direct.points.iter().copied().collect(),
by: [b[0] - a[0], b[1] - a[1]],
}),
PointGrab::Handle(point, side) => Some(PathEdit::Handle {
point,
side,
to: b,
free: drag.free,
}),
PointGrab::Marquee { .. } => None,
}
}
fn spread(&self, edit: &PathEdit) -> Vec<(Shaped, PathEdit)> {
let (Some(direct), Some(first)) = (self.direct.as_ref(), self.shaped.as_ref()) else {
return Vec::new();
};
let all = |points: &[usize]| points.iter().copied().collect::<BTreeSet<usize>>() == direct.points;
self.also_shaped
.iter()
.filter_map(|shaped| {
let points: Vec<usize> = direct.also.get(&shaped.node)?.iter().copied().collect();
let theirs = match edit {
PathEdit::Move { points: of, by } if all(of) => {
let moved = to_canvas(first.matrix, *by) - to_canvas(first.matrix, [0.0, 0.0]);
let by = to_local(shaped.matrix, to_canvas(shaped.matrix, [0.0, 0.0]) + moved);
PathEdit::Move { points, by }
}
PathEdit::Remove { points: of } if all(of) => PathEdit::Remove { points },
PathEdit::Corner { points: of } if all(of) => PathEdit::Corner { points },
PathEdit::Smooth { points: of } if all(of) => PathEdit::Smooth { points },
_ => return None,
};
Some((shaped.clone(), theirs))
})
.collect()
}
fn shown_subs(&self) -> Option<Vec<Subpath>> {
if let Some(commit) = self.path_commit.as_ref() {
return Some(commit.preview.clone());
}
let mut subs = self.shaped.as_ref()?.subs.clone();
if let Some(edit) = self.point_drag.as_ref().and_then(|d| self.point_edit(d)) {
let _ = edit.apply(&mut subs);
}
Some(subs)
}
fn shown_also(&self) -> Vec<Shaped> {
if let Some(commit) = self.path_commit.as_ref() {
return commit.also.clone();
}
let moved = self
.point_drag
.as_ref()
.and_then(|d| self.point_edit(d))
.map_or(Vec::new(), |edit| self.spread(&edit));
self.also_shaped
.iter()
.map(|shaped| {
let mut shown = shaped.clone();
if let Some((_, edit)) = moved.iter().find(|(s, _)| s.node == shaped.node) {
let _ = edit.apply(&mut shown.subs);
}
shown
})
.collect()
}
fn promote(&mut self, view: View, rect: Rect, pos: Pos2) {
let Some(direct) = self.direct.as_ref() else {
return;
};
let found = self.also_shaped.iter().find_map(|shaped| {
let chosen = direct.also.get(&shaped.node)?;
pathedit::anchors(&shaped.subs)
.iter()
.enumerate()
.any(|(i, (_, a))| {
chosen.contains(&i)
&& self.screen(view, rect, to_canvas(shaped.matrix, a.at)).distance(pos) <= HANDLE
})
.then(|| shaped.node.clone())
});
let (Some(id), Some(d)) = (found, self.direct.as_mut()) else {
return;
};
let points = d.also.remove(&id).unwrap_or_default();
let before = (
std::mem::replace(&mut d.node, id),
std::mem::replace(&mut d.points, points),
);
d.also.insert(before.0, before.1);
self.refresh_shape();
}
fn direct_down(&mut self, view: View, rect: Rect, pos: Pos2, c: Vec2) -> Result<()> {
let (alt, shift) = (self.modifiers.alt, self.modifiers.shift);
self.pick_later = false;
self.promote(view, rect, pos);
enum Action {
Handle(usize, Side),
Anchor(usize, bool),
Insert(usize, f32),
Elsewhere,
}
let action = match self.shaped.as_ref() {
Some(shaped) => {
let m = shaped.matrix;
let screen = |p: [f32; 2]| self.screen(view, rect, to_canvas(m, p));
let anchors = pathedit::anchors(&shaped.subs);
let selected: Vec<usize> = self
.direct
.as_ref()
.map_or(Vec::new(), |d| d.points.iter().copied().collect());
let handle = selected.iter().find_map(|&i| {
let a = anchors.get(i)?.1;
[(Side::In, a.inn, a.has_in()), (Side::Out, a.out, a.has_out())]
.into_iter()
.find(|(_, p, has)| *has && screen(*p).distance(pos) <= HANDLE)
.map(|(side, _, _)| (i, side))
});
let anchor = anchors.iter().position(|(_, a)| screen(a.at).distance(pos) <= HANDLE);
let scale = (m[0] * m[3] - m[1] * m[2]).abs().sqrt() * view.zoom;
let near = pathedit::nearest(&shaped.subs, to_local(m, c)).filter(|(_, _, d)| d * scale <= 8.0);
match (handle, anchor, near) {
(Some((i, side)), _, _) => Action::Handle(i, side),
(None, Some(i), _) => Action::Anchor(i, anchors[i].1.has_in() || anchors[i].1.has_out()),
(None, None, Some((segment, t, _))) if alt => Action::Insert(segment, t),
_ => Action::Elsewhere,
}
}
None => Action::Elsewhere,
};
match action {
Action::Handle(i, side) => {
self.point_drag = Some(PointDrag {
grab: PointGrab::Handle(i, side),
start: c,
now: c,
free: alt,
});
}
Action::Anchor(i, curved) if alt => {
let points = vec![i];
return self.commit_path(if curved {
PathEdit::Corner { points }
} else {
PathEdit::Smooth { points }
});
}
Action::Anchor(i, _) => {
if let Some(d) = self.direct.as_mut() {
if shift {
if !d.points.remove(&i) {
d.points.insert(i);
}
} else if !d.points.contains(&i) {
d.points = BTreeSet::from([i]);
d.also.clear();
}
if d.points.contains(&i) {
self.point_drag = Some(PointDrag {
grab: PointGrab::Anchors,
start: c,
now: c,
free: false,
});
}
}
}
Action::Insert(segment, t) => return self.commit_path(PathEdit::Insert { segment, t }),
Action::Elsewhere => {
let on_shape = match shift || (self.direct.is_some() && !self.on_picked_shape(c)?) {
true => {
self.pick_later = true;
Some(false)
}
false => self.pick_elsewhere(c)?,
};
if let Some(on_shape) = on_shape {
self.point_drag = Some(PointDrag {
grab: PointGrab::Marquee { on_shape },
start: c,
now: c,
free: false,
});
}
}
}
Ok(())
}
fn on_picked_shape(&self, c: Vec2) -> Result<bool> {
let Some(current) = self.direct.as_ref().map(|d| &d.node) else {
return Ok(false);
};
let under = overlay::leaf_hits(&self.scene.bundle.doc, self.scene.frame, (c.x, c.y))?;
if !under.is_empty() {
return Ok(under.contains(current));
}
let zoom = self.view.map_or(1.0, |v| v.zoom);
Ok(self.mark_at(c, 5.0 / zoom).is_some_and(|(path, mark)| {
path == self.scene.active
&& self
.scene
.active_cel()
.is_some_and(|cel| markedit::address(&cel, mark) == *current)
}))
}
fn pick_elsewhere(&mut self, c: Vec2) -> Result<Option<bool>> {
self.under = overlay::leaf_hits(&self.scene.bundle.doc, self.scene.frame, (c.x, c.y))?;
let zoom = self.view.map_or(1.0, |v| v.zoom);
let mut on_stroke = false;
if self.under.is_empty()
&& let Some((path, mark)) = self.mark_at(c, 5.0 / zoom)
{
if path != self.scene.active {
self.activate(path)?;
}
let picked = self
.scene
.active_marks()
.iter()
.find(|m| m.id() == mark)
.map(|m| m.as_stroke().is_some());
match (picked, self.scene.active_cel()) {
(Some(true), Some(cel)) => {
let address = markedit::address(&cel, mark);
if self.direct.as_ref().map(|d| &d.node) != Some(&address) {
self.pick_shape(address);
return Ok(None);
}
on_stroke = true;
}
(Some(false), _) => self.say(Tone::Info, "that is a fill: A reshapes strokes and vector shapes"),
_ => {}
}
}
let current = self.direct.as_ref().map(|d| d.node.clone());
let hit = match ¤t {
Some(id) if self.under.contains(id) => Some(id.clone()),
_ => self.under.first().cloned(),
};
match hit {
Some(id) if Some(&id) != current.as_ref() => {
self.pick_shape(id);
Ok(None)
}
hit => Ok(Some(hit.is_some() || on_stroke)),
}
}
fn pen_down(&mut self, view: View, rect: Rect, pos: Pos2, c: Vec2) -> Result<()> {
let vector = self
.scene
.active_layer()
.is_some_and(|l| l.kind() == Kind::Vector && !l.locked);
if !vector {
self.say(
Tone::Refused,
"the pen draws vector paths: pick a vector layer, or add one with \"vector\" in Layers",
);
return Ok(());
}
let first = self
.pen_path
.as_ref()
.filter(|p| p.anchors.len() >= 2)
.and_then(|p| p.anchors.first())
.map(|a| self.screen(view, rect, vec2(a.at[0], a.at[1])));
if first.is_some_and(|f| f.distance(pos) <= HANDLE + 2.0) {
return self.commit_pen(true);
}
let path = self.pen_path.get_or_insert_with(|| PenPath {
anchors: Vec::new(),
dragging: false,
});
path.anchors.push(pathedit::Anchor::corner([c.x, c.y]));
path.dragging = true;
Ok(())
}
fn pen_move(&mut self, c: Vec2) {
let zoom = self.view.map_or(1.0, |v| v.zoom);
let Some(last) = self
.pen_path
.as_mut()
.filter(|p| p.dragging)
.and_then(|p| p.anchors.last_mut())
else {
return;
};
let pull = [c.x - last.at[0], c.y - last.at[1]];
let (out, inn) = match pull[0].hypot(pull[1]) * zoom > 3.0 {
true => ([c.x, c.y], [last.at[0] - pull[0], last.at[1] - pull[1]]),
false => (last.at, last.at),
};
last.out = out;
last.inn = inn;
}
fn pen_keys(&mut self, ui: &mut egui::Ui) -> Result<()> {
if self.pen_path.is_none() {
return Ok(());
}
if self.tool != Tool::Pen {
return self.commit_pen(false);
}
if self.keys_busy {
return Ok(());
}
let (finish, cancel) = ui.input_mut(|i| {
(
i.consume_key(egui::Modifiers::NONE, Key::Enter),
i.consume_key(egui::Modifiers::NONE, Key::Escape),
)
});
if cancel {
self.pen_path = None;
self.say(Tone::Info, "path dropped");
}
if finish {
self.commit_pen(false)?;
}
Ok(())
}
fn commit_pen(&mut self, closed: bool) -> Result<()> {
let Some(path) = self.pen_path.take() else {
return Ok(());
};
if path.anchors.len() < 2 {
self.say(Tone::Info, "a path needs two points: click again before Return");
return Ok(());
}
let Some((layer, name)) = self
.scene
.active_layer()
.filter(|l| l.kind() == Kind::Vector)
.map(|l| (l.id.clone(), l.name.clone()))
else {
return Ok(());
};
let d = pathedit::to_d(&[Subpath {
anchors: path.anchors,
closed,
}]);
let (colour, outline) = (color::hex(self.color), color::hex(self.second));
let fill = (closed && self.pen_fill).then(|| colour.clone());
let mut node = json!({ "type": "path", "d": d });
if let Some(fill) = &fill {
node["fill"] = json!(fill);
}
if self.pen_stroke || fill.is_none() {
node["stroke"] = json!({ "paint": outline, "width": self.pen_width, "cap": "round", "join": "round" });
}
let op = Op::AddNode {
node,
place: klad_core::ops::Place {
into: Some(layer),
frame: Some(self.scene.frame),
..Default::default()
},
};
self.apply(vec![op])?;
self.used_colour();
self.say(
Tone::Done,
format!(
"{} path added to {name}: V moves it, A edits its points",
if closed { "closed" } else { "open" }
),
);
Ok(())
}
#[allow(clippy::too_many_arguments)]
fn decorate_pen(
&self,
painter: &egui::Painter,
path: &PenPath,
hover: Option<Pos2>,
view: View,
rect: Rect,
accent: Color32,
dark: egui::Stroke,
) {
let to_screen = |p: [f32; 2]| self.screen(view, rect, vec2(p[0], p[1]));
let mut anchors = path.anchors.clone();
if let Some(hover) = hover.filter(|h| !path.dragging && rect.contains(*h)) {
let c = view.to_canvas(hover - rect.min, rect.size());
anchors.push(pathedit::Anchor::corner([c.x, c.y]));
}
let sub = Subpath { anchors, closed: false };
pathedit::flatten(&[sub], 2.0 / view.zoom.max(1e-3))
.into_iter()
.for_each(|line| {
let points: Vec<Pos2> = line.into_iter().map(to_screen).collect();
painter.add(egui::Shape::line(points.clone(), dark));
painter.add(egui::Shape::line(points, egui::Stroke::new(1.5, accent)));
});
if let Some(last) = path.anchors.last().filter(|a| a.has_out()) {
[last.inn, last.out].into_iter().for_each(|h| {
painter.line_segment([to_screen(last.at), to_screen(h)], egui::Stroke::new(1.0, accent));
painter.circle_filled(to_screen(h), 3.5, accent);
});
}
path.anchors.iter().enumerate().for_each(|(i, a)| {
let p = to_screen(a.at);
let size = if i == 0 && path.anchors.len() >= 2 {
HANDLE + 3.0
} else {
HANDLE
};
let square = Rect::from_center_size(p, vec2(size, size));
painter.rect_filled(square, 1.0, Color32::WHITE);
painter.rect_stroke(square, 1.0, egui::Stroke::new(1.0, accent), egui::StrokeKind::Middle);
});
}
fn pick_shape(&mut self, id: String) {
self.direct = Some(Direct {
node: id,
points: BTreeSet::new(),
also: BTreeMap::new(),
});
self.refresh_shape();
}
fn direct_up(&mut self) -> Result<()> {
let Some(drag) = self.point_drag.take() else {
return Ok(());
};
let zoom = self.view.map_or(1.0, |v| v.zoom);
let moved = (drag.now - drag.start).length() * zoom > 2.0;
match drag.grab {
PointGrab::Marquee { on_shape } => {
let later = std::mem::take(&mut self.pick_later);
if !moved && later {
if self.pick_elsewhere(drag.start)? == Some(false) {
self.direct = None;
}
return Ok(());
}
if !moved {
let current = self.direct.as_ref().map(|d| d.node.clone());
let below = current
.and_then(|id| self.under.iter().position(|u| *u == id))
.filter(|_| self.under.len() > 1)
.map(|i| self.under[(i + 1) % self.under.len()].clone());
match (on_shape, below) {
(true, Some(id)) => self.pick_shape(id),
(true, None) => {
if let Some(d) = self.direct.as_mut() {
d.points.clear();
d.also.clear();
}
}
(false, _) => self.direct = None,
}
return Ok(());
}
let (lo, hi) = (drag.start.min(drag.now), drag.start.max(drag.now));
let boxed = |shaped: &Shaped| -> BTreeSet<usize> {
pathedit::anchors(&shaped.subs)
.iter()
.enumerate()
.filter(|(_, (_, a))| {
let p = to_canvas(shaped.matrix, a.at);
p.x >= lo.x && p.x <= hi.x && p.y >= lo.y && p.y <= hi.y
})
.map(|(i, _)| i)
.collect()
};
if self.modifiers.shift {
let found: Vec<(String, BTreeSet<usize>)> = self
.layer_shapes([lo.x, lo.y, hi.x, hi.y])
.iter()
.filter_map(|id| self.shape_of(id))
.map(|shaped| (boxed(&shaped), shaped.node))
.filter(|(points, _)| !points.is_empty())
.map(|(points, id)| (id, points))
.collect();
if self.direct.is_none()
&& let Some((id, _)) = found.first()
{
self.pick_shape(id.clone());
}
if let Some(d) = self.direct.as_mut() {
found.into_iter().for_each(|(id, points)| match id == d.node {
true => d.points.extend(points),
false => d.also.entry(id).or_default().extend(points),
});
}
self.refresh_shape();
return Ok(());
}
let inside = self.shaped.as_ref().map(boxed);
if let (Some(d), Some(inside)) = (self.direct.as_mut(), inside) {
d.points = inside;
d.also.clear();
}
Ok(())
}
_ if !moved => Ok(()),
_ => match self.point_edit(&drag) {
Some(edit) => self.commit_path(edit),
None => Ok(()),
},
}
}
fn stroke_path(&self, id: &str) -> Option<Vec<Subpath>> {
let (cel, mark) = markedit::parse_address(id)?;
if self.scene.active_cel().as_deref() != Some(cel) {
return None;
}
let stroke = self
.scene
.active_marks()
.iter()
.find(|m| m.id() == mark)
.and_then(|m| m.as_stroke())?;
let points: Vec<[f32; 2]> = stroke
.samples
.iter()
.map(|s| {
let (x, y) = s.pos();
[x, y]
})
.collect();
Some(vec![pathedit::fit_polyline(
&points,
(stroke.size * 0.12).clamp(1.0, 6.0),
)])
}
fn reshape_stroke(&mut self, id: String, edit: PathEdit, also: Vec<(Shaped, PathEdit)>) -> Result<()> {
let Some(shaped) = self.shaped.as_ref().filter(|s| s.node == id) else {
return Ok(());
};
let mut subs = shaped.subs.clone();
if let Err(e) = edit.apply(&mut subs) {
self.say(Tone::Refused, format!("{e:#}"));
return Ok(());
}
let points = |subs: &[Subpath]| subs.iter().map(|s| s.anchors.len()).sum::<usize>();
if points(&subs) != points(&shaped.subs)
&& let Some(d) = self.direct.as_mut()
{
d.points.clear();
}
let removing = matches!(edit, PathEdit::Remove { .. });
let bent: Vec<Shaped> = also
.into_iter()
.filter_map(|(mut shaped, edit)| edit.apply(&mut shaped.subs).is_ok().then_some(shaped))
.collect();
let set = |id: &str, subs: &[Subpath]| Op::Set {
id: id.to_string(),
props: [("path".to_string(), json!(pathedit::to_d(subs)))]
.into_iter()
.collect(),
};
let ops = std::iter::once(set(&id, &subs))
.chain(bent.iter().map(|shaped| set(&shaped.node, &shaped.subs)))
.collect();
self.apply(ops)?;
let rev = self.scene.bundle.doc.rev;
self.shaped = Some(Shaped {
node: id,
rev,
subs,
matrix: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0],
});
self.also_shaped = std::mem::take(&mut self.also_shaped)
.into_iter()
.map(|shaped| {
let now = bent.iter().find(|b| b.node == shaped.node).cloned().unwrap_or(shaped);
Shaped { rev, ..now }
})
.collect();
if removing && let Some(d) = self.direct.as_mut() {
d.also.clear();
}
Ok(())
}
fn commit_path(&mut self, edit: PathEdit) -> Result<()> {
let Some(id) = self.direct.as_ref().map(|d| d.node.clone()) else {
return Ok(());
};
if self.path_commit.is_some() {
return Ok(());
}
let also = self.spread(&edit);
let removing = matches!(edit, PathEdit::Remove { .. });
if markedit::parse_address(&id).is_some() {
return self.reshape_stroke(id, edit, also);
}
let doc = &self.scene.bundle.doc;
let Some(Loc::Node(path, c, _)) = doc.locate(&id) else {
return Ok(());
};
let layer = doc.layer_at(&path);
if layer.locked {
self.say(
Tone::Refused,
format!(
"{} is locked: unlock it with the lock in the layers panel to change it",
layer.name
),
);
return Ok(());
}
let cel = layer.cels()[c].id.clone();
let edits: Vec<Op> = std::iter::once(Op::Path { id: id.clone(), edit })
.chain(also.iter().map(|(shaped, edit)| Op::Path {
id: shaped.node.clone(),
edit: edit.clone(),
}))
.collect();
let ops = vector::pinned(doc, &edits)?;
let (next, _) = apply_all(doc, &ops)?;
let nodes = match next.locate(&cel) {
Some(Loc::Cel(p, c)) => next.layer_at(&p).cels()[c].nodes.clone(),
_ => Vec::new(),
};
let preview = match next.item(&id) {
Some(Item::Node(_, _, n)) => pathedit::from_shape(&n.shape).unwrap_or_default(),
_ => Vec::new(),
};
let count = |subs: &[Subpath]| subs.iter().map(|s| s.anchors.len()).sum::<usize>();
if Some(count(&preview)) != self.shaped.as_ref().map(|s| count(&s.subs))
&& let Some(d) = self.direct.as_mut()
{
d.points.clear();
}
let also = self
.also_shaped
.iter()
.map(|shaped| Shaped {
subs: match next.item(&shaped.node) {
Some(Item::Node(_, _, n)) => pathedit::from_shape(&n.shape).unwrap_or_default(),
_ => Vec::new(),
},
..shaped.clone()
})
.collect();
if removing && let Some(d) = self.direct.as_mut() {
d.also.clear();
}
let job = lift::render(nodes, self.scene.size(), self.ctx.clone());
self.path_commit = Some(PathCommit {
job,
ops,
cel,
preview,
also,
node: id,
});
Ok(())
}
fn tend_path(&mut self) -> Result<()> {
let Some(result) = self.path_commit.as_ref().and_then(|p| p.job.try_recv().ok()) else {
return Ok(());
};
let Some(commit) = self.path_commit.take() else {
return Ok(());
};
let start = Instant::now();
let dirty = match result {
Ok((hash, raster)) => self
.scene
.apply_rendered(&commit.ops, (commit.cel, hash, raster), &self.brushes)?,
Err(e) => {
self.failed(e.context("the edited path could not be drawn"));
self.scene.apply(&commit.ops, &self.brushes)?
}
};
self.dirty.extend(dirty);
self.measure(
"point edit",
format!("point edit on {} written in {:.0} ms", commit.node, ms(start)),
);
self.forget_missing_selection();
Ok(())
}
fn on_pen(&mut self, ctx: &egui::Context, e: PenEvent, rect: Rect, was_focused: bool) -> Result<()> {
self.readout.pressure = e.pressure;
self.readout.tilt = e.tilt;
self.readout.eraser = e.eraser;
self.readout.tablet = e.tablet;
if e.tablet {
self.readout.device = e.device;
if e.phase != Phase::Up && self.settings.note_peak(&device_key(e.device), e.pressure) {
self.settings_dirty = true;
}
}
if e.phase == Phase::Move {
self.readout.samples.push_back(e.at);
while self
.readout
.samples
.front()
.is_some_and(|t| e.at.duration_since(*t) > Duration::from_secs(1))
{
self.readout.samples.pop_front();
}
}
let Some(view) = self.view else {
return Ok(());
};
let c = view.to_canvas(e.pos - rect.min, rect.size());
let on_canvas = rect.contains(e.pos)
&& ctx
.layer_id_at(e.pos)
.is_none_or(|l| l.order == egui::Order::Background);
let picking = self.modifiers.alt && !self.modifiers.command && matches!(self.tool, Tool::Brush | Tool::Fill);
let sizing_now = self.modifiers.alt && self.modifiers.command && self.tool == Tool::Brush;
match (e.phase, self.sizing) {
(Phase::Down, None) if sizing_now && on_canvas && self.live.is_none() => {
self.sizing = Some((e.pos.x, self.size, e.pos));
return Ok(());
}
(Phase::Move, Some((x, start, _))) => {
self.size = options::size_from_drag(start, e.pos.x - x);
return Ok(());
}
(Phase::Up, Some(_)) => {
self.sizing = None;
return Ok(());
}
_ => {}
}
let pressing = e.phase == Phase::Down && was_focused && on_canvas && !self.navigating;
if pressing && self.holding_frame_keys() {
return Ok(());
}
let needs_canvas = matches!(self.tool, Tool::Brush | Tool::Fill | Tool::Strokes | Tool::Select);
if pressing && !needs_canvas {
self.hold_still();
}
if pressing && needs_canvas && !self.ensure_canvas()? {
self.say(
Tone::Info,
format!("frame {} is still loading; draw again in a moment", self.scene.frame),
);
return Ok(());
}
match (self.tool, e.phase) {
(_, Phase::Down) if !was_focused || !on_canvas || self.navigating => {}
(_, Phase::Down) if picking => self.pick_colour(c, self.modifiers.shift)?,
(Tool::Fill, Phase::Down) if self.scene.on_grid() => {
if self.scene.can_paint() {
self.fill_pixels(klad_core::pixel::cell_at(c.x, c.y))?;
}
}
(Tool::Fill, Phase::Move | Phase::Up) if self.scene.on_grid() => {}
(Tool::Brush, Phase::Down) if self.scene.on_grid() => {
if self.pixel_live.is_none() && self.scene.can_paint() {
let at = klad_core::pixel::cell_at(c.x, c.y);
let run = match self.pixel_last.filter(|_| self.modifiers.shift) {
Some(last) => klad_core::pixel::line(last, at),
None => vec![at],
};
let erase = e.eraser || self.brush == "eraser";
self.pixel_live = Some(PixelLive { run, erase });
}
}
(Tool::Brush, Phase::Move) if self.pixel_live.is_some() => {
if let Some(live) = self.pixel_live.as_mut() {
klad_core::pixel::extend(&mut live.run, klad_core::pixel::cell_at(c.x, c.y));
}
}
(Tool::Brush, Phase::Up) if self.pixel_live.is_some() => self.finish_pixels()?,
(Tool::Fill, Phase::Down) => {
if self.scene.can_paint() {
self.lasso = Some(Lasso {
points: vec![c],
start: e.pos,
far: false,
});
}
}
(Tool::Strokes, Phase::Down) => match self.grab_at(view, rect, e.pos) {
Some((id, grab, corners)) => self.start_drag(id, grab, corners, c, false),
None => {
self.lasso = Some(Lasso {
points: vec![c],
start: e.pos,
far: false,
});
}
},
(Tool::Strokes, Phase::Up) if self.drag.is_some() => self.finish_drag()?,
(Tool::Strokes, Phase::Up) => self.finish_pick()?,
(Tool::Strokes, Phase::Move) if self.drag.is_some() => {
if let Some(drag) = self.drag.as_mut() {
drag.to(c);
}
self.copy_for_drag()?;
}
(Tool::Direct, Phase::Down) if self.path_commit.is_some() => {}
(Tool::Direct, Phase::Down) => self.direct_down(view, rect, e.pos, c)?,
(Tool::Direct, Phase::Move) => {
if let Some(drag) = self.point_drag.as_mut() {
drag.now = c;
drag.free |= self.modifiers.alt;
}
}
(Tool::Direct, Phase::Up) => self.direct_up()?,
(Tool::Fill | Tool::Strokes | Tool::Select, Phase::Move) if self.drag.is_none() => {
if let Some(lasso) = self.lasso.as_mut() {
lasso.far |= (e.pos - lasso.start).length() > 6.0;
if lasso.points.last().is_none_or(|p| (*p - c).length() >= 1.0) {
lasso.points.push(c);
}
}
}
(Tool::Fill, Phase::Up) => self.finish_fill()?,
(Tool::Brush, Phase::Down) => {
if self.live.is_none() && self.scene.can_paint() {
self.begin(&e, c)?;
}
}
(Tool::Brush, Phase::Move) => {
if let Some(live) = self.live.as_mut() {
let dt = e.at.duration_since(live.last_at).as_secs_f32() * 1000.0;
let sample = live.recorder.push(raw_of(&e, c, dt));
live.painter
.push_on(&sample, &mut self.buffer, self.scene.active_raster());
live.stroke.samples.push(sample);
if let Some((axis, copy, painter)) = live.twin.as_mut() {
let twin = make::mirrored(&sample, *axis);
painter.push_on(&twin, &mut self.mirror_buffer, self.scene.active_raster());
copy.samples.push(twin);
}
live.last_at = e.at;
self.pending.get_or_insert(e.at);
}
}
(Tool::Brush, Phase::Up) => self.finish()?,
(Tool::Select, Phase::Down) => match self.grab_at(view, rect, e.pos) {
Some((_, Grab::Move, _))
if self.modifiers.shift
&& self.selection.is_some()
&& !self.on_marks()
&& self.toggle_shape(c)? => {}
Some((id, grab, corners)) => self.start_drag(id, grab, corners, c, false),
None => {
self.end_shift();
self.grab_under(c, e.pos)?
}
},
(Tool::Select, Phase::Move) => {
if let Some(drag) = self.drag.as_mut() {
drag.to(c);
}
self.copy_for_drag()?;
}
(Tool::Select, Phase::Up) if self.lasso.is_some() && self.lasso_shapes()? => {}
(Tool::Select, Phase::Up) if self.lasso.is_some() => match self.scene.active_cel() {
Some(_) => self.finish_pick()?,
None => {
self.lasso = None;
self.picked = None;
}
},
(Tool::Select, Phase::Up) => self.finish_drag()?,
(Tool::Note, Phase::Down) => self.press_note(c),
(Tool::Shape, Phase::Down) => self.shape_down(c),
(Tool::Shape, Phase::Move) => self.shape_move(c),
(Tool::Shape, Phase::Up) => self.shape_up()?,
(Tool::Text, Phase::Down) => self.text_down(c)?,
(Tool::Bone, Phase::Down) => self.bone_down(c),
(Tool::Bone, Phase::Move) => self.bone_move(c),
(Tool::Bone, Phase::Up) => self.bone_up()?,
(Tool::Pen, Phase::Down) => self.pen_down(view, rect, e.pos, c)?,
(Tool::Pen, Phase::Move) => self.pen_move(c),
(Tool::Pen, Phase::Up) => {
if let Some(path) = self.pen_path.as_mut() {
path.dragging = false;
}
}
_ => {}
}
Ok(())
}
fn shaped(&self) -> Result<(String, BrushDef)> {
let base = self.brushes.def(&self.brush).ok_or_else(|| {
anyhow!(
"the brush {} is not there any more: pick another one in the brush panel",
self.brush
)
})?;
let def = match &self.custom {
Some(def) => def.clone(),
None => self.tuning.shape(base),
};
Ok((pick_id(&self.brush, &def, &self.embedded), def))
}
fn pick(&mut self, id: &str) {
if let Some(def) = self.brushes.def(id) {
self.tuning = self.tuned(id, def);
self.brush = id.to_string();
self.custom = None;
self.brush_window.name = def.name.clone();
}
}
fn tuned(&self, id: &str, def: &BrushDef) -> Tuning {
let tuning = Tuning::of(def);
match (id, self.settings.eraser_feather, tuning.hardness) {
("eraser", Some(feather), Some(_)) => Tuning { feather, ..tuning },
_ => tuning,
}
}
pub(super) fn eraser_feather(&self) -> Option<f32> {
if self.is_on(Cmd::Eraser) != Some(true) {
return None;
}
let def = self.brushes.def("eraser").filter(|d| d.hardness().is_some())?;
Some(self.settings.eraser_feather.unwrap_or(def.feather))
}
pub(super) fn set_eraser_feather(&mut self, feather: f32) {
let feather = feather.clamp(0.0, 1.0);
self.settings.eraser_feather = Some(feather);
self.settings_dirty = true;
if self.brush == "eraser" {
self.tuning.feather = feather;
}
}
fn begin(&mut self, e: &PenEvent, c: Vec2) -> Result<()> {
let (name, def, tuning) = if e.eraser {
let base = self
.brushes
.def("eraser")
.cloned()
.ok_or_else(|| crate::report::bug("the eraser brush is missing from the library"))?;
let tuning = self.tuned("eraser", &base);
let def = tuning.shape(&base);
(pick_id("eraser", &def, &self.embedded), def, tuning)
} else {
let (name, def) = self.shaped()?;
let tuning = match &self.custom {
Some(custom) => Tuning {
taper: custom.taper,
stabilizer: custom.stabilizer,
smoothing: custom.smoothing,
..self.tuning
},
None => self.tuning,
};
(name, def, tuning)
};
if self.brushes.def(&name) != Some(&def) {
self.brushes.insert(&name, def);
}
let brush = self.brushes.get(&name)?.clone();
let lock = self.scene.active_locks_alpha();
if lock && stroke_blend(&brush, true).is_none() {
self.say(
Tone::Refused,
"alpha is locked on this layer, so the eraser cannot change it (untick lock alpha)",
);
return Ok(());
}
let id = self.scene.next_mark_id();
let mut stroke = Stroke::new(id, &name, self.color, self.size, self.rng.next_u64() as u32);
stroke.opacity = self.opacity;
stroke.flow = self.flow;
stroke.taper = tuning.taper;
stroke.lock = lock;
let curve = if e.tablet {
self.settings.curve(&device_key(e.device))
} else {
PressureCurve::default()
};
let mut recorder = Recorder::new(curve, tuning.stabilizer, tuning.smoothing);
let sample = recorder.push(raw_of(e, c, 0.0));
if brush.def.color.is_some_and(|c| c.uses_second()) {
stroke.second = Some(klad_core::color::to_u16(self.second));
}
let mut painter = StrokePainter::live(&brush, &stroke);
painter.push_on(&sample, &mut self.buffer, self.scene.active_raster());
stroke.samples.push(sample);
let twin = self.mirror.map(|axis| {
let mut copy = stroke.clone();
copy.id = id + 1;
copy.seed = stroke.seed.wrapping_add(1);
copy.samples = vec![make::mirrored(&sample, axis)];
let mut painter = StrokePainter::live(&brush, ©);
painter.push_on(©.samples[0], &mut self.mirror_buffer, self.scene.active_raster());
(axis, copy, painter)
});
self.live = Some(Live {
stroke,
painter,
brush,
recorder,
last_at: e.at,
twin,
});
self.pending.get_or_insert(e.at);
Ok(())
}
fn finish(&mut self) -> Result<()> {
let Some(mut live) = self.live.take() else {
return Ok(());
};
let start = Instant::now();
let tail = live.recorder.finish();
tail.iter()
.for_each(|s| live.painter.push_on(s, &mut self.buffer, self.scene.active_raster()));
live.painter.end(&mut self.buffer, self.scene.active_raster());
if let Some((axis, copy, painter)) = live.twin.as_mut() {
tail.iter().map(|s| make::mirrored(s, *axis)).for_each(|s| {
painter.push_on(&s, &mut self.mirror_buffer, self.scene.active_raster());
copy.samples.push(s);
});
painter.end(&mut self.mirror_buffer, self.scene.active_raster());
}
live.stroke.samples.extend(tail);
let repainted = needs_repaint(&live.stroke);
if repainted {
self.dirty.extend(self.buffer.touched().iter().copied());
self.buffer.reset();
klad_brush::draw_stroke_on(&mut self.buffer, &live.brush, &live.stroke, self.scene.active_raster());
if let Some((_, copy, _)) = &live.twin {
self.dirty.extend(self.mirror_buffer.touched().iter().copied());
self.mirror_buffer.reset();
klad_brush::draw_stroke_on(&mut self.mirror_buffer, &live.brush, copy, self.scene.active_raster());
}
}
let ended = ms(start);
if self.external.is_some() {
self.reload()?;
}
if self.scene.bundle.embed_brush(&live.stroke.brush, &live.brush.def)? {
self.embedded.insert(live.stroke.brush.clone(), live.brush.def.clone());
}
let samples = live.stroke.samples.len();
let dabs = live.painter.dabs();
let alone = encode_cel(&[Mark::Stroke(live.stroke.clone())])?.len();
let brush = live.stroke.brush.clone();
let erasing = live.brush.blend == klad_brush::brush::StrokeBlend::Erase;
let blend = stroke_blend(&live.brush, live.stroke.lock).unwrap_or(live.brush.blend);
let attaching = Instant::now();
live.stroke.on = self.attaching(&live.stroke, &live.brush.def);
let attach = ms(attaching);
let mut touched = self.scene.commit_stroke(live.stroke, &mut self.buffer, blend)?;
if let Some((_, mut copy, _)) = live.twin {
copy.id = self.scene.next_mark_id();
copy.on = self.attaching(©, &live.brush.def);
touched.extend(self.scene.commit_stroke(copy, &mut self.mirror_buffer, blend)?);
}
let commit = ms(start);
self.dirty.extend(touched);
let saving = Instant::now();
let bytes = self.scene.save_active("stroke")?;
self.first.drew |= !erasing;
if !erasing {
self.used_colour();
}
let count = self.scene.active_marks().len();
let text = format!(
"{brush}: {samples} samples, {dabs} live dabs, {alone} B packed alone\nlayer file {bytes} B for {count} strokes and fills ({:.0} B each)\npen up {ended:.1} ms{}, attach {attach:.1} ms, commit {commit:.1} ms, save {:.1} ms",
bytes as f64 / count.max(1) as f64,
if repainted { " (tapered repaint)" } else { "" },
ms(saving)
);
self.measure("stroke", text);
Ok(())
}
fn attaching(&self, stroke: &Stroke, def: &BrushDef) -> Vec<u32> {
let marks = self.scene.active_marks();
klad_core::attach::targets(marks, marks.len(), stroke, |id| match id == stroke.brush {
true => Some(def),
false => self.brushes.def(id).or_else(|| self.embedded.get(id)),
})
}
fn set_colour(&mut self, rgba: [f32; 4]) {
self.color = rgba;
self.hsva = Hsva::from_rgba(rgba, self.hsva.h);
}
fn used_colour(&mut self) {
if self.settings.used(&color::hex(self.color)) {
self.settings_dirty = true;
}
}
fn pick_colour(&mut self, at: Vec2, layer_only: bool) -> Result<()> {
let where_from = if layer_only { "this layer" } else { "the image" };
match self.scene.sample((at.x, at.y), layer_only)? {
Some(rgba) => {
self.pick_new_colour(rgba);
self.say(Tone::Done, format!("picked {} from {where_from}", color::hex(rgba)));
}
None => self.say(Tone::Refused, format!("nothing to pick from {where_from} there")),
}
Ok(())
}
fn fill_reference(&self) -> FillRef {
match &self.fill.reference {
FillRef::Layer(id) if self.scene.active_id().as_ref() == Some(id) => FillRef::This,
FillRef::Layer(id) if self.scene.bundle.doc.layer(id).is_none() => FillRef::This,
other => other.clone(),
}
}
fn pixel_cells(&self, live: &PixelLive) -> Vec<klad_core::pixel::Cell> {
let run = match self.pixel_perfect && self.pixel_size == 1 {
true => klad_core::pixel::perfect(&live.run),
false => live.run.clone(),
};
klad_core::pixel::stamp(&run, self.pixel_size)
}
pub(super) fn pixel_spec(&self, erase: bool) -> Option<klad_core::ops::PixelSpec> {
let shade = match (erase, self.pixel_mode) {
(false, PixelMode::Lighter) => Some(1),
(false, PixelMode::Darker) => Some(-1),
_ => None,
};
let dither = (!erase && shade.is_none() && self.pixel_dither < 100).then_some(self.pixel_dither);
Some(klad_core::ops::PixelSpec {
layer: self.scene.active_id()?,
frame: self.scene.frame,
color: (!erase && shade.is_none()).then(|| color::hex(self.color)),
erase,
shade,
dither,
second: dither.filter(|_| self.pixel_two).map(|_| color::hex(self.second)),
mirror_x: self.mirror.map(|axis| (axis * 2.0).round() / 2.0),
by_hand: true,
..klad_core::ops::PixelSpec::default()
})
}
fn pixel_preview(&self, cells: Vec<klad_core::pixel::Cell>) -> Vec<klad_core::pixel::Cell> {
let twinned = match self.mirror {
Some(axis) => klad_core::pixel::mirrored(&cells, Some((axis * 2.0).round() / 2.0), None),
None => cells,
};
let canvas = &self.scene.bundle.doc.canvas;
match canvas.wrap {
true => klad_core::pixel::wrapped(&twinned, canvas.width, canvas.height),
false => twinned,
}
}
fn erases_nothing(&self, ops: &[Op]) -> bool {
let (w, h) = self.scene.size();
let grid = klad_core::pixel::grid_of(self.scene.active_marks(), w, h);
let painted = |c: &klad_core::pixel::Cell| {
c[0] >= 0 && c[1] >= 0 && c[0] < w as i64 && c[1] < h as i64 && grid.at(c[0] as u32, c[1] as u32).is_some()
};
ops.iter().all(|op| match op {
Op::Pixel(spec) => spec.erase && !spec.cells.iter().any(painted),
_ => false,
})
}
pub(super) fn apply_pixels(&mut self, spec: klad_core::ops::PixelSpec) -> Result<()> {
let drew = spec.color.is_some();
match self.scene.bundle.settle_pixels(&[Op::Pixel(spec)]) {
Ok(ops) if self.erases_nothing(&ops) => {}
Ok(ops) => {
self.apply(ops)?;
if drew {
self.used_colour();
}
}
Err(e) => {
let why = e.chain().last().map_or_else(|| format!("{e:#}"), ToString::to_string);
self.say(Tone::Refused, why);
}
}
Ok(())
}
fn step_picked(&mut self, by: i32) -> Result<()> {
let doc = &self.scene.bundle.doc;
let sets: Vec<(String, u32, &'static str, Value)> = self.chosen_marks().map_or(Vec::new(), |(_, chosen)| {
chosen
.iter()
.filter_map(|(cel, m)| {
let fill = m.as_fill().filter(|f| f.on_grid() && !f.erases())?;
let at = fill
.entry()
.and_then(|entry| doc.swatch(entry))
.or_else(|| doc.swatch(&klad_core::color::to_hex(fill.color())))?;
let to = doc.ramp_step(at, by)?;
Some((cel.clone(), m.id(), "color", json!(to.to_string())))
})
.collect()
});
if sets.is_empty() {
self.say(
Tone::Refused,
match by > 0 {
true => "nothing to step lighter: these colours are in no ramp, or at its light end (the ramp button makes one)",
false => "nothing to step darker: these colours are in no ramp, or at its dark end (the ramp button makes one)",
},
);
return Ok(());
}
self.set_picked(sets)
}
fn fill_pixels(&mut self, at: klad_core::pixel::Cell) -> Result<()> {
let (w, h) = self.scene.size();
if at[0] < 0 || at[1] < 0 || at[0] >= w as i64 || at[1] >= h as i64 {
return Ok(());
}
let Some(spec) = self.pixel_spec(false) else {
return Ok(());
};
self.apply_pixels(klad_core::ops::PixelSpec {
fill: Some(at),
diagonal: self.pixel_diagonal,
reference: self.pixel_fill_all.then(|| "all".to_string()),
..spec
})
}
pub(super) fn pixel_shape_spec(&self) -> Option<klad_core::ops::PixelSpec> {
let (a, b) = self.shapes.drag?;
let (a, b) = (klad_core::pixel::cell_at(a.x, a.y), klad_core::pixel::cell_at(b.x, b.y));
let b = match (self.modifiers.shift, self.pixel_shape) {
(true, PixelShape::Rect | PixelShape::Ellipse) => {
let side = (b[0] - a[0]).abs().max((b[1] - a[1]).abs());
let sign = |v: i64| if v < 0 { -1 } else { 1 };
[a[0] + side * sign(b[0] - a[0]), a[1] + side * sign(b[1] - a[1])]
}
_ => b,
};
let bounds = [
a[0].min(b[0]),
a[1].min(b[1]),
(b[0] - a[0]).abs() + 1,
(b[1] - a[1]).abs() + 1,
];
let spec = self.pixel_spec(false)?;
Some(match self.pixel_shape {
PixelShape::Rect => klad_core::ops::PixelSpec {
rect: Some(bounds),
filled: self.pixel_filled,
size: self.pixel_size,
..spec
},
PixelShape::Ellipse => klad_core::ops::PixelSpec {
ellipse: Some(bounds),
filled: self.pixel_filled,
size: self.pixel_size,
..spec
},
PixelShape::Line => klad_core::ops::PixelSpec {
line: Some([a[0], a[1], b[0], b[1]]),
size: self.pixel_size,
..spec
},
})
}
fn finish_pixels(&mut self) -> Result<()> {
let Some(live) = self.pixel_live.take() else {
return Ok(());
};
self.pixel_last = live.run.last().copied();
let cells = self.pixel_cells(&live);
let Some(spec) = self.pixel_spec(live.erase).filter(|_| !cells.is_empty()) else {
return Ok(());
};
self.apply_pixels(klad_core::ops::PixelSpec { cells, ..spec })
}
fn finish_fill(&mut self) -> Result<()> {
let Some(lasso) = self.lasso.take() else {
return Ok(());
};
let start = Instant::now();
let (w, h) = self.scene.size();
let (source, coverage) = if lasso.far && lasso.points.len() >= 3 {
let points: Vec<[f32; 2]> = lasso.points.iter().map(|p| [p.x, p.y]).collect();
let coverage = polygon(&points, w, h);
(FillSource::Polygon(points), coverage)
} else {
let at = lasso.points[0];
let seed = Seed {
x: at.x,
y: at.y,
tolerance: self.fill.tolerance,
gap: self.fill.gap,
expand: self.fill.expand,
};
let reference = self.fill_reference();
let image = self.scene.fill_reference(&reference, &self.brushes)?;
let coverage = flood(&image, &seed);
(FillSource::Seed { seed, reference }, coverage)
};
let computed = ms(start);
if coverage.is_empty() {
self.say(
Tone::Refused,
"nothing to fill there: click inside closed lines, or raise the gap so small openings close",
);
return Ok(());
}
if self.external.is_some() {
self.reload()?;
}
let pixels = coverage.pixels();
let lassoed = matches!(source, FillSource::Polygon(_));
let mut fill = Fill::new(self.scene.next_mark_id(), self.color, source, coverage);
fill.opacity = self.fill.opacity;
fill.lock = self.scene.active_locks_alpha();
let committing = Instant::now();
let touched = self.scene.commit_fill(fill, &self.brushes)?;
self.dirty.extend(touched);
let bytes = self.scene.save_active("fill")?;
self.first.filled = true;
self.used_colour();
let text = format!(
"{}: {pixels} px computed in {computed:.0} ms, painted and saved in {:.0} ms\nlayer file {bytes} B",
if lassoed { "lasso fill" } else { "fill" },
ms(committing)
);
self.measure("fill", text);
Ok(())
}
fn navigate(&mut self, ui: &egui::Ui, response: &egui::Response, rect: Rect) {
let area = rect.size();
let (zoom, scroll, rotation, hover, space, middle, primary, delta, time) = ui.input(|i| {
(
i.zoom_delta(),
i.smooth_scroll_delta,
i.rotation_delta(),
i.pointer.hover_pos(),
i.key_down(Key::Space),
i.pointer.middle_down(),
i.pointer.primary_down(),
i.pointer.delta(),
i.time,
)
});
self.navigating = (space && !ui.ctx().egui_wants_keyboard_input()) || middle;
let Some(view) = self.view.as_mut() else {
return;
};
let at = hover.filter(|p| rect.contains(*p)).map_or(area / 2.0, |p| p - rect.min);
if response.hovered() || response.dragged() {
if zoom != 1.0 && self.scene.bundle.doc.pixel_art() {
let wanted = (self.zoom_wanted.unwrap_or(view.zoom) * zoom).clamp(0.02, 64.0);
self.zoom_wanted = Some(wanted);
let target = View::whole(wanted, ui.ctx().pixels_per_point());
if target != view.zoom {
view.zoom_at(target / view.zoom, at, area);
}
} else if zoom != 1.0 {
view.zoom_at(zoom, at, area);
}
if scroll != Vec2::ZERO {
view.pan(scroll);
}
if rotation != 0.0 {
view.rotate_at(rotation, at, area);
}
}
if self.navigating && (middle || primary) && self.live.is_none() {
view.pan(delta);
}
if self.spin {
view.rotate_at(0.01, area / 2.0, area);
view.zoom_at(1.0 + 0.012 * (time as f32 * 1.5).sin(), area / 2.0, area);
ui.ctx().request_repaint();
}
}
fn canvas(&mut self, ui: &mut egui::Ui) -> Result<()> {
let rect = ui.max_rect();
let response = ui.allocate_rect(rect, Sense::click_and_drag());
self.canvas_rect = rect;
let area = rect.size();
let canvas = self.canvas_size();
if self.view.is_none() {
self.view = Some(self.fitted(area));
}
self.navigate(ui, &response, rect);
self.keep_typing_focus(ui, &response)?;
self.typing_keys(ui)?;
self.pen_keys(ui)?;
self.bone_keys(ui);
self.shift_keys(ui)?;
self.command_keys(ui)?;
let ctx = ui.ctx().clone();
let was_focused = self.focused;
self.focused = ctx.input(|i| i.focused);
self.modifiers = ctx.input(|i| i.modifiers);
self.refresh_shape();
let events = match &self.pen {
Some(pen) => pen.drain(ctx.content_rect().height()),
None => pen::from_egui(&ui.input(|i| i.events.clone())),
};
let holding = self.writing() && matches!(self.tool, Tool::Select | Tool::Direct);
self.held
.admit(holding, events)
.into_iter()
.try_for_each(|e| self.on_pen(&ctx, e, rect, was_focused))?;
if self.tool == Tool::Bone && response.secondary_clicked() {
self.end_chain();
}
if self.tool == Tool::Note
&& response.secondary_clicked()
&& let (Some(p), Some(view)) = (response.interact_pointer_pos(), self.view)
{
self.select_pin(view.to_canvas(p - rect.min, rect.size()))?;
}
let view = self.view.unwrap_or_else(|| self.fitted(area));
self.double_click_text(&response, view, rect)?;
self.zoom_px = view.zoom * ctx.pixels_per_point();
self.refresh_box();
self.refresh_cut();
self.refresh_shape();
self.tend_path()?;
let level = match self.zoom_px >= 1.0 {
true => 0,
false => (1.0 / self.zoom_px).log2().floor().clamp(0.0, 4.0) as u32,
};
self.frames.set_level(level);
let show = self.tend_frames()?;
let view_uniform = view.uniform(area, ctx.pixels_per_point(), canvas, self.scene.bundle.doc.canvas.wrap);
let (w, h) = self.scene.size();
let visible = self.visible_tiles(view, rect);
let previewed = self.tend_preview(visible)?;
let mut tiles = std::mem::take(&mut self.dirty);
if let Some(state) = self.preview.as_ref() {
let held: BTreeSet<usize> = tiles.intersection(&state.shown).copied().collect();
tiles.retain(|i| !held.contains(i));
self.dirty.extend(held);
}
let mut stroke: Vec<usize> = self.buffer.take_dirty();
stroke.extend(self.mirror_buffer.take_dirty());
if !self.canvas_current() {
self.dirty.extend(std::mem::take(&mut tiles));
self.dirty.extend(stroke.drain(..));
}
let refill = self.live.is_none() && tiles.len() > self.batch;
if refill {
let later = tiles.split_off(&tiles.iter().nth(self.batch).copied().unwrap_or(usize::MAX));
self.dirty.extend(later);
ctx.request_repaint();
}
let tiles: Vec<usize> = tiles.into_iter().collect();
let start = Instant::now();
let preview = self.live.as_ref().map(|l| Preview {
twin: l.twin.as_ref().map(|_| &self.mirror_buffer),
buffer: &self.buffer,
color: l.stroke.color(),
opacity: l.stroke.opacity,
blend: stroke_blend(&l.brush, l.stroke.lock).unwrap_or(l.brush.blend),
});
let uploads = if tiles.is_empty() && stroke.is_empty() {
Vec::new()
} else {
self.scene.compose_painting(&stroke, &tiles, preview.as_ref())?
};
if !uploads.is_empty() {
let spent = ms(start);
if refill {
self.batch = ((uploads.len() as f64 * REFILL_MS / spent.max(0.1)) as usize).clamp(8, timeline::FILL);
}
let mut stats = lock(&self.stats);
stats.compose_ms.push(spent as f32);
stats.tiles.push(uploads.len() as f32);
}
let uploads: Tiles = previewed.into_iter().chain(uploads).collect();
if !uploads.is_empty() {
self.painted += 1;
}
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(
rect,
CanvasPaint {
show: show.filter(|_| self.preview.is_none()),
outbox: self.outbox.clone(),
uniform: view_uniform,
size: (w, h),
cols: self.scene.cols(),
pending: self.pending.take(),
stats: self.stats.clone(),
},
));
self.parallax(ui, view, rect);
self.prepare_typing(&ctx, view, rect);
let hover = ui
.input(|i| i.pointer.hover_pos())
.filter(|p| rect.contains(*p))
.map(|p| view.to_canvas(p - rect.min, rect.size()));
self.hover_cell = hover
.filter(|_| self.scene.bundle.doc.pixel_art())
.filter(|p| p.x >= 0.0 && p.y >= 0.0 && p.x < canvas.x && p.y < canvas.y)
.map(|p| [p.x.floor() as i32, p.y.floor() as i32]);
self.decorate_grid(ui, view, rect);
self.decorate(ui, view, rect);
let painter = ui.painter().with_clip_rect(rect);
self.decorate_bones(&painter, |c| rect.min + view.to_screen(c, rect.size()), hover);
if self.live.is_some()
|| self.lasso.is_some()
|| self.drag.is_some()
|| self.point_drag.is_some()
|| self.path_commit.is_some()
|| self
.preview
.as_ref()
.is_some_and(|p| p.job.is_some() || p.finish.is_some())
{
ctx.request_repaint();
}
self.share_selection();
Ok(())
}
pub(super) fn fitted(&self, area: Vec2) -> View {
match self.scene.bundle.doc.pixel_art() {
true => View::fit_whole(self.canvas_size(), area, self.ctx.pixels_per_point()),
false => View::fit(self.canvas_size(), area),
}
}
pub(super) fn grid_shows(&self) -> bool {
self.settings.pixel_grid && self.zoom_px >= GRID_FROM && self.scene.bundle.doc.pixel_art()
}
fn decorate_grid(&self, ui: &egui::Ui, view: View, rect: Rect) {
let painter = ui.painter().with_clip_rect(rect);
let canvas = self.canvas_size();
if self.grid_shows() {
let corners = [
rect.left_top(),
rect.right_top(),
rect.right_bottom(),
rect.left_bottom(),
]
.map(|p| view.to_canvas(p - rect.min, rect.size()));
let low = |f: fn(&Vec2) -> f32| corners.iter().map(f).fold(f32::MAX, f32::min);
let high = |f: fn(&Vec2) -> f32| corners.iter().map(f).fold(f32::MIN, f32::max);
let (x0, x1) = (low(|p| p.x).floor().max(0.0), high(|p| p.x).ceil().min(canvas.x));
let (y0, y1) = (low(|p| p.y).floor().max(0.0), high(|p| p.y).ceil().min(canvas.y));
let dark = egui::Stroke::new(1.0, Color32::from_black_alpha(70));
let light = egui::Stroke::new(1.0, Color32::from_white_alpha(90));
let to_screen = |x: f32, y: f32| self.screen(view, rect, vec2(x, y));
let rule = |a: Pos2, b: Pos2| {
painter.line_segment([a, b], dark);
painter.extend(egui::Shape::dashed_line(&[a, b], light, 2.0, 2.0));
};
(x0 as i32..=x1 as i32)
.map(|x| x as f32)
.for_each(|x| rule(to_screen(x, y0), to_screen(x, y1)));
(y0 as i32..=y1 as i32)
.map(|y| y as f32)
.for_each(|y| rule(to_screen(x0, y), to_screen(x1, y)));
}
if let Some([tile_width, tile_height]) = self.scene.bundle.doc.canvas.tile {
let edge = egui::Stroke::new(1.5, Color32::from_black_alpha(150));
let glow = egui::Stroke::new(1.0, Color32::from_white_alpha(140));
let to_screen = |x: f32, y: f32| self.screen(view, rect, vec2(x, y));
let rule = |a: Pos2, b: Pos2| {
painter.line_segment([a, b], edge);
painter.extend(egui::Shape::dashed_line(&[a, b], glow, 4.0, 4.0));
};
(0..=(canvas.x as u32 / tile_width.max(1)))
.map(|column| (column * tile_width) as f32)
.for_each(|x| rule(to_screen(x, 0.0), to_screen(x, canvas.y)));
(0..=(canvas.y as u32 / tile_height.max(1)))
.map(|row| (row * tile_height) as f32)
.for_each(|y| rule(to_screen(0.0, y), to_screen(canvas.x, y)));
}
let shaped = self
.pixel_shape_spec()
.filter(|_| self.tool == Tool::Shape && self.scene.on_grid())
.and_then(|spec| {
klad_core::ops::PixelSpec {
shade: None,
dither: None,
..spec.clone()
}
.drawn()
.ok()
.map(|cells| (self.pixel_preview(cells), spec.erase))
});
let drawing = self
.pixel_live
.as_ref()
.map(|live| (self.pixel_preview(self.pixel_cells(live)), live.erase))
.or(shaped);
if let Some((cells, erase)) = drawing {
let shading = !erase && self.pixel_mode != PixelMode::Draw;
let dither = (!erase && !shading && self.pixel_dither < 100).then_some(self.pixel_dither);
cells.iter().for_each(|c| {
let fill = match (erase, self.pixel_mode, dither) {
(true, _, _) => Color32::from_rgba_unmultiplied(255, 255, 255, 120),
(false, PixelMode::Lighter, _) => Color32::from_white_alpha(90),
(false, PixelMode::Darker, _) => Color32::from_black_alpha(90),
(false, PixelMode::Draw, Some(percent)) if !klad_core::pixel::dithered(*c, percent) => {
match self.pixel_two {
true => color::color32(self.second),
false => Color32::TRANSPARENT,
}
}
(false, PixelMode::Draw, _) => color::color32(self.color),
};
let (x, y) = (c[0] as f32, c[1] as f32);
let corners = [(x, y), (x + 1.0, y), (x + 1.0, y + 1.0), (x, y + 1.0)]
.map(|(x, y)| self.screen(view, rect, vec2(x, y)))
.to_vec();
painter.add(egui::Shape::convex_polygon(corners, fill, egui::Stroke::NONE));
});
}
let pencil = self.tool == Tool::Brush && self.scene.on_grid();
if let Some([x, y]) = self.hover_cell.filter(|_| self.scene.on_grid() && self.zoom_px >= 3.0) {
let side = if pencil { self.pixel_size.max(1) as f32 } else { 1.0 };
let low = ((side - 1.0) / 2.0).floor();
let (x, y) = (x as f32 - low, y as f32 - low);
let cell = [(x, y), (x + side, y), (x + side, y + side), (x, y + side)]
.map(|(x, y)| self.screen(view, rect, vec2(x, y)))
.to_vec();
painter.add(egui::Shape::closed_line(
cell.clone(),
egui::Stroke::new(3.0, Color32::from_black_alpha(150)),
));
painter.add(egui::Shape::closed_line(cell, egui::Stroke::new(1.0, Color32::WHITE)));
}
}
fn decorate(&self, ui: &egui::Ui, view: View, rect: Rect) {
let painter = ui.painter().with_clip_rect(rect);
let accent = Color32::from_rgb(64, 196, 255);
let dark = egui::Stroke::new(3.0, Color32::from_black_alpha(140));
if let Some(picked) = self.picked.as_ref().filter(|_| self.on_marks()) {
let thin = egui::Stroke::new(1.0, accent);
let moving = self.drag.as_ref().filter(|d| d.strokes && d.moved()).map(Drag::affine);
let to_screen = |x: f32, y: f32| {
let (x, y) = moving.map_or((x, y), |a| lift::affine_apply(a, (x, y)));
self.screen(view, rect, vec2(x, y))
};
let parts = self.picked_parts();
let chosen = parts
.iter()
.flat_map(|(_, _, marks, ids)| marks.iter().filter(|m| ids.contains(&m.id())));
chosen.for_each(|m| match m {
Mark::Stroke(s) => {
let points: Vec<(f32, f32)> = s.samples.iter().map(|v| v.pos()).collect();
points
.chunk_by(|a, b| klad_core::cut::keeps(&s.cuts, *a) == klad_core::cut::keeps(&s.cuts, *b))
.filter(|run| klad_core::cut::keeps(&s.cuts, run[0]))
.for_each(|run| {
let line: Vec<Pos2> = run.iter().map(|&(x, y)| to_screen(x, y)).collect();
painter.add(egui::Shape::line(line, thin));
});
}
Mark::Fill(f) => {
if let Some([x0, y0, x1, y1]) = m.bounds().or(f.bounds()) {
let corners = [(x0, y0), (x1, y0), (x1, y1), (x0, y1)].map(|(x, y)| to_screen(x, y));
painter.add(egui::Shape::closed_line(corners.to_vec(), thin));
}
}
});
if let Some(polygon) = &picked.cut {
let line: Vec<Pos2> = polygon.iter().map(|p| to_screen(p[0], p[1])).collect();
painter.add(egui::Shape::dashed_line(
&[line.clone(), line[..1].to_vec()].concat(),
egui::Stroke::new(1.5, accent),
6.0,
4.0,
));
}
}
if self.tool == Tool::Direct {
self.decorate_points(&painter, view, rect, accent);
self.decorate_point_box(&painter, view, rect, accent, dark);
}
self.decorate_shape(&painter, &|x, y| self.screen(view, rect, vec2(x, y)), accent);
self.decorate_typing(&painter, view, rect, accent);
let mirrors =
self.tool == Tool::Brush || (self.scene.on_grid() && matches!(self.tool, Tool::Shape | Tool::Fill));
if let Some(axis) = self.mirror.filter(|_| mirrors) {
let h = self.scene.size().1 as f32;
painter.add(egui::Shape::dashed_line(
&[
self.screen(view, rect, vec2(axis, 0.0)),
self.screen(view, rect, vec2(axis, h)),
],
egui::Stroke::new(1.0, accent),
8.0,
6.0,
));
}
if let Some(path) = self.pen_path.as_ref() {
let hover = ui.input(|i| i.pointer.hover_pos());
self.decorate_pen(&painter, path, hover, view, rect, accent, dark);
}
if let Some((_, corners)) = self.handles() {
if self.drag.is_none() && self.tool == Tool::Select && !self.on_marks() {
self.group_boxes.iter().for_each(|member| {
let outline: Vec<Pos2> = member.iter().map(|c| self.screen(view, rect, *c)).collect();
painter.add(egui::Shape::closed_line(outline, egui::Stroke::new(1.0, accent)));
});
}
let corners = match &self.drag {
Some(drag) => drag.preview(),
None => corners,
};
let screen: Vec<Pos2> = corners.iter().map(|c| self.screen(view, rect, *c)).collect();
painter.add(egui::Shape::closed_line(screen.clone(), dark));
painter.add(egui::Shape::closed_line(screen.clone(), egui::Stroke::new(1.5, accent)));
screen.iter().for_each(|p| {
painter.rect_filled(Rect::from_center_size(*p, vec2(HANDLE, HANDLE)), 1.0, Color32::WHITE);
painter.rect_stroke(
Rect::from_center_size(*p, vec2(HANDLE, HANDLE)),
1.0,
egui::Stroke::new(1.0, accent),
egui::StrokeKind::Middle,
);
});
if self.edges() {
let flat = [0, 1, 2, 3].map(|i| screen[i].to_vec2());
(0..4).for_each(|side| {
let p = edge(&flat, side).to_pos2();
painter.circle_filled(p, HANDLE / 2.0 - 0.5, Color32::WHITE);
painter.circle_stroke(p, HANDLE / 2.0 - 0.5, egui::Stroke::new(1.0, accent));
});
}
let top = screen[0].lerp(screen[1], 0.5);
let center = screen.iter().fold(Vec2::ZERO, |a, p| a + p.to_vec2()) / 4.0;
let knob = top + (top.to_vec2() - center).normalized() * KNOB;
painter.line_segment([top, knob], egui::Stroke::new(1.5, accent));
painter.circle_filled(knob, HANDLE / 2.0 + 1.0, Color32::WHITE);
painter.circle_stroke(knob, HANDLE / 2.0 + 1.0, egui::Stroke::new(1.0, accent));
}
self.draw_pins(&painter, |c| self.screen(view, rect, c));
self.draw_checks(&painter, |c| self.screen(view, rect, c));
if let Some(lasso) = self.lasso.as_ref().filter(|l| l.far) {
let line: Vec<Pos2> = self
.lasso_outline(lasso)
.iter()
.map(|p| self.screen(view, rect, *p))
.collect();
let tint = if matches!(self.tool, Tool::Strokes | Tool::Select) {
accent
} else {
color::color32(self.color)
};
painter.add(egui::Shape::closed_line(line.clone(), dark));
painter.add(egui::Shape::closed_line(line, egui::Stroke::new(1.5, tint)));
}
let hover = ui.input(|i| i.pointer.hover_pos()).filter(|p| rect.contains(*p));
if let Some(hover) = hover.filter(|_| self.modifiers.alt && matches!(self.tool, Tool::Brush | Tool::Fill)) {
painter.circle_stroke(hover, 9.0, egui::Stroke::new(3.0, Color32::from_black_alpha(160)));
painter.circle_stroke(hover, 9.0, egui::Stroke::new(1.5, Color32::WHITE));
painter.circle_filled(hover, 5.0, color::color32(self.color));
return;
}
if self.tool == Tool::Fill
&& let Some(hover) = hover
{
let arm = |d: Vec2| [hover + d * 3.0, hover + d * 9.0];
[vec2(1.0, 0.0), vec2(-1.0, 0.0), vec2(0.0, 1.0), vec2(0.0, -1.0)]
.iter()
.for_each(|d| {
painter.line_segment(arm(*d), egui::Stroke::new(3.0, Color32::from_black_alpha(160)));
painter.line_segment(arm(*d), egui::Stroke::new(1.5, Color32::WHITE));
});
}
if let Some((_, _, origin)) = self.sizing {
let radius = (self.size * 0.5 * view.zoom).max(1.5);
painter.circle_stroke(origin, radius, egui::Stroke::new(1.0, Color32::from_gray(30)));
painter.circle_stroke(origin, radius + 1.0, egui::Stroke::new(1.0, Color32::from_gray(235)));
painter.text(
origin + vec2(radius + 8.0, 0.0),
egui::Align2::LEFT_CENTER,
format!("{:.1} px", self.size),
egui::FontId::proportional(13.0),
Color32::WHITE,
);
return;
}
if self.tool == Tool::Brush
&& let Some(hover) = hover
{
let radius = (self.size * 0.5 * view.zoom).max(1.5);
painter.circle_stroke(hover, radius, egui::Stroke::new(1.0, Color32::from_gray(30)));
painter.circle_stroke(hover, radius + 1.0, egui::Stroke::new(1.0, Color32::from_gray(235)));
}
}
fn decorate_points(&self, painter: &egui::Painter, view: View, rect: Rect, accent: Color32) {
let (Some(shaped), Some(direct)) = (self.shaped.as_ref(), self.direct.as_ref()) else {
return;
};
let Some(subs) = self.shown_subs() else {
return;
};
let m = shaped.matrix;
let screen = |p: [f32; 2]| self.screen(view, rect, to_canvas(m, p));
let thin = egui::Stroke::new(1.0, accent);
let none = BTreeSet::new();
self.shown_also().iter().for_each(|shown| {
self.outline_points(painter, view, rect, accent, &shown.subs, shown.matrix);
let chosen = direct.also.get(&shown.node).unwrap_or(&none);
self.square_points(painter, view, rect, accent, &shown.subs, shown.matrix, chosen);
});
self.outline_points(painter, view, rect, accent, &subs, m);
let anchors = pathedit::anchors(&subs);
direct.points.iter().filter_map(|&i| anchors.get(i)).for_each(|(_, a)| {
let at = screen(a.at);
[(a.inn, a.has_in()), (a.out, a.has_out())]
.into_iter()
.filter(|(_, has)| *has)
.for_each(|(p, _)| {
let h = screen(p);
painter.line_segment([at, h], thin);
painter.circle_filled(h, HANDLE / 2.0 - 0.5, Color32::WHITE);
painter.circle_stroke(h, HANDLE / 2.0 - 0.5, thin);
});
});
self.square_points(painter, view, rect, accent, &subs, m, &direct.points);
}
fn point_box(&self) -> Option<(Vec2, Vec2)> {
self.point_drag
.filter(|d| matches!(d.grab, PointGrab::Marquee { .. }))
.map(|d| (d.start, d.now))
}
fn decorate_point_box(&self, painter: &egui::Painter, view: View, rect: Rect, accent: Color32, dark: egui::Stroke) {
let Some((start, now)) = self.point_box() else {
return;
};
let area = Rect::from_two_pos(self.screen(view, rect, start), self.screen(view, rect, now));
painter.rect_filled(area, 0.0, accent.gamma_multiply(0.12));
painter.rect_stroke(area, 0.0, dark, egui::StrokeKind::Outside);
painter.rect_stroke(area, 0.0, egui::Stroke::new(1.5, accent), egui::StrokeKind::Middle);
}
fn outline_points(
&self,
painter: &egui::Painter,
view: View,
rect: Rect,
accent: Color32,
subs: &[Subpath],
m: [f32; 6],
) {
let screen = |p: [f32; 2]| self.screen(view, rect, to_canvas(m, p));
let step = (2.0 / (view.zoom * (m[0] * m[3] - m[1] * m[2]).abs().sqrt()).max(1e-3)).clamp(0.05, 8.0);
pathedit::flatten(subs, step).iter().zip(subs).for_each(|(line, sub)| {
let points: Vec<Pos2> = line.iter().map(|p| screen(*p)).collect();
let shape = if sub.closed {
egui::Shape::closed_line(points, egui::Stroke::new(1.5, accent))
} else {
egui::Shape::line(points, egui::Stroke::new(1.5, accent))
};
painter.add(shape);
});
}
#[allow(clippy::too_many_arguments)]
fn square_points(
&self,
painter: &egui::Painter,
view: View,
rect: Rect,
accent: Color32,
subs: &[Subpath],
m: [f32; 6],
chosen: &BTreeSet<usize>,
) {
let size = HANDLE - 2.0;
let thin = egui::Stroke::new(1.0, accent);
pathedit::anchors(subs).iter().enumerate().for_each(|(i, (_, a))| {
let at = self.screen(view, rect, to_canvas(m, a.at));
let square = Rect::from_center_size(at, vec2(size, size));
let fill = if chosen.contains(&i) { accent } else { Color32::WHITE };
painter.rect_filled(square, 0.0, fill);
painter.rect_stroke(square, 0.0, thin, egui::StrokeKind::Middle);
});
}
fn layer_shapes(&self, bounds: [f32; 4]) -> Vec<String> {
fn leaves(node: &Node, out: &mut Vec<String>) {
match &node.shape {
Shape::Group { children } => children.iter().for_each(|child| leaves(child, out)),
Shape::Rect { .. } | Shape::Ellipse { .. } | Shape::Path { .. } => out.push(node.id.clone()),
_ => {}
}
}
let doc = &self.scene.bundle.doc;
let of_cel = |nodes: &[Node]| {
let mut out = Vec::new();
nodes.iter().for_each(|node| leaves(node, &mut out));
out
};
if let Some(Loc::Node(path, c, _)) = self.direct.as_ref().and_then(|d| doc.locate(&d.node)) {
let layer = doc.layer_at(&path);
return match layer.locked {
true => Vec::new(),
false => of_cel(&layer.cels()[c].nodes),
};
}
let Some(layer) = self.scene.active_layer().filter(|l| !l.locked) else {
return Vec::new();
};
match (layer.kind(), self.scene.active_cel()) {
(Kind::Vector, _) => layer
.content_at(self.scene.frame)
.map_or(Vec::new(), |cel| of_cel(&cel.nodes)),
(_, Some(cel)) => self
.scene
.active_marks()
.iter()
.filter_map(|m| m.as_stroke())
.filter(|stroke| {
stroke.samples.iter().any(|sample| {
let (x, y) = sample.pos();
x >= bounds[0] && y >= bounds[1] && x <= bounds[2] && y <= bounds[3]
})
})
.map(|stroke| markedit::address(&cel, stroke.id))
.collect(),
_ => Vec::new(),
}
}
fn chosen_marks(&self) -> Option<(Picked, Vec<(String, Mark)>)> {
let picked = self.picked.clone()?;
let parts = self.picked_parts();
if parts.is_empty() {
return None;
}
let chosen = parts
.iter()
.flat_map(|(_, cel, marks, ids)| {
marks
.iter()
.filter(|m| ids.contains(&m.id()))
.map(|m| (cel.clone(), m.clone()))
})
.collect();
Some((picked, chosen))
}
fn set_picked(&mut self, sets: Vec<(String, u32, &'static str, Value)>) -> Result<()> {
let Some(picked) = self.picked.clone().filter(|_| !sets.is_empty()) else {
return Ok(());
};
let start = Instant::now();
let (mut ops, after) = match &picked.cut {
Some(_) => self
.picked_ops(LassoAction::Transform(MarkTransform::default()))
.ok_or_else(|| anyhow!("the selection changed underneath: select the strokes again"))?,
None => (Vec::new(), Some(picked.clone())),
};
ops.extend(sets.into_iter().map(|(cel, id, key, value)| Op::Set {
id: address(&cel, id),
props: Map::from_iter([(key.to_string(), value)]),
}));
self.apply(ops)?;
self.picked = after;
self.forget_missing_selection();
self.measure("stroke edit", format!("stroke edit redrawn in {:.0} ms", ms(start)));
Ok(())
}
pub(super) fn recolourable(&self) -> Option<String> {
let id = self
.selection
.clone()
.or_else(|| self.direct.as_ref().map(|d| d.node.clone()))?;
match self.scene.bundle.doc.item(&id) {
Some(Item::Node(_, _, node))
if matches!(
node.shape,
Shape::Rect { .. } | Shape::Ellipse { .. } | Shape::Path { .. } | Shape::Text(_)
) =>
{
Some(id)
}
_ => None,
}
}
fn recolour_shape(&mut self, outline: bool) -> Result<()> {
let Some(id) = self.recolourable() else {
return Ok(());
};
let hex = color::hex(self.color);
let has_outline = matches!(
self.scene.bundle.doc.item(&id),
Some(Item::Node(_, _, node)) if node.stroke.is_some()
);
let props = match (outline, has_outline) {
(false, _) => json!({"fill": hex}),
(true, true) => json!({"stroke.paint": hex}),
(true, false) => json!({"stroke": {"paint": hex, "width": self.pen_width}}),
};
let props = props.as_object().cloned().unwrap_or_default();
self.apply(vec![Op::Set { id, props }])
}
pub(super) fn solo(&mut self, id: &str) -> Result<()> {
let ops = match self.soloed.take() {
Some((was, before)) if was == id => before
.into_iter()
.filter(|(layer, visible)| {
self.scene
.bundle
.doc
.layer(layer)
.is_some_and(|l| l.visible != *visible)
})
.map(|(layer, visible)| Op::Set {
id: layer,
props: Map::from_iter([("visible".to_string(), json!(visible))]),
})
.collect(),
_ => {
let before = self
.scene
.bundle
.doc
.all_layers()
.iter()
.map(|l| (l.id.clone(), l.visible))
.collect();
let ops = klad_core::ops::solo(&self.scene.bundle.doc, id)?;
self.soloed = Some((id.to_string(), before));
ops
}
};
if ops.is_empty() {
return Ok(());
}
self.apply(ops)
}
fn recolour_picked(&mut self) -> Result<()> {
let target = self.color;
let sets = self.chosen_marks().map_or(Vec::new(), |(_, chosen)| {
let colours: Vec<_> = chosen.iter().map(|(_, m)| m.color()).collect();
klad_core::color::recolour(&colours, target)
.into_iter()
.zip(&chosen)
.map(|(shade, (cel, m))| {
let colour = match m.as_fill().is_some_and(|f| f.on_grid()) {
true => target,
false => shade,
};
(cel.clone(), m.id(), "color", json!(klad_core::color::to_hex(colour)))
})
.collect()
});
self.set_picked(sets)
}
fn select_same_colour(&mut self) {
let Some(cel) = self.scene.active_cel() else {
return;
};
let marks = self.scene.active_marks();
let key = |m: &Mark| {
m.as_fill().filter(|f| f.on_grid() && !f.erases()).map(|f| {
f.entry()
.map_or_else(|| klad_core::color::to_hex(f.color()), String::from)
})
};
let held: Vec<u32> = self
.picked
.as_ref()
.filter(|p| p.cel == cel)
.map_or(Vec::new(), |p| p.ids.clone());
let wanted: BTreeSet<String> = match held.is_empty() {
false => marks
.iter()
.filter(|m| held.contains(&m.id()))
.filter_map(key)
.collect(),
true => {
let current = klad_core::color::to_hex(self.color);
marks
.iter()
.filter(|m| klad_core::color::to_hex(m.color()).eq_ignore_ascii_case(¤t))
.filter_map(key)
.collect()
}
};
let ids: Vec<u32> = marks
.iter()
.filter(|m| key(m).is_some_and(|k| wanted.contains(&k)))
.map(Mark::id)
.collect();
match ids.is_empty() {
true => self.say(
Tone::Info,
"no pixels of this drawing have that colour: click a palette colour, or select a mark first",
),
false => {
let count = ids.len();
self.tool = Tool::Strokes;
self.picked = Some(Picked::whole(cel, ids));
self.say(Tone::Done, format!("{count} marks of that colour selected"));
}
}
}
fn attached_parts(&self) -> Vec<(String, String, Vec<u32>)> {
self.picked_parts()
.into_iter()
.map(|(layer, cel, marks, ids)| {
let chosen: BTreeSet<u32> = ids.iter().copied().collect();
let attached = klad_core::stroke::strokes_of(marks)
.filter(|s| !chosen.contains(&s.id) && s.on.iter().any(|t| chosen.contains(t)))
.map(|s| s.id)
.collect();
(layer, cel, attached)
})
.collect()
}
pub(super) fn attached_count(&self) -> usize {
self.attached_parts().iter().map(|(_, _, ids)| ids.len()).sum()
}
pub(super) fn detachable(&self) -> bool {
self.attached_count() > 0
|| self.picked_parts().iter().any(|(_, _, marks, ids)| {
let live: BTreeSet<u32> = marks.iter().map(Mark::id).collect();
klad_core::stroke::strokes_of(marks)
.any(|s| ids.contains(&s.id) && s.on.iter().any(|t| live.contains(t)))
})
}
fn select_attached(&mut self) -> Result<()> {
let Some(picked) = self.picked.clone() else {
return Ok(());
};
if picked.cut.is_some() {
self.say(
Tone::Refused,
"the lasso cut has not happened yet: move or edit the strokes first, then select what is attached",
);
return Ok(());
}
let parts = self.attached_parts();
let count: usize = parts.iter().map(|(_, _, ids)| ids.len()).sum();
let mut parts = parts.into_iter();
let Some((_, cel, ids)) = parts.next() else {
return Ok(());
};
self.picked = Some(Picked {
more: parts
.filter(|(_, _, ids)| !ids.is_empty())
.map(|(layer, cel, ids)| Part { layer, cel, ids })
.collect(),
..Picked::whole(cel, ids)
});
self.say(
Tone::Done,
format!("{count} attached selected: they move and go on their own now, and attach to what they land on"),
);
Ok(())
}
fn detach_picked(&mut self) -> Result<()> {
let Some(picked) = self.picked.clone() else {
return Ok(());
};
let count = self.attached_count();
let (mut ops, after) = match &picked.cut {
Some(_) => self
.picked_ops(LassoAction::Transform(MarkTransform::default()))
.ok_or_else(|| anyhow!("the selection changed underneath: select the strokes again"))?,
None => (Vec::new(), Some(picked.clone())),
};
let ids: Vec<String> = after
.iter()
.flat_map(|p| {
std::iter::once((p.cel.clone(), p.ids.clone()))
.chain(p.more.iter().map(|m| (m.cel.clone(), m.ids.clone())))
})
.flat_map(|(cel, ids)| ids.into_iter().map(move |id| address(&cel, id)))
.collect();
ops.push(Op::Detach { ids });
self.apply(ops)?;
self.picked = after;
self.forget_missing_selection();
self.say(
Tone::Done,
format!("{count} detached: they stay where they are and act on whatever is under them"),
);
Ok(())
}
fn size_picked(&mut self, k: f32) -> Result<()> {
let sets = self.chosen_marks().map_or(Vec::new(), |(_, chosen)| {
chosen
.iter()
.filter_map(|(cel, m)| {
m.as_stroke()
.map(|s| (cel.clone(), s.id, "size", json!((s.size * k).max(0.1))))
})
.collect()
});
self.set_picked(sets)
}
fn flip_picked(&mut self, sx: f32, sy: f32) -> Result<()> {
let middle = self
.picked_corners()
.map(|(_, c)| [(c[0].x + c[2].x) / 2.0, (c[0].y + c[2].y) / 2.0]);
let start = Instant::now();
self.edit_picked(LassoAction::Transform(MarkTransform {
sx,
sy,
pivot: middle,
..Default::default()
}))?;
self.measure("stroke edit", format!("stroke edit redrawn in {:.0} ms", ms(start)));
Ok(())
}
fn select_all_strokes(&mut self) {
let ids: Vec<u32> = self.scene.active_marks().iter().map(Mark::id).collect();
let more: Vec<Part> = self
.also_cels()
.into_iter()
.map(|(layer, cel)| Part {
ids: self.scene.marks_of(&cel).iter().map(Mark::id).collect(),
layer,
cel,
})
.filter(|p| !p.ids.is_empty())
.collect();
if let Some(cel) = self.scene.active_cel().filter(|_| !ids.is_empty() || !more.is_empty()) {
self.tool = Tool::Strokes;
self.picked = Some(Picked {
more,
..Picked::whole(cel, ids)
});
}
}
fn strokes_inspector(&mut self, ui: &mut egui::Ui) -> Result<()> {
let Some((picked, chosen)) = self.chosen_marks() else {
ui.label(match self.also.is_empty() {
true => "click a stroke or drag a loop around strokes on the active paint layer (shift adds); cmd click layers in the layers panel to select on several at once".to_string(),
false => format!("click a stroke or drag a loop: it selects on the active layer and {} more (cmd clicked in the layers panel)", self.also.len()),
});
return Ok(());
};
let fills = chosen.iter().filter(|(_, m)| m.as_fill().is_some()).count();
let place = match picked.more.len() {
0 => self
.scene
.bundle
.doc
.paint_cels()
.into_iter()
.find(|(_, c)| c.id == picked.cel)
.map_or_else(String::new, |(l, c)| format!("on {}, frame {}", l.name, c.frame)),
n => format!("on {} layers", n + 1),
};
let attached = match self.attached_count() {
0 => String::new(),
n => format!(", {n} attached"),
};
ui.label(format!(
"{} strokes, {fills} fills{attached} selected {place}{}",
chosen.len() - fills,
if picked.cut.is_some() {
"\n(with the parts crossing the lasso edge)"
} else {
""
}
));
ui.small("the bar under the selection edits it; drag inside the box to move, a corner to scale, an edge to stretch (past the other edge flips), the knob to turn; arrows nudge");
ui.separator();
ui.label(format!("part: {}", self.picked_part_names().join(", ")));
let mut name = false;
ui.horizontal(|ui| {
let label = ui.label("name");
let field = ui
.add(
egui::TextEdit::singleline(&mut self.checks.part)
.desired_width(120.0)
.hint_text("leaf, near leg"),
)
.labelled_by(label.id)
.hint("the part's name; Return or the button names the selected marks");
name = ui
.button("make them this part")
.hint("name the selected marks as this part, as klad part does")
.clicked()
|| (field.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)));
});
ui.small(
"in-betweens pair marks by part and klad arcs tracks them; an empty name takes the marks out of their part",
);
if name {
self.name_part()?;
}
Ok(())
}
fn path_inspector(&mut self, ui: &mut egui::Ui) -> Result<()> {
let Some(direct) = self.direct.clone() else {
ui.label("click a stroke, path, rect or ellipse to edit its points");
return Ok(());
};
if markedit::parse_address(&direct.node).is_some() {
let points = self
.shaped
.as_ref()
.map_or(0, |s| s.subs.iter().map(|p| p.anchors.len()).sum());
ui.label(format!("a stroke: {points} points fitted to it"));
ui.small("drag a point or a handle to bend the stroke (it keeps its pressure); alt click the line adds a point; Delete removes the selected points");
return Ok(());
}
let Some(Item::Node(layer, _, node)) = self.scene.bundle.doc.item(&direct.node) else {
self.direct = None;
return Ok(());
};
let (kind, layer_name, is_path) = (
node.type_name(),
layer.name.clone(),
matches!(node.shape, Shape::Path { .. }),
);
let total = self
.shaped
.as_ref()
.map_or(0, |s| s.subs.iter().map(|p| p.anchors.len()).sum::<usize>());
ui.label(format!(
"{kind}{} on {layer_name}: {total} points, {} selected",
if node.name.is_empty() {
String::new()
} else {
format!(" \"{}\"", node.name)
},
direct.points.len()
));
if !direct.also.is_empty() {
ui.label(format!(
"and {} points on {} more on this layer: drag one to move them all",
direct.also.values().map(BTreeSet::len).sum::<usize>(),
direct.also.len()
));
}
if !is_path {
ui.label(format!("any point edit turns this {kind} into a path"));
}
if self.under.len() > 1 && self.under.contains(&direct.node) {
ui.label("under the last click (clicking the shape again steps down):");
let doc = &self.scene.bundle.doc;
let rows: Vec<(String, String)> = self
.under
.iter()
.take(12)
.map(|id| {
let what = match doc.item(id) {
Some(Item::Node(_, _, n)) => format!("{id} {} {}", n.type_name(), n.name),
_ => id.clone(),
};
(id.clone(), what)
})
.collect();
let mut pick = None;
rows.into_iter().for_each(|(id, what)| {
if ui.selectable_label(id == direct.node, what).clicked() {
pick = Some(id);
}
});
if let Some(id) = pick {
self.pick_shape(id);
return Ok(());
}
}
ui.small(
"drag points or handles; drag a box to select points of this shape, shift and drag a box for the points of every shape on the layer; drag one to move them all\n\
alt click the outline: new point; alt click a point: corner or smooth; alt drag a handle: break it",
);
if self.path_commit.is_some() {
ui.label("writing the last edit...");
}
Ok(())
}
#[allow(clippy::too_many_arguments)]
fn number(
&mut self,
ui: &mut egui::Ui,
key: &str,
label: &str,
current: f32,
range: RangeInclusive<f32>,
speed: f64,
hint: &str,
) -> Option<f32> {
let mut value = self.edits.get(key).copied().unwrap_or(current);
let response = ui
.add(egui::DragValue::new(&mut value).speed(speed).range(range).prefix(label))
.hint(hint);
if response.dragged() || response.has_focus() {
self.edits.insert(key.to_string(), value);
return None;
}
let pending = self.edits.remove(key);
if response.drag_stopped() || response.lost_focus() || response.changed() {
return Some(value);
}
pending.filter(|p| (p - current).abs() > f32::EPSILON)
}
fn text(&mut self, ui: &mut egui::Ui, key: &str, label: &str, current: &str, hint: &str) -> Option<String> {
let mut value = self.texts.get(key).cloned().unwrap_or_else(|| current.to_string());
let label = ui.label(label);
let response = ui.text_edit_singleline(&mut value).labelled_by(label.id).hint(hint);
if response.has_focus() {
self.texts.insert(key.to_string(), value);
return None;
}
self.texts.remove(key);
(response.lost_focus() && value != current).then_some(value)
}
fn node_inspector(&mut self, ui: &mut egui::Ui, id: &str) -> Result<()> {
let Some(Item::Node(layer, _, node)) = self.scene.bundle.doc.item(id) else {
self.selection = None;
return Ok(());
};
let (node, name) = (node.clone(), layer.name.clone());
ui.label(format!("{} on {name}", node.type_name()));
let mut props: Vec<(String, Value)> = Vec::new();
ui.horizontal(|ui| {
if let Some(name) = self.text(
ui,
&format!("{id}.name"),
"name",
&node.name,
"the shape's name; Return keeps it",
) {
props.push(("name".into(), json!(name)));
}
});
if let Some(paint) = self.paint_editor(ui, id, &node) {
props.push(("fill".into(), serde_json::to_value(paint)?));
}
if let Shape::Rays(rays) = &node.shape {
let changed = ui.horizontal_wrapped(|ui| self.rays_section(ui, id, rays)).inner;
if let Some(Value::Object(fields)) = changed {
props.extend(fields);
}
}
props.extend(self.shape_fields(ui, id, &node));
let t = node.transform;
ui.horizontal(|ui| {
if let Some(v) = self.number(
ui,
&format!("{id}.x"),
"x ",
t.x,
-1e5..=1e5,
1.0,
"move it across, in canvas px",
) {
props.push(("transform.x".into(), json!(v)));
}
if let Some(v) = self.number(
ui,
&format!("{id}.y"),
"y ",
t.y,
-1e5..=1e5,
1.0,
"move it down, in canvas px",
) {
props.push(("transform.y".into(), json!(v)));
}
if let Some(v) = self.number(
ui,
&format!("{id}.r"),
"rotate ",
t.rotate,
-3600.0..=3600.0,
0.5,
"turn it, in degrees clockwise",
) {
props.push(("transform.rotate".into(), json!(v)));
}
});
ui.horizontal(|ui| {
if let Some(v) = self.number(
ui,
&format!("{id}.sx"),
"sx ",
t.sx,
-100.0..=100.0,
0.01,
"scale across; negative mirrors",
) {
props.push(("transform.sx".into(), json!(v)));
}
if let Some(v) = self.number(
ui,
&format!("{id}.sy"),
"sy ",
t.sy,
-100.0..=100.0,
0.01,
"scale up and down; negative mirrors",
) {
props.push(("transform.sy".into(), json!(v)));
}
});
ui.horizontal(|ui| {
if let Some(v) = self.number(
ui,
&format!("{id}.o"),
"opacity ",
node.opacity,
0.0..=1.0,
0.01,
"the shape's opacity",
) {
props.push(("opacity".into(), json!(v)));
}
if let Some(v) = self.number(
ui,
&format!("{id}.b"),
"blur ",
node.blur,
0.0..=200.0,
0.2,
"soften the whole shape, in px",
) {
props.push(("blur".into(), json!(v)));
}
});
let mut remove = false;
ui.horizontal(|ui| {
let mut visible = node.visible;
if ui
.checkbox(&mut visible, "visible")
.hint("show or hide this shape")
.changed()
{
props.push(("visible".into(), json!(visible)));
}
remove = ui.button("delete").hint("remove this shape (Delete)").clicked();
if ui.button("deselect").hint("clear the selection (Esc)").clicked() {
self.selection = None;
}
});
self.set(id, props)?;
if remove {
self.selection = None;
self.apply(vec![Op::Remove {
ids: vec![id.to_string()],
}])?;
return Ok(());
}
self.animation_section(ui, id)
}
fn paint_editor(&mut self, ui: &mut egui::Ui, id: &str, node: &Node) -> Option<Paint> {
let first = |stops: &[Stop]| stops.first().map_or("#000000".to_string(), |s| s.1.clone());
let (kind, base) = match &node.fill {
Some(Paint::Solid(hex)) if hex == "none" => ("none", "#000000".to_string()),
Some(Paint::Solid(hex)) => ("solid", hex.clone()),
None => ("solid", "#000000".to_string()),
Some(Paint::Linear { linear }) => ("linear", first(&linear.stops)),
Some(Paint::Radial { radial }) => ("radial", first(&radial.stops)),
};
let mut chosen = kind;
let mut out: Option<Paint> = None;
ui.horizontal(|ui| {
ui.label("fill");
egui::ComboBox::from_id_salt(format!("{id}.fillkind"))
.selected_text(kind)
.show_ui(ui, |ui| {
["none", "solid", "linear", "radial"].iter().for_each(|k| {
ui.selectable_value(&mut chosen, *k, *k);
});
})
.response
.hint("no fill, one colour, or a linear or radial gradient");
if kind == "solid" {
let mut colour = color_of(&base).unwrap_or(Color32::BLACK);
if egui::color_picker::color_edit_button_srgba(ui, &mut colour, egui::color_picker::Alpha::OnlyBlend)
.hint("the fill colour")
.changed()
{
out = Some(Paint::Solid(hex_of(colour)));
}
if ui
.button("use brush colour")
.hint("fill it with the current colour")
.clicked()
{
out = Some(Paint::Solid(color::hex(self.color)));
}
}
});
if chosen != kind {
let [x, y, w, h] = klad_render::vector::local_bounds(node)
.ok()
.flatten()
.map_or([0.0, 0.0, 100.0, 100.0], |r| [r.left, r.top, r.width(), r.height()]);
let stops = vec![Stop(0.0, base.clone()), Stop(1.0, "#ffffff".into())];
return Some(match chosen {
"none" => Paint::Solid("none".into()),
"solid" => Paint::Solid(base),
"linear" => Paint::Linear {
linear: Linear {
from: [x + w / 2.0, y],
to: [x + w / 2.0, y + h],
stops,
},
},
_ => Paint::Radial {
radial: Radial {
center: [x + w / 2.0, y + h / 2.0],
radius: (w.max(h) / 2.0).max(1.0),
stops,
},
},
});
}
match &node.fill {
Some(Paint::Linear { linear }) => {
let mut next = linear.clone();
let mut changed = false;
ui.horizontal(|ui| {
[("fx", 0, "from x "), ("fy", 1, "y ")]
.iter()
.for_each(|(k, c, label)| {
if let Some(v) = self.number(
ui,
&format!("{id}.g.{k}"),
label,
linear.from[*c],
-1e5..=1e5,
1.0,
"where the gradient starts, in the shape's own px",
) {
next.from[*c] = v;
changed = true;
}
});
});
ui.horizontal(|ui| {
[("tx", 0, "to x "), ("ty", 1, "y ")].iter().for_each(|(k, c, label)| {
if let Some(v) = self.number(
ui,
&format!("{id}.g.{k}"),
label,
linear.to[*c],
-1e5..=1e5,
1.0,
"where the gradient ends, in the shape's own px",
) {
next.to[*c] = v;
changed = true;
}
});
});
if let Some(stops) = self.stops_editor(ui, id, &linear.stops) {
next.stops = stops;
changed = true;
}
changed.then_some(Paint::Linear { linear: next }).or(out)
}
Some(Paint::Radial { radial }) => {
let mut next = radial.clone();
let mut changed = false;
ui.horizontal(|ui| {
[("cx", 0, "centre x "), ("cy", 1, "y ")]
.iter()
.for_each(|(k, c, label)| {
if let Some(v) = self.number(
ui,
&format!("{id}.g.{k}"),
label,
radial.center[*c],
-1e5..=1e5,
1.0,
"the centre of the gradient, in the shape's own px",
) {
next.center[*c] = v;
changed = true;
}
});
if let Some(v) = self.number(
ui,
&format!("{id}.g.r"),
"radius ",
radial.radius,
0.1..=1e5,
1.0,
"how far the gradient reaches",
) {
next.radius = v;
changed = true;
}
});
if let Some(stops) = self.stops_editor(ui, id, &radial.stops) {
next.stops = stops;
changed = true;
}
changed.then_some(Paint::Radial { radial: next }).or(out)
}
_ => out,
}
}
fn stops_editor(&mut self, ui: &mut egui::Ui, id: &str, stops: &[Stop]) -> Option<Vec<Stop>> {
let mut next = stops.to_vec();
let mut changed = false;
let mut remove = None;
stops.iter().enumerate().for_each(|(i, Stop(at, hex))| {
ui.horizontal(|ui| {
if let Some(v) = self.number(
ui,
&format!("{id}.g.s{i}"),
"stop ",
*at,
0.0..=1.0,
0.005,
"where this colour sits along the gradient, 0 to 1",
) {
next[i].0 = v;
changed = true;
}
let mut colour = color_of(hex).unwrap_or(Color32::BLACK);
if egui::color_picker::color_edit_button_srgba(ui, &mut colour, egui::color_picker::Alpha::OnlyBlend)
.hint("this stop's colour")
.changed()
{
next[i].1 = hex_of(colour);
changed = true;
}
if ui
.button("brush colour")
.hint("give this stop the current colour")
.clicked()
{
next[i].1 = color::hex(self.color);
changed = true;
}
if stops.len() > 1 && ui.button(crate::theme::icon::CLOSE).hint("remove this stop").clicked() {
remove = Some(i);
}
});
});
if let Some(i) = remove {
next.remove(i);
changed = true;
}
if ui
.button("add stop")
.hint("a stop between the last two, in the current colour")
.clicked()
{
let at = match stops {
[.., a, b] => (a.0 + b.0) / 2.0,
_ => 0.5,
};
next.push(Stop(at, color::hex(self.color)));
changed = true;
}
if changed {
next.sort_by(|a, b| a.0.total_cmp(&b.0));
}
changed.then_some(next)
}
fn activate(&mut self, path: Vec<usize>) -> Result<()> {
if self.live.is_some() {
return Ok(());
}
let id = self.scene.bundle.doc.locate_path(&path).map(|l| l.id.clone());
let tinted = self.scene.tint_mask && (self.scene.active_is_mask() || path.last() == Some(&MASK));
if path != self.scene.active {
self.timeline.kept = (self.canvas_current() && !self.scene.onion_on && !tinted).then_some((
self.scene.frame,
self.scene.bundle.doc.rev,
self.canvas_gen,
));
}
self.scene.set_active_later(path);
if self.scene.onion_on {
self.frames_changed();
}
self.also.retain(|a| Some(a) != id.as_ref());
self.selection = None;
self.picked = None;
Ok(())
}
fn mask_inspector(&mut self, ui: &mut egui::Ui) -> Result<()> {
if self.scene.active_layer().is_none() {
return Ok(());
}
let owner_path = self.scene.active[..self.scene.active.len() - 1].to_vec();
let owner = self.scene.bundle.doc.layer_at(&owner_path).clone();
ui.label(format!("the mask of {}", owner.name));
ui.colored_label(Color32::from_rgb(255, 150, 150), self.mask_hint());
ui.horizontal_wrapped(|ui| {
self.command_check(ui, Cmd::ToggleMask, "mask on");
self.command_check(ui, Cmd::TintMask, "show the mask in red");
});
ui.horizontal_wrapped(|ui| {
self.command_button(ui, Cmd::BackToLayer, Some("back to the layer"));
self.command_button(ui, Cmd::RemoveMask, Some("remove mask"));
});
Ok(())
}
fn mask_hint(&self) -> &'static str {
if self.brush == "eraser" {
"the eraser is on: it shows the layer again where the mask hid it (E switches back to the brush)"
} else {
"the brush hides the layer where you paint (any colour); the eraser (E) shows it again"
}
}
fn layer_inspector(&mut self, ui: &mut egui::Ui) -> Result<()> {
if self.scene.active_is_mask() {
return self.mask_inspector(ui);
}
let Some(layer) = self.scene.active_layer().cloned() else {
ui.label("no layer selected");
return Ok(());
};
let id = layer.id.clone();
ui.label(format!("{} layer", layer.kind_name()));
let mut props: Vec<(String, Value)> = Vec::new();
ui.horizontal(|ui| {
if let Some(name) = self.text(
ui,
&format!("{id}.name"),
"name",
&layer.name,
"the layer's name; Return keeps it",
) {
props.push(("name".into(), json!(name)));
}
});
if layer.kind() == Kind::Bones {
self.command_check(ui, Cmd::ToggleLocked, "locked");
let linked = klad_core::rig::painted(&self.scene.bundle.doc, &id).len();
ui.label(
egui::RichText::new(format!(
"{} bones, {linked} layers rigged to them; draw and pose them with the bone tool (J)",
layer.bones.len()
))
.color(crate::theme::WEAK),
);
return self.set(&id, props);
}
ui.horizontal_wrapped(|ui| {
self.command_check(ui, Cmd::ToggleLocked, "locked");
self.command_check(ui, Cmd::ToggleClip, "clip to layer below");
if layer.kind() == Kind::Paint {
self.command_check(ui, Cmd::ToggleLockAlpha, "lock alpha");
}
});
ui.horizontal_wrapped(|ui| match &layer.mask {
Some(_) => {
self.command_check(ui, Cmd::ToggleMask, "mask on");
self.command_button(ui, Cmd::PaintMask, Some("paint on the mask"));
self.command_button(ui, Cmd::RemoveMask, Some("remove mask"));
}
None => {
self.command_button(ui, Cmd::AddMask, Some("add mask"));
self.command_button(ui, Cmd::AddMaskHiding, Some("add mask hiding all"));
}
});
ui.horizontal_wrapped(|ui| {
let mut reference = layer.reference;
if ui
.checkbox(&mut reference, "reference")
.hint("shown here to trace over, left out of renders and exports (klad render --references shows it)")
.changed()
{
props.push(("reference".into(), json!(reference)));
}
});
self.set(&id, props)?;
self.depth_section(ui, &layer)?;
self.adjust_section(ui, &layer)?;
self.effects_section(ui, &layer)?;
self.animation_section(ui, &id)
}
fn colour_panel(&mut self, ui: &mut egui::Ui) -> Result<()> {
let mut picked: Option<[f32; 4]> = None;
let mut hsva = self.hsva;
ui.horizontal(|ui| {
if color::picker(ui, &mut hsva, 150.0) {
self.color = hsva.rgba();
self.hsva = hsva;
}
ui.vertical(|ui| {
color::swatch(ui, self.color, false, 44.0).hint("the current colour");
ui.add_space(4.0);
ui.horizontal(|ui| {
if let Some(text) = self.text(
ui,
"colour.hex",
"hex",
&color::hex(self.color),
"type #rrggbb or #rrggbbaa and press Return",
) {
match color::rgba_of(&text) {
Some(rgba) => picked = Some(rgba),
None => self.say(
Tone::Refused,
format!("{text} is not a colour: type it as #rrggbb or #rrggbbaa, for example #c8a070"),
),
}
}
});
let mut alpha = self.color[3];
if ui
.add(egui::Slider::new(&mut alpha, 0.0..=1.0).text("alpha"))
.hint("how see-through the colour is")
.changed()
{
let [r, g, b, _] = self.color;
self.set_colour([r, g, b, alpha]);
}
});
});
ui.label("palette");
let edit = self.palette_row(ui);
let variants: Vec<String> = self
.scene
.bundle
.doc
.variant_names()
.into_iter()
.map(String::from)
.collect();
let shown = self.scene.bundle.doc.shown_variant().to_string();
let mut show = None;
if variants.len() > 1 {
ui.horizontal_wrapped(|ui| {
ui.label("variant");
variants.iter().for_each(|name| {
let hint = match name == klad_core::doc::BASE_VARIANT {
true => "show the palette itself".to_string(),
false => format!(
"show the drawing in the colours of {name}; colours changed while it is shown are its own"
),
};
if ui.selectable_label(*name == shown, name).hint(hint).clicked() && *name != shown {
show = Some(name.clone());
}
});
});
}
ui.horizontal_wrapped(|ui| {
let label = ui.label("name");
ui.add(
egui::TextEdit::singleline(&mut self.swatch_name)
.hint_text("optional")
.desired_width(110.0),
)
.labelled_by(label.id)
.hint("a name for the colour; agents can use it in place of the hex");
self.command_button(ui, Cmd::AddSwatch, Some("add colour"));
if self.can_run(Cmd::UpdateSwatch).is_none() {
self.command_button(ui, Cmd::UpdateSwatch, Some("update"));
}
self.command_button(ui, Cmd::AddRamp, Some("ramp"));
self.command_button(ui, Cmd::LoadPalette, Some("palettes"));
if variants.len() > 1 || self.can_run(Cmd::NewVariant).is_none() {
self.command_button(ui, Cmd::NewVariant, Some("new variant"));
}
if !self.scene.bundle.doc.variants.shown.is_empty() {
self.command_button(ui, Cmd::RenameVariant, Some("rename variant"));
self.command_button(ui, Cmd::RemoveVariant, Some("remove variant"));
}
});
let edit = edit.or(show.map(|name| klad_core::ops::PaletteEdit::Variant { name }));
if !self.settings.recent.is_empty() {
ui.label("recent");
let recent = self.settings.recent.clone();
let current = color::hex(self.color);
ui.horizontal_wrapped(|ui| {
recent.iter().for_each(|hex| {
if let Some(rgba) = color::rgba_of(hex)
&& color::swatch(ui, rgba, hex.eq_ignore_ascii_case(¤t), 24.0)
.hint(format!("{hex}, used lately"))
.clicked()
{
picked = Some(rgba);
}
});
});
}
if let Some(rgba) = picked {
self.pick_new_colour(rgba);
}
match edit {
Some(edit) => self.apply(vec![Op::Palette(edit)]),
None => Ok(()),
}
}
fn fill_panel(&mut self, ui: &mut egui::Ui) {
let layers: Vec<(String, String)> = self
.scene
.bundle
.doc
.all_layers()
.iter()
.rev()
.map(|l| (l.id.clone(), l.name.clone()))
.collect();
let name_of = |r: &FillRef| match r {
FillRef::This => "this layer".to_string(),
FillRef::All => "all visible layers".to_string(),
FillRef::Layer(id) => layers
.iter()
.find(|(l, _)| l == id)
.map_or(id.clone(), |(_, name)| format!("{name} ({id})")),
};
let mut reference = self.fill.reference.clone();
ui.horizontal_wrapped(|ui| {
ui.label("inside the lines of");
egui::ComboBox::from_id_salt("fill.ref")
.selected_text(name_of(&reference))
.width(170.0)
.show_ui(ui, |ui| {
ui.selectable_value(&mut reference, FillRef::This, name_of(&FillRef::This));
ui.selectable_value(&mut reference, FillRef::All, name_of(&FillRef::All));
layers.iter().for_each(|(id, _)| {
let r = FillRef::Layer(id.clone());
let text = name_of(&r);
ui.selectable_value(&mut reference, r, text);
});
})
.response
.hint("the lines the fill stops at: this layer, everything visible, or a layer such as your lines");
});
self.fill.reference = reference;
let f = &mut self.fill;
ui.add(egui::Slider::new(&mut f.gap, 0.0..=fill::MAX_GAP).text("close gaps px"))
.hint("openings in the lines up to this wide count as closed");
ui.add(egui::Slider::new(&mut f.tolerance, 0.0..=1.0).text("tolerance"))
.hint("how different a pixel may be from where you click and still fill");
ui.add(egui::Slider::new(&mut f.expand, 0.0..=fill::MAX_EXPAND).text("grow under lines px"))
.hint("the fill reaches this far under the lines, so no paper shows between line and colour");
ui.add(egui::Slider::new(&mut f.opacity, 0.05..=1.0).text("opacity"))
.hint("the fill's opacity");
ui.small("click inside lines to fill, drag a loop to lasso fill");
ui.horizontal_wrapped(|ui| {
self.command_button(ui, Cmd::Refill, Some("refill this drawing"));
self.command_button(ui, Cmd::ShowGaps, Some("show gaps"));
});
if !self.scene.can_paint() {
ui.colored_label(Color32::LIGHT_YELLOW, "pick a paint layer to fill on");
}
}
fn pen_panel(&mut self, ui: &mut egui::Ui) {
let key = device_key(self.readout.device);
let mut curve = self.settings.curve(&key);
let raw = self.readout.pressure;
let peak = self.settings.peak(&key);
let before = curve;
ui.spacing_mut().slider_width = 220.0;
prefs::grid(ui, "settings pen", |ui| {
prefs::row_label(ui, "Pen");
ui.label(if self.readout.device == 0 {
"not identified yet: move it away from the tablet and back".to_string()
} else {
key.clone()
});
ui.end_row();
prefs::row_label(ui, "Pressure");
ui.vertical(|ui| {
ui.add(
egui::ProgressBar::new(raw)
.desired_width(280.0)
.text(format!("pen {raw:.3}")),
);
ui.add(
egui::ProgressBar::new(curve.apply(raw))
.desired_width(280.0)
.text(format!("recorded {:.3}", curve.apply(raw))),
);
ui.label(egui::RichText::new(format!("heaviest press seen {peak:.3}")).color(crate::theme::WEAK));
});
ui.end_row();
prefs::row_label(ui, "Lightest");
ui.add(egui::Slider::new(&mut curve.low, 0.0..=0.5))
.hint("the pen's raw pressure that records as the lightest touch");
ui.end_row();
prefs::row_label(ui, "Heaviest");
ui.add(egui::Slider::new(&mut curve.high, 0.05..=1.0))
.hint("the pen's raw pressure that records as full pressure");
ui.end_row();
prefs::row_label(ui, "Curve");
ui.add(egui::Slider::new(&mut curve.gamma, 0.3..=3.0).logarithmic(true))
.hint("below 1 light presses record heavier, above 1 lighter");
ui.end_row();
prefs::row_label(ui, "");
ui.horizontal_wrapped(|ui| {
if ui
.button("heaviest = my peak")
.hint("set heaviest to the hardest press seen with this pen")
.clicked()
&& peak > 0.05
{
curve.high = peak;
}
if ui.button("reset").hint("the default curve").clicked() {
curve = PressureCurve::default();
}
if ui
.button("forget peak")
.hint("start measuring the hardest press again")
.clicked()
&& let Some(pen) = self.settings.pens.get_mut(&key)
{
pen.peak = 0.0;
self.settings_dirty = true;
}
});
ui.end_row();
prefs::row_label(ui, "Response");
let (rect, _) = ui.allocate_exact_size(vec2(220.0, 120.0), Sense::hover());
let painter = ui.painter_at(rect);
painter.rect_filled(rect, 2.0, Color32::from_gray(28));
let at = |x: f32, y: f32| egui::pos2(rect.left() + x * rect.width(), rect.bottom() - y * rect.height());
let line: Vec<Pos2> = (0..=40)
.map(|i| i as f32 / 40.0)
.map(|x| at(x, curve.apply(x)))
.collect();
painter.add(egui::Shape::line(line, egui::Stroke::new(1.5, Color32::LIGHT_BLUE)));
painter.circle_filled(at(raw, curve.apply(raw)), 3.5, Color32::YELLOW);
ui.end_row();
});
if curve != before {
curve.high = curve.high.max(curve.low + 0.05);
self.settings.set_curve(&key, curve);
self.settings_dirty = true;
}
}
}
impl Editor {
#[cfg(test)]
pub(crate) fn redraw_canvas(&mut self) {
self.dirty.extend(self.scene.all_tiles());
}
pub(crate) fn clear(&self) -> [f32; 4] {
crate::theme::surround(self.settings.defaults.surround)
}
pub(crate) fn take_tabs(&mut self, ctx: &egui::Context, raw_input: &mut egui::RawInput) {
if !ctx.egui_wants_keyboard_input() {
self.tabs.extend(crate::layout::take_tabs(raw_input));
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn grab_finds_every_handle_where_the_press_lands() {
use egui::pos2;
let screen = [
pos2(100.0, 100.0),
pos2(300.0, 100.0),
pos2(300.0, 200.0),
pos2(100.0, 200.0),
];
assert_eq!(grab(screen, pos2(200.0, 100.0 - KNOB), true), Some(Grab::Rotate));
assert_eq!(
grab(screen, pos2(200.0 + 9.0, 100.0 - KNOB - 6.0), true),
Some(Grab::Rotate)
);
assert_eq!(grab(screen, pos2(311.0, 104.0), true), Some(Grab::Scale));
assert_eq!(grab(screen, pos2(92.0, 207.0), false), Some(Grab::Scale));
assert_eq!(grab(screen, pos2(200.0, 111.0), true), Some(Grab::Stretch(0)));
assert_eq!(grab(screen, pos2(309.0, 150.0), true), Some(Grab::Stretch(1)));
assert_eq!(grab(screen, pos2(200.0, 189.0), true), Some(Grab::Stretch(2)));
assert_eq!(grab(screen, pos2(91.0, 150.0), true), Some(Grab::Stretch(3)));
assert_eq!(grab(screen, pos2(309.0, 150.0), false), None);
assert_eq!(grab(screen, pos2(295.0, 150.0), false), Some(Grab::Move));
assert_eq!(grab(screen, pos2(200.0, 150.0), true), Some(Grab::Move));
assert_eq!(grab(screen, pos2(330.0, 150.0), true), None);
}
#[test]
fn stroke_drags_commit_what_the_preview_shows() {
[
Grab::Move,
Grab::Scale,
Grab::Rotate,
Grab::Stretch(0),
Grab::Stretch(1),
Grab::Stretch(3),
]
.iter()
.for_each(|&grab| {
let drag = Drag {
grab,
node: "c1:1,2".into(),
strokes: true,
whole: false,
fresh: false,
copy: false,
start: vec2(140.0, 80.0),
now: vec2(190.0, 20.0),
center: vec2(100.0, 100.0),
corners: [
vec2(50.0, 50.0),
vec2(150.0, 50.0),
vec2(150.0, 150.0),
vec2(50.0, 150.0),
],
slop: 0.5,
crossed: true,
};
let committed = drag.mark_transform();
let a = committed.affine(committed.pivot.unwrap_or([0.0, 0.0]));
drag.affine()
.iter()
.zip(a)
.for_each(|(p, c)| assert!((p - c).abs() < 1e-3, "{grab:?}: {:?} vs {a:?}", drag.affine()));
});
}
#[test]
fn points_map_between_canvas_and_the_shape() {
let m = [0.0, -2.0, 2.0, 0.0, 100.0, 50.0];
let local = to_local(m, vec2(80.0, 70.0));
let back = to_canvas(m, local);
assert!((back - vec2(80.0, 70.0)).length() < 1e-3);
let picked = Picked::whole("c4".into(), vec![3, 12]);
assert_eq!(picked.addresses(), ["c4:s3", "c4:s12"]);
assert_eq!(picked.key(), "c4:3,12");
let cut = Picked {
cut: Some(vec![[0.0, 0.0], [5.0, 0.0], [5.0, 5.0]]),
..picked.clone()
};
assert!(cut.key().starts_with("c4:3,12:cut"));
}
#[test]
fn hardness_and_curve_make_a_variant_but_feel_settings_do_not() {
let set = BrushSet::presets();
let ink = set.def("ink").unwrap();
let tuning = Tuning::of(ink);
assert_eq!(&tuning.shape(ink), ink);
let soft = set.def("soft").unwrap();
assert_eq!(&Tuning::of(soft).shape(soft), soft);
let feel = Tuning {
taper: [0.0, 0.0],
stabilizer: 0.0,
smoothing: 80.0,
..tuning
};
assert_eq!(&feel.shape(ink), ink);
let harder = Tuning {
hardness: Some(1.0),
..tuning
};
assert_eq!(harder.shape(ink).hardness(), Some(1.0));
let feathered = Tuning { feather: 0.5, ..tuning };
assert_eq!(feathered.shape(ink).feather, 0.5);
let lighter = Tuning {
size_min: 0.3,
..tuning
};
let shaped = lighter.shape(ink);
assert_eq!(shaped.dynamics.size.pressure.map(|c| c.min), Some(0.3));
let none = BTreeMap::new();
assert_eq!(pick_id("ink", &tuning.shape(ink), &none), "ink");
assert!(pick_id("ink", &shaped, &none).starts_with("ink-"));
}
}