diff --git a/README.md b/README.md index 8a931500..bb43d61c 100644 --- a/README.md +++ b/README.md @@ -88,7 +88,7 @@

Vectors without compromise

- Real vector networks: the Pen and Pencil tools, vector edit mode with bend, split, heal-on-delete and handle mirroring, boolean groups (union, subtract, intersect, exclude), flatten, outline stroke, arrowheads, dashes and per-side strokes. Rectangles with smooth (squircle) corners, polygons, stars and arcs. + Real vector networks: the Pen and Pencil tools, vector edit mode with its own tools (pen that extends and branches paths, bend, paint bucket fills for any closed area, lasso, cut), point panel with handle mirroring and per-point corner radius, join, split and heal-on-delete, boolean groups (union, subtract, intersect, exclude), flatten, outline stroke, arrowheads, dashes and per-side strokes. Rectangles with smooth (squircle) corners, polygons, stars and arcs.

Paints and effects

diff --git a/ROADMAP.md b/ROADMAP.md index aa680c68..1444dd4d 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -9,7 +9,7 @@ continuous Claude Opus 5.5 agent work (including builds and the CI gate), for ** **4–6 parallel agents** on disjoint crates. They are counted from the remaining work in the parity table below and updated as work lands. -_Last updated: 2026-10-09 (end of day 1: foundation, renderer, engine, UI3 shell)._ +_Last updated: 2026-10-10 (vector edit mode tools)._ ## Where we are @@ -38,8 +38,12 @@ dimension measured side by side. ### Where we're lacking (priority order) -1. **Vector edit mode** (Enter on a vector): vertex/handle editing, bend, paint bucket, lasso, - cut/erase, vector networks with branching. 25–35 h. +1. **Vector edit mode**: *landed:* edit-mode toolbar (move, pen, bend, paint bucket, lasso, cut), + pen that extends, branches and closes paths (vector networks), paint bucket fill/unfill of any + closed area (faces with holes), point/segment selection, handle mirroring (none/angle/angle and + length) with a Point panel (position, corner radius, mirroring), smooth/sharp points, join and + merge, delete vs delete-and-heal, nudging, one undo step per gesture. *Left:* eraser, variable + width strokes, shape builder, transform box for several points, point snapping. 12–18 h. 2. **Text editing depth**: *landed:* OpenType features panel, small caps, lists, title case, truncation/max lines, font picker with previews and recents, word/line selection, IME commit. *Left:* inline IME preedit, variable font axes, visual QA. 8–12 h. @@ -62,7 +66,8 @@ dimension measured side by side. ### Where we're going -- **Next:** vector edit mode (1) and text depth (2) in parallel with the fidelity pass (7). +- **Next:** text depth (2) and auto layout depth (3) in parallel with the fidelity pass (7); the + rest of vector editing (1). - **Then:** auto layout/components/prototyping depth (3–5), interop (6). - **Alpha:** release builds on every push to `release` (packaging in progress), demo files, docs. @@ -111,7 +116,7 @@ Scores by behaviour, 0–100%. Hours are what remains (one agent). | Canvas & navigation | 6 | 60% | rulers/guides dragging, pixel preview, minimap-free perf at scale | 8–12 | | Selection & transform | 8 | 55% | rotated multi-select handles, scale tool polish, measure hover polish, nudge-resize | 12–18 | | Layers panel | 5 | 55% | search/filter, multi-select ranges, collapse all, thumbnails, drag polish | 8–12 | -| Shapes & vector | 8 | 30% | vector edit mode, bend/paint bucket, live boolean editing, arc handles on canvas | 30–40 | +| Shapes & vector | 8 | 55% | eraser, variable width, shape builder, multi-point transform box, point snapping, live boolean editing, arc handles on canvas | 15–22 | | Paint | 7 | 55% | gradient handles on canvas, image crop mode, document colours, colour models | 12–18 | | Strokes | 3 | 55% | arrowhead set, dash/gap UI, per-side UI, stroke styles | 5–8 | | Effects | 4 | 60% | effect styles UI, glass/texture fidelity, shadow spread on non-rects exactness | 6–10 | @@ -125,7 +130,7 @@ Scores by behaviour, 0–100%. Hours are what remains (one agent). | Dev mode / inspect | 2 | 35% | measurements on canvas, code variants (Swift/Compose), assets | 6–10 | | Comments, versions, misc | 3 | 25% | comments, version history UI, plugins (WASM) | 15–25 | -Weighted feature depth ≈ **43%**. +Weighted feature depth ≈ **45%**. ## Milestones @@ -136,7 +141,7 @@ Weighted feature depth ≈ **43%**. | M1 Core editing completeness (tools, panels, menus, clipboard, files) | ~60% | | M2 Layout depth | ~45% | | M3 Components & styles depth | ~40% | -| M4 Vector & text depth | ~30% | +| M4 Vector & text depth | ~45% | | M5 Prototype & present | ~30% | | M6 Interop & dev mode | ~35% | | M7 Release (signed builds for all platforms, README screenshots) | started | diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs index 7306318c..14faa869 100644 --- a/crates/doc/src/lib.rs +++ b/crates/doc/src/lib.rs @@ -16,6 +16,7 @@ pub mod proto; pub mod styles; pub mod text; pub mod vector; +pub mod vector_faces; pub use comments::*; pub use figcraft_color as color; @@ -25,6 +26,7 @@ pub use props::*; pub use styles::*; pub use text::*; pub use vector::*; +pub use vector_faces::Face; use figcraft_color::Color; use figcraft_geom::{Affine, Point, Rect}; diff --git a/crates/doc/src/vector.rs b/crates/doc/src/vector.rs index 064317a6..7c441fbd 100644 --- a/crates/doc/src/vector.rs +++ b/crates/doc/src/vector.rs @@ -4,6 +4,32 @@ use figcraft_geom::{BezPath, Point}; use serde::{Deserialize, Serialize}; +/// How a vertex's two bezier handles follow each other when one is dragged. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Default)] +#[serde(rename_all = "camelCase")] +pub enum HandleMirroring { + /// Handles move independently (a corner). + #[default] + None, + /// The other handle stays opposite but keeps its own length. + Angle, + /// The other handle mirrors angle and length (a symmetric smooth point). + AngleAndLength, +} + +impl HandleMirroring { + pub fn id(self) -> &'static str { + match self { + HandleMirroring::None => "none", + HandleMirroring::Angle => "angle", + HandleMirroring::AngleAndLength => "angleAndLength", + } + } + pub fn from_id(s: &str) -> Option { + [HandleMirroring::None, HandleMirroring::Angle, HandleMirroring::AngleAndLength].into_iter().find(|m| m.id().eq_ignore_ascii_case(s)) + } +} + #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)] pub struct Vertex { pub x: f64, @@ -11,11 +37,14 @@ pub struct Vertex { /// Per-vertex corner radius (0 = sharp). #[serde(default)] pub radius: f64, + /// Handle mirroring; `None` infers it from the handles (see [`VectorNetwork::mirroring`]). + #[serde(default, skip_serializing_if = "Option::is_none")] + pub mirror: Option, } impl Vertex { pub fn new(x: f64, y: f64) -> Self { - Self { x, y, radius: 0.0 } + Self { x, y, radius: 0.0, mirror: None } } pub fn point(&self) -> Point { Point::new(self.x, self.y) @@ -92,9 +121,27 @@ impl VectorNetwork { net.vertices.push(Vertex::new(p.x, p.y)); net.vertices.len() - 1 }; + // A subpath that ends back on its start point without a ClosePath (e.g. ellipse outlines) + // is closed too, so it keeps its fill. + let close_open = + |net: &mut VectorNetwork, loop_segs: &mut Vec, all_loops: &mut Vec>, first_v: Option, cur_v: Option| { + let (Some(a), Some(f)) = (cur_v, first_v) else { return }; + let (Some(pa), Some(pf)) = (net.vertices.get(a).map(Vertex::point), net.vertices.get(f).map(Vertex::point)) else { return }; + if a == f || loop_segs.len() < 2 || (pa - pf).hypot() > 1e-6 || a + 1 != net.vertices.len() { + return; + } + for s in net.segments.iter_mut() { + if s.b == a { + s.b = f; + } + } + net.vertices.pop(); + all_loops.push(std::mem::take(loop_segs)); + }; for el in path.elements() { match *el { PathEl::MoveTo(p) => { + close_open(&mut net, &mut loop_segs, &mut all_loops, first_v, cur_v); loop_segs.clear(); let v = push_v(&mut net, p); first_v = Some(v); @@ -129,7 +176,9 @@ impl VectorNetwork { let (Some(a), Some(f)) = (cur_v, first_v) else { continue }; let close_pt = net.vertices.get(a).map(Vertex::point); let first_pt = net.vertices.get(f).map(Vertex::point); - if close_pt.is_some() && close_pt == first_pt && a != f { + // The end vertex lands on the start (up to float noise): merge them. + let same = matches!((close_pt, first_pt), (Some(c), Some(f)) if (c - f).hypot() <= 1e-6); + if same && a != f { // Merge the duplicate end vertex into the first one. for s in net.segments.iter_mut() { if s.b == a { @@ -150,12 +199,93 @@ impl VectorNetwork { } } } + close_open(&mut net, &mut loop_segs, &mut all_loops, first_v, cur_v); if !all_loops.is_empty() { net.regions.push(Region { loops: all_loops, winding: WindingRule::NonZero }); } net } + /// Segments touching vertex `v`: (segment index, `true` when `v` is the segment's `a` end). + pub fn incident(&self, v: usize) -> Vec<(usize, bool)> { + self.segments + .iter() + .enumerate() + .filter_map(|(i, s)| { + if s.a == v { + Some((i, true)) + } else if s.b == v { + Some((i, false)) + } else { + None + } + }) + .collect() + } + + /// The handle (relative to its vertex) at one end of a segment. + pub fn handle(&self, seg: usize, start: bool) -> Option<(f64, f64)> { + let s = self.segments.get(seg)?; + Some(if start { s.ta } else { s.tb }) + } + + pub fn set_handle(&mut self, seg: usize, start: bool, t: (f64, f64)) { + if let Some(s) = self.segments.get_mut(seg) { + if start { + s.ta = t; + } else { + s.tb = t; + } + } + } + + /// The vertex's handle mirroring: its explicit setting, else inferred from its two handles + /// (opposite and equal → angle and length, opposite → angle, otherwise none). + pub fn mirroring(&self, v: usize) -> HandleMirroring { + if let Some(m) = self.vertices.get(v).and_then(|x| x.mirror) { + return m; + } + let inc = self.incident(v); + let [(s1, a1), (s2, a2)] = inc.as_slice() else { return HandleMirroring::None }; + let (Some(h1), Some(h2)) = (self.handle(*s1, *a1), self.handle(*s2, *a2)) else { return HandleMirroring::None }; + let (l1, l2) = (h1.0.hypot(h1.1), h2.0.hypot(h2.1)); + if l1 < 1e-9 || l2 < 1e-9 { + return HandleMirroring::None; + } + // Opposite directions: the cross product is ~0 and the dot product negative. + let cross = (h1.0 * h2.1 - h1.1 * h2.0) / (l1 * l2); + let dot = (h1.0 * h2.0 + h1.1 * h2.1) / (l1 * l2); + if cross.abs() > 1e-3 || dot > -0.999 { + HandleMirroring::None + } else if (l1 - l2).abs() <= 1e-6 * l1.max(l2).max(1.0) { + HandleMirroring::AngleAndLength + } else { + HandleMirroring::Angle + } + } + + /// Segment `i` as a cubic bezier. + pub fn cubic(&self, i: usize) -> Option { + let (a, c1, c2, b) = self.seg_points(self.segments.get(i)?)?; + Some(figcraft_geom::kurbo::CubicBez::new(a, c1, c2, b)) + } + + /// One closed loop of segments as a path. + pub fn loop_path(&self, lp: &[usize]) -> BezPath { + let mut path = BezPath::new(); + self.append_loop(&mut path, lp); + path + } + + /// Whether the rendered fill covers `p` (the renderer fills every region with one rule: even-odd + /// when any region asks for it). + pub fn fill_contains(&self, p: Point) -> bool { + use figcraft_geom::Shape; + let path = self.fill_path(); + let w = path.winding(p); + if self.regions.iter().any(|r| r.winding == WindingRule::EvenOdd) { w % 2 != 0 } else { w != 0 } + } + fn seg_points(&self, s: &Segment) -> Option<(Point, Point, Point, Point)> { let a = self.vertices.get(s.a)?.point(); let b = self.vertices.get(s.b)?.point(); diff --git a/crates/doc/src/vector_faces.rs b/crates/doc/src/vector_faces.rs new file mode 100644 index 00000000..3eb4d494 --- /dev/null +++ b/crates/doc/src/vector_faces.rs @@ -0,0 +1,517 @@ +//! Faces of a vector network: the closed areas between its segments, which the paint bucket fills +//! and unfills. +//! +//! Faces come from a half-edge walk of the planar graph: at each vertex the walk turns to the next +//! segment in angular order, which traces every bounded area once (positive signed area) and the +//! outside of each connected piece once (negative). Pieces nested inside a face become its holes. +//! Segments are assumed not to cross each other; crossing networks still give well-formed (if +//! approximate) faces. + +use figcraft_geom::kurbo::{ParamCurve, ParamCurveDeriv, PathEl}; +use figcraft_geom::{BezPath, Point, Rect, Shape, Vec2}; + +use crate::vector::{Region, VectorNetwork, WindingRule}; + +/// A bounded area: its outer loop first, then the outer loops of pieces nested inside it. +#[derive(Clone, Debug, PartialEq)] +pub struct Face { + /// Loops of segment indices. + pub loops: Vec>, + /// Enclosed area (the outer loop's minus the holes'). + pub area: f64, + /// The face's outline (all loops); fill it even-odd. + pub path: BezPath, +} + +impl Face { + pub fn contains(&self, p: Point) -> bool { + self.path.winding(p) % 2 != 0 + } + + /// The fill region for this face. + pub fn region(&self) -> Region { + Region { loops: self.loops.clone(), winding: if self.loops.len() > 1 { WindingRule::EvenOdd } else { WindingRule::NonZero } } + } + + /// Some point strictly inside the face (not in a hole). + pub fn interior_point(&self) -> Option { + interior_point(&self.path) + } +} + +/// A traced cycle of half-edges (segment index, forward?). +struct Cycle { + half_edges: Vec<(usize, bool)>, + area: f64, + component: usize, +} + +impl VectorNetwork { + /// Every bounded face, holes included. + pub fn faces(&self) -> Vec { + let cycles = self.cycles(); + // Each connected piece's outside: its most negative cycle. + let mut outside: std::collections::BTreeMap = std::collections::BTreeMap::new(); + for c in cycles.iter().filter(|c| c.area < -AREA_EPS) { + let e = outside.entry(c.component).or_insert(c); + if c.area < e.area { + *e = c; + } + } + // A piece's outer boundary (loops + path), only for pieces that enclose any area. + let boundaries: Vec<(usize, Vec>, BezPath, f64)> = outside + .iter() + .map(|(comp, c)| { + let loops = self.split_loops(&c.half_edges); + let path = self.loops_path(&loops); + (*comp, loops, path, -c.area) + }) + .filter(|(_, loops, _, _)| !loops.is_empty()) + .collect(); + let mut faces = Vec::new(); + for c in cycles.iter().filter(|c| c.area > AREA_EPS) { + let loops = self.split_loops(&c.half_edges); + if loops.is_empty() { + continue; + } + let outer = self.loops_path(&loops); + // Pieces directly inside this face (not inside another piece that is) are its holes. + let inside: Vec<&(usize, Vec>, BezPath, f64)> = boundaries + .iter() + .filter(|(comp, ..)| *comp != c.component) + .filter(|(comp, ..)| self.component_point(&cycles, *comp).is_some_and(|p| outer.winding(p) % 2 != 0)) + .collect(); + let mut face = Face { loops, area: c.area, path: outer }; + for (comp, hl, hp, ha) in &inside { + let nested = inside + .iter() + .any(|(other, _, op, _)| other != comp && self.component_point(&cycles, *comp).is_some_and(|p| op.winding(p) % 2 != 0)); + if nested { + continue; + } + face.loops.extend(hl.iter().cloned()); + face.path.extend(hp.elements().iter().copied()); + face.area -= ha; + } + faces.push(face); + } + faces + } + + /// The smallest face containing `p`. + pub fn face_at(&self, p: Point) -> Option { + self.faces().into_iter().filter(|f| f.contains(p)).min_by(|a, b| a.area.total_cmp(&b.area)) + } + + /// The paint bucket: fill the face under `p`, or unfill it when it's filled. Returns the new + /// state (`Some(true)` = filled), or `None` when `p` isn't inside a closed area. + /// + /// Regions that aren't single faces (e.g. from a converted shape or an import) are first + /// re-expressed as one region per filled face, so any face can be toggled on its own. + pub fn paint(&mut self, p: Point) -> Option { + let face = self.face_at(p)?; + let key = |loops: &[Vec]| -> Vec> { + let mut k: Vec> = loops + .iter() + .map(|l| { + let mut l = l.clone(); + l.sort_unstable(); + l + }) + .collect(); + k.sort(); + k + }; + let faces = self.faces(); + let face_keys: Vec>> = faces.iter().map(|f| key(&f.loops)).collect(); + if !self.regions.iter().all(|r| face_keys.contains(&key(&r.loops))) { + let filled: Vec = faces.iter().filter(|f| f.interior_point().is_some_and(|q| self.fill_contains(q))).map(Face::region).collect(); + self.regions = filled; + } + let k = key(&face.loops); + if let Some(i) = self.regions.iter().position(|r| key(&r.loops) == k) { + self.regions.remove(i); + Some(false) + } else { + self.regions.push(face.region()); + Some(true) + } + } + + /// Trace every half-edge cycle. + fn cycles(&self) -> Vec { + let n = self.segments.len(); + let nv = self.vertices.len(); + let valid = |i: usize| self.segments.get(i).is_some_and(|s| s.a < nv && s.b < nv); + // Outgoing half-edges per vertex, sorted by angle. + let mut out: Vec> = vec![Vec::new(); nv]; + for i in (0..n).filter(|i| valid(*i)) { + for fwd in [true, false] { + let Some((origin, dir, along)) = self.half_edge_dir(i, fwd) else { continue }; + if let Some(list) = out.get_mut(origin) { + list.push((dir.y.atan2(dir.x), along.y.atan2(along.x), i, fwd)); + } + } + } + for list in &mut out { + list.sort_by(|a, b| a.0.total_cmp(&b.0).then(a.1.total_cmp(&b.1))); + } + let origin = |i: usize, fwd: bool| self.segments.get(i).map(|s| if fwd { s.a } else { s.b }); + let dest = |i: usize, fwd: bool| self.segments.get(i).map(|s| if fwd { s.b } else { s.a }); + // The walk: arrive at v along (i, fwd); leave by the edge before the twin in angular order. + let next = |i: usize, fwd: bool| -> Option<(usize, bool)> { + let v = dest(i, fwd)?; + let list = out.get(v)?; + let k = list.iter().position(|e| e.2 == i && e.3 != fwd)?; + let e = list.get((k + list.len() - 1) % list.len())?; + Some((e.2, e.3)) + }; + let comp = self.components(); + let idx = |i: usize, fwd: bool| i * 2 + usize::from(!fwd); + let mut seen = vec![false; n * 2]; + let mut cycles = Vec::new(); + for i in (0..n).filter(|i| valid(*i)) { + for fwd in [true, false] { + if seen.get(idx(i, fwd)).copied().unwrap_or(true) { + continue; + } + let mut half_edges = Vec::new(); + let mut cur = (i, fwd); + let mut closed = false; + for _ in 0..=n * 2 { + if let Some(s) = seen.get_mut(idx(cur.0, cur.1)) { + *s = true; + } + half_edges.push(cur); + let Some(nx) = next(cur.0, cur.1) else { break }; + if nx == (i, fwd) { + closed = true; + break; + } + if seen.get(idx(nx.0, nx.1)).copied().unwrap_or(true) { + break; + } + cur = nx; + } + if !closed { + continue; + } + let area = self.half_edge_path(&half_edges).area(); + let component = origin(i, fwd).and_then(|v| comp.get(v).copied()).unwrap_or(0); + cycles.push(Cycle { half_edges, area: if area.is_finite() { area } else { 0.0 }, component }); + } + } + cycles + } + + /// Where half-edge (i, fwd) starts, its initial direction and a direction a little along it + /// (tie-break for tangent curves). + fn half_edge_dir(&self, i: usize, fwd: bool) -> Option<(usize, Vec2, Vec2)> { + let s = self.segments.get(i)?; + let c = self.cubic(i)?; + let (origin, p0, d, along) = if fwd { + (s.a, c.p0, c.deriv().eval(0.0).to_vec2(), c.eval(0.25) - c.p0) + } else { + (s.b, c.p3, -c.deriv().eval(1.0).to_vec2(), c.eval(0.75) - c.p3) + }; + let fallback = if fwd { [c.p2 - p0, c.p3 - p0] } else { [c.p1 - p0, c.p0 - p0] }; + // A zero-length segment gets a nominal direction; the walk stays a permutation, so its + // cycles still close (and its angle is irrelevant at the usual two-segment vertex). + let nominal = if fwd { Vec2::new(1.0, 0.0) } else { Vec2::new(-1.0, 0.0) }; + let dir = std::iter::once(d).chain(fallback).find(|v| v.hypot() > 1e-9).unwrap_or(nominal); + Some((origin, dir, if along.hypot() > 1e-9 { along } else { dir })) + } + + fn half_edge_path(&self, half_edges: &[(usize, bool)]) -> BezPath { + let mut path = BezPath::new(); + for (k, (i, fwd)) in half_edges.iter().enumerate() { + let Some(c) = self.cubic(*i) else { continue }; + let c = if *fwd { c } else { figcraft_geom::kurbo::CubicBez::new(c.p3, c.p2, c.p1, c.p0) }; + if k == 0 { + path.move_to(c.p0); + } + path.curve_to(c.p1, c.p2, c.p3); + } + path.close_path(); + path + } + + /// A cycle's segments as closed loops: segments walked twice (dangling paths, bridges between + /// loops) are dropped and what's left is chained into loops. + fn split_loops(&self, half_edges: &[(usize, bool)]) -> Vec> { + let count = |i: usize| half_edges.iter().filter(|h| h.0 == i).count(); + let kept: Vec<(usize, bool)> = half_edges.iter().copied().filter(|h| count(h.0) == 1).collect(); + let ends = |h: (usize, bool)| self.segments.get(h.0).map(|s| if h.1 { (s.a, s.b) } else { (s.b, s.a) }); + let mut used = vec![false; kept.len()]; + let mut loops = Vec::new(); + for start in 0..kept.len() { + if used.get(start).copied().unwrap_or(true) { + continue; + } + let Some(first) = kept.get(start).copied() else { continue }; + let Some((v0, mut v)) = ends(first) else { continue }; + if let Some(u) = used.get_mut(start) { + *u = true; + } + let mut lp = vec![first.0]; + let mut pos = start; + while v != v0 { + // Prefer the next half-edge in walk order that continues from `v`. + let found = (1..=kept.len()) + .map(|d| (pos + d) % kept.len()) + .find(|j| !used.get(*j).copied().unwrap_or(true) && kept.get(*j).and_then(|h| ends(*h)).is_some_and(|(a, _)| a == v)); + let Some(j) = found else { break }; + if let Some(u) = used.get_mut(j) { + *u = true; + } + let Some(h) = kept.get(j).copied() else { break }; + lp.push(h.0); + v = ends(h).map(|e| e.1).unwrap_or(v0); + pos = j; + } + if v == v0 { + loops.push(lp); + } + } + loops + } + + fn loops_path(&self, loops: &[Vec]) -> BezPath { + let mut path = BezPath::new(); + for lp in loops { + path.extend(self.loop_path(lp).elements().iter().copied()); + } + path + } + + /// Connected piece of every vertex. + fn components(&self) -> Vec { + let nv = self.vertices.len(); + let mut parent: Vec = (0..nv).collect(); + fn find(parent: &mut [usize], mut x: usize) -> usize { + for _ in 0..parent.len() { + let p = parent.get(x).copied().unwrap_or(x); + if p == x { + break; + } + let gp = parent.get(p).copied().unwrap_or(p); + if let Some(px) = parent.get_mut(x) { + *px = gp; + } + x = gp; + } + x + } + for s in &self.segments { + if s.a < nv && s.b < nv { + let (ra, rb) = (find(&mut parent, s.a), find(&mut parent, s.b)); + if let Some(r) = parent.get_mut(ra) { + *r = rb; + } + } + } + (0..nv).map(|v| find(&mut parent, v)).collect() + } + + /// A vertex of piece `comp` (for nesting tests). + fn component_point(&self, cycles: &[Cycle], comp: usize) -> Option { + let c = cycles.iter().find(|c| c.component == comp)?; + let (i, fwd) = c.half_edges.first().copied()?; + let s = self.segments.get(i)?; + self.vertices.get(if fwd { s.a } else { s.b }).map(|v| v.point()) + } +} + +const AREA_EPS: f64 = 1e-9; + +/// A point inside a closed path under the even-odd rule: the middle of the widest span on a few +/// horizontal scanlines. +pub fn interior_point(path: &BezPath) -> Option { + let bb: Rect = path.bounding_box(); + if !(bb.width() > 0.0 && bb.height() > 0.0 && bb.width().is_finite() && bb.height().is_finite()) { + return None; + } + let mut lines: Vec<(Point, Point)> = Vec::new(); + let (mut start, mut last) = (Point::ZERO, Point::ZERO); + figcraft_geom::kurbo::flatten(path.iter(), bb.width().max(bb.height()) * 1e-3, |el| match el { + PathEl::MoveTo(p) => { + start = p; + last = p; + } + PathEl::LineTo(p) => { + lines.push((last, p)); + last = p; + } + PathEl::ClosePath => { + lines.push((last, start)); + last = start; + } + _ => {} + }); + let mut best: Option<(f64, Point)> = None; + for k in [0.5, 0.3, 0.7, 0.15, 0.85, 0.05, 0.95] { + // An irrational nudge keeps the scanline off vertices. + let y = bb.y0 + bb.height() * (k + 0.000_123_456_7); + let mut xs: Vec = lines + .iter() + .filter(|(p, q)| (p.y <= y && y < q.y) || (q.y <= y && y < p.y)) + .map(|(p, q)| p.x + (y - p.y) * (q.x - p.x) / (q.y - p.y)) + .filter(|x| x.is_finite()) + .collect(); + xs.sort_by(f64::total_cmp); + for pair in xs.chunks_exact(2) { + let (Some(a), Some(b)) = (pair.first(), pair.get(1)) else { continue }; + let w = b - a; + if w > best.map(|b| b.0).unwrap_or(1e-9) { + best = Some((w, Point::new((a + b) / 2.0, y))); + } + } + } + best.map(|b| b.1) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::vector::{Segment, Vertex}; + + fn square(x: f64, y: f64, s: f64) -> VectorNetwork { + VectorNetwork::from_points(&[Point::new(x, y), Point::new(x + s, y), Point::new(x + s, y + s), Point::new(x, y + s)], true) + } + + fn merge(a: &VectorNetwork, b: &VectorNetwork) -> VectorNetwork { + let mut n = a.clone(); + let (nv, ns) = (n.vertices.len(), n.segments.len()); + n.vertices.extend(b.vertices.iter().copied()); + n.segments.extend(b.segments.iter().map(|s| Segment { a: s.a + nv, b: s.b + nv, ..*s })); + n.regions + .extend(b.regions.iter().map(|r| Region { loops: r.loops.iter().map(|l| l.iter().map(|i| i + ns).collect()).collect(), ..r.clone() })); + n + } + + #[test] + fn square_has_one_face_and_the_bucket_toggles_it() { + let mut n = square(0.0, 0.0, 100.0); + n.regions.clear(); + let f = n.faces(); + assert_eq!(f.len(), 1); + assert!((f[0].area - 10000.0).abs() < 1e-6); + assert_eq!(n.paint(Point::new(50.0, 50.0)), Some(true)); + assert!(n.fill_contains(Point::new(50.0, 50.0))); + assert_eq!(n.paint(Point::new(50.0, 50.0)), Some(false)); + assert!(n.regions.is_empty()); + assert_eq!(n.paint(Point::new(150.0, 50.0)), None, "outside every face"); + } + + #[test] + fn a_diagonal_splits_the_square_into_two_faces() { + let mut n = square(0.0, 0.0, 100.0); + n.regions.clear(); + n.segments.push(Segment::line(0, 2)); + let f = n.faces(); + assert_eq!(f.len(), 2); + assert!(f.iter().all(|f| (f.area - 5000.0).abs() < 1e-6)); + assert_eq!(n.paint(Point::new(75.0, 25.0)), Some(true)); + assert!(n.fill_contains(Point::new(75.0, 25.0))); + assert!(!n.fill_contains(Point::new(25.0, 75.0))); + } + + #[test] + fn unfilling_part_of_a_converted_shape_keeps_the_rest() { + // A filled square (one region over the outline) cut by a diagonal. + let mut n = square(0.0, 0.0, 100.0); + n.segments.push(Segment::line(0, 2)); + assert!(n.fill_contains(Point::new(75.0, 25.0))); + assert_eq!(n.paint(Point::new(75.0, 25.0)), Some(false)); + assert!(!n.fill_contains(Point::new(75.0, 25.0))); + assert!(n.fill_contains(Point::new(25.0, 75.0))); + } + + #[test] + fn nested_pieces_become_holes() { + let mut outer = square(0.0, 0.0, 100.0); + outer.regions.clear(); + let mut inner = square(25.0, 25.0, 50.0); + inner.regions.clear(); + let mut n = merge(&outer, &inner); + let mut areas: Vec = n.faces().iter().map(|f| f.area).collect(); + areas.sort_by(f64::total_cmp); + assert_eq!(areas.len(), 2); + assert!((areas[0] - 2500.0).abs() < 1e-6 && (areas[1] - 7500.0).abs() < 1e-6, "{areas:?}"); + assert_eq!(n.paint(Point::new(10.0, 10.0)), Some(true)); + assert!(n.fill_contains(Point::new(10.0, 10.0))); + assert!(!n.fill_contains(Point::new(50.0, 50.0)), "the ring has a hole"); + assert_eq!(n.paint(Point::new(50.0, 50.0)), Some(true)); + assert!(n.fill_contains(Point::new(50.0, 50.0))); + // A third square inside the inner one is the inner face's hole, not the ring's. + let mut core = square(45.0, 45.0, 10.0); + core.regions.clear(); + let n3 = merge(&n, &core); + let ring = n3.face_at(Point::new(10.0, 10.0)).unwrap(); + assert_eq!(ring.loops.len(), 2); + assert!((ring.area - 7500.0).abs() < 1e-6); + let mid = n3.face_at(Point::new(30.0, 30.0)).unwrap(); + assert!((mid.area - 2400.0).abs() < 1e-6); + } + + #[test] + fn dangling_paths_and_bridges_dont_break_faces() { + let mut n = square(0.0, 0.0, 100.0); + n.regions.clear(); + // A spur into the square. + n.vertices.push(Vertex::new(50.0, 50.0)); + n.segments.push(Segment::line(0, 4)); + // A second square inside, bridged to the spur's end. + let inner = square(60.0, 60.0, 20.0); + let mut m = merge(&n, &inner); + m.regions.clear(); + m.segments.push(Segment::line(4, 5)); + let f = m.face_at(Point::new(10.0, 90.0)).unwrap(); + assert!((f.area - (10000.0 - 400.0)).abs() < 1e-6, "{}", f.area); + assert_eq!(f.loops.len(), 2); + assert_eq!(m.paint(Point::new(10.0, 90.0)), Some(true)); + assert!(m.fill_contains(Point::new(10.0, 90.0))); + assert!(!m.fill_contains(Point::new(70.0, 70.0))); + } + + #[test] + fn curves_and_junk_networks() { + let mut circle = figcraft_geom::kurbo::Ellipse::new((50.0, 50.0), (50.0, 50.0), 0.0).to_path(0.01); + circle.close_path(); + let mut n = VectorNetwork::from_path(&circle); + let close = n.vertices.iter().enumerate().any(|(i, a)| n.vertices.iter().skip(i + 1).any(|b| (a.point() - b.point()).hypot() < 1e-3)); + assert!(!close, "the closing point merges into the first"); + n.regions.clear(); + eprintln!( + "{:?} +{:?}", + n.vertices, n.segments + ); + for c in n.cycles() { + eprintln!("cycle {:?} area {}", c.half_edges, c.area); + } + let f = n.faces(); + assert_eq!(f.len(), 1); + assert!((f[0].area - std::f64::consts::PI * 2500.0).abs() < 5.0, "{}", f[0].area); + // Without the ClosePath (kurbo's ellipse outline) it's still one closed, filled loop. + let open = figcraft_geom::kurbo::Ellipse::new((50.0, 50.0), (50.0, 50.0), 0.0).to_path(0.01); + let o = VectorNetwork::from_path(&open); + assert_eq!(o.vertices.len(), n.vertices.len()); + assert_eq!(o.regions.len(), 1); + assert!(o.fill_contains(Point::new(50.0, 50.0))); + assert_eq!(n.paint(Point::new(50.0, 50.0)), Some(true)); + // Junk: NaN coordinates, dangling indices, self-loops, coincident points. + let mut j = square(0.0, 0.0, 10.0); + j.vertices.push(Vertex::new(f64::NAN, 1.0)); + j.segments.push(Segment::line(0, 4)); + j.segments.push(Segment::line(2, 99)); + j.segments.push(Segment::line(1, 1)); + j.segments.push(Segment { a: 3, b: 3, ta: (5.0, 5.0), tb: (-5.0, 5.0) }); + j.vertices.push(Vertex::new(0.0, 0.0)); + j.segments.push(Segment::line(0, 5)); + let _ = j.faces(); + let _ = j.paint(Point::new(5.0, 5.0)); + let _ = j.paint(Point::new(f64::NAN, 5.0)); + assert!(interior_point(&BezPath::new()).is_none()); + } +} diff --git a/crates/engine/src/cmd/structure.rs b/crates/engine/src/cmd/structure.rs index 299331fe..1d2878bf 100644 --- a/crates/engine/src/cmd/structure.rs +++ b/crates/engine/src/cmd/structure.rs @@ -70,8 +70,12 @@ pub fn specs() -> Vec { }), spec!("vector.simplify", "Simplify vector", "{ids?, tolerance?}", true, simplify), spec!("vector.offset", "Offset path", "{ids?, offset}", true, offset_path), - spec!("vector.join", "Join selection", "{ids?}", true, join), - spec!("vector.smoothJoin", "Smooth join selection", "{ids?}", true, join), + spec!("vector.join", "Join selection", "{ids?} (in vector edit mode: joins the selected points)", true, |s, p| { + crate::vectoredit::join_in_edit_mode(s, false).unwrap_or_else(|| join(s, p)) + }), + spec!("vector.smoothJoin", "Smooth join selection", "{ids?} (in vector edit mode: joins the selected points smoothly)", true, |s, p| { + crate::vectoredit::join_in_edit_mode(s, true).unwrap_or_else(|| join(s, p)) + }), ] } diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index dd469c7b..41a359fa 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -205,8 +205,8 @@ pub struct DocState { pub text_edit: Option, /// Hovered node (canvas hover outline). pub hover: Option, - /// Vector edit mode: the vector being edited and its selected vertices. - pub vector_edit: Option<(NodeId, Vec)>, + /// Vector edit mode: the vector being edited, its selected points and the edit tool. + pub vector_edit: Option, pub uid: u64, } @@ -274,6 +274,15 @@ impl DocState { { self.text_edit = None; } + // Vector edit mode ends when its layer is gone (or no longer a vector, e.g. undone). + match self.vector_edit.as_mut() { + Some(ve) if doc.page_of(ve.id) == Some(page) => match vectoredit::network(&doc, ve.id) { + Some(net) => ve.clamp(net), + None => self.vector_edit = None, + }, + Some(_) => self.vector_edit = None, + None => {} + } } } diff --git a/crates/engine/src/tools.rs b/crates/engine/src/tools.rs index 8247c843..a721aebb 100644 --- a/crates/engine/src/tools.rs +++ b/crates/engine/src/tools.rs @@ -171,7 +171,7 @@ impl PointerEvent { pub fn at(kind: PointerKind, x: f64, y: f64, zoom: f64) -> Self { Self { kind, x, y, sx: x * zoom, sy: y * zoom, shift: false, alt: false, cmd: false, ctrl: false, zoom } } - fn p(&self) -> Point { + pub(crate) fn p(&self) -> Point { Point::new(self.x, self.y) } fn tol(&self) -> f64 { @@ -218,10 +218,15 @@ pub struct Overlay { pub drop_target: Option, /// Auto layout insertion indicator (x0, y0, x1, y1). pub insert_line: Option<[f64; 4]>, + /// Vector edit mode: what the pointer is over, the lasso being drawn and the closed area the + /// paint bucket would fill (page-space polygons). + pub vector_hover: Option, + pub lasso: Vec<[f64; 2]>, + pub face: Vec>, } #[derive(Clone, Debug)] -struct ResizeStart { +pub(crate) struct ResizeStart { /// Node id → (world transform, w, h) at the start. nodes: Vec<(NodeId, Affine, f64, f64)>, /// Single node: its world transform and size; else the AABB. @@ -231,7 +236,7 @@ struct ResizeStart { } #[derive(Clone, Debug, Default)] -enum Gesture { +pub(crate) enum Gesture { #[default] None, Marquee { @@ -280,26 +285,8 @@ enum Gesture { PenDrag { anchor: Point, }, - VertexDrag { - start: Point, - id: NodeId, - verts: Vec, - }, - HandleDrag { - id: NodeId, - seg: usize, - start_end: bool, - }, - Bend { - id: NodeId, - seg: usize, - t: f64, - }, - VertexMarquee { - start: Point, - id: NodeId, - base: Vec, - }, + /// Vector edit mode gestures (handled in `vectoredit`). + Vector(crate::vectoredit::VGesture), } /// The pen tool's in-progress path (page coordinates). @@ -315,7 +302,7 @@ pub struct PenPath { #[derive(Clone, Debug, Default)] pub struct ToolState { pub tool: ToolId, - gesture: Gesture, + pub(crate) gesture: Gesture, pub overlay: Overlay, pub pen: Option, /// Tool to return to after a temporary tool (space → hand). @@ -412,6 +399,9 @@ impl Session { if self.tool.tool == ToolId::Pen && t != ToolId::Pen { let _ = self.pen_finish(); } + if !matches!(t, ToolId::Move | ToolId::Scale | ToolId::Hand) && self.ds().is_ok_and(|d| d.vector_edit.is_some()) { + let _ = crate::vectoredit::end(self); + } self.tool.tool = t; self.tool.gesture = Gesture::None; self.tool.overlay = Overlay::default(); @@ -425,17 +415,9 @@ impl Session { /// Feed one pointer event to the current tool. pub fn pointer(&mut self, ev: &PointerEvent) -> Result<()> { - let tool = if ev.kind == PointerKind::Down && ev.ctrl && !ev.cmd && false { ToolId::Hand } else { self.tool.tool }; - if matches!(tool, ToolId::Move | ToolId::Scale) && self.ds().map(|d| d.vector_edit.is_some()).unwrap_or(false) { - match ev.kind { - PointerKind::Down => return self.vector_down(ev), - PointerKind::DoubleClick => return crate::vectoredit::end(self), - PointerKind::Hover => { - self.tool.overlay.cursor = Cursor::Pen; - return Ok(()); - } - _ => {} - } + let tool = self.tool.tool; + if matches!(tool, ToolId::Move | ToolId::Scale) && self.ds().is_ok_and(|d| d.vector_edit.is_some()) && self.vector_pointer(ev)? { + return Ok(()); } match ev.kind { PointerKind::Hover => self.hover(ev), @@ -776,60 +758,7 @@ impl Session { textedit::set_caret(self, idx, true)?; Ok(()) } - Gesture::VertexDrag { start, id, verts } => { - let (id, verts) = (*id, verts.clone()); - let w = self.doc()?.world_transform(id); - let mut d = ev.p() - *start; - if ev.shift { - if d.x.abs() > d.y.abs() { - d.y = 0.0; - } else { - d.x = 0.0; - } - } - // Page delta → local delta. - let inv = w.inverse(); - let ld = inv * (Point::ZERO + d) - inv * Point::ZERO; - self.preview(|doc, _| { - crate::vectoredit::move_vertices(doc, id, &verts, ld)?; - crate::vectoredit::refit(doc, id) - })?; - Ok(()) - } - Gesture::HandleDrag { id, seg, start_end } => { - let (id, seg, se) = (*id, *seg, *start_end); - let lp = self.doc()?.world_transform(id).inverse() * ev.p(); - let alt = ev.alt; - self.preview(|doc, _| { - crate::vectoredit::set_handle(doc, id, seg, se, lp, alt)?; - crate::vectoredit::refit(doc, id) - })?; - Ok(()) - } - Gesture::Bend { id, seg, t } => { - let (id, seg, t) = (*id, *seg, *t); - let lp = self.doc()?.world_transform(id).inverse() * ev.p(); - self.preview(|doc, _| { - crate::vectoredit::bend(doc, id, seg, t, lp)?; - crate::vectoredit::refit(doc, id) - })?; - Ok(()) - } - Gesture::VertexMarquee { start, id, base } => { - let r = Rect::from_points(*start, ev.p()); - self.tool.overlay.marquee = Some([r.x0, r.y0, r.x1, r.y1]); - let mut v = base.clone(); - for i in crate::vectoredit::vertices_in(self.doc()?, *id, r) { - if !v.contains(&i) { - v.push(i); - } - } - let id = *id; - let ds = self.ds_mut()?; - ds.vector_edit = Some((id, v)); - ds.revision += 1; - Ok(()) - } + Gesture::Vector(_) => Ok(()), Gesture::PenDrag { anchor } => { let out = ev.p() - *anchor; if let Some(pen) = self.tool.pen.as_mut() @@ -1238,8 +1167,7 @@ impl Session { } Gesture::TextSelect { .. } | Gesture::Marquee { .. } | Gesture::None => {} Gesture::PenDrag { .. } => {} - Gesture::VertexDrag { .. } | Gesture::HandleDrag { .. } | Gesture::Bend { .. } => self.commit_interaction()?, - Gesture::VertexMarquee { .. } => {} + Gesture::Vector(_) => self.commit_interaction()?, } if let Ok(ds) = self.ds_mut() { ds.revision += 1; @@ -1508,79 +1436,6 @@ impl Session { Ok(()) } - fn vector_down(&mut self, ev: &PointerEvent) -> Result<()> { - let Some((id, sel)) = self.ds()?.vector_edit.clone() else { return Ok(()) }; - let doc = self.doc()?.clone(); - let tol = 6.0 / ev.zoom.max(1e-6); - match crate::vectoredit::hit(&doc, id, &sel, ev.p(), tol) { - Some(crate::vectoredit::VHit::Vertex(v)) => { - let verts = if ev.shift { - let mut s2 = sel.clone(); - if let Some(i) = s2.iter().position(|x| *x == v) { - s2.remove(i); - } else { - s2.push(v); - } - s2 - } else if sel.contains(&v) { - sel.clone() - } else { - vec![v] - }; - let ds = self.ds_mut()?; - ds.vector_edit = Some((id, verts.clone())); - self.begin_interaction("Move points")?; - self.tool.gesture = Gesture::VertexDrag { start: ev.p(), id, verts }; - } - Some(crate::vectoredit::VHit::Handle { seg, start }) => { - self.begin_interaction("Edit handle")?; - self.tool.gesture = Gesture::HandleDrag { id, seg, start_end: start }; - } - Some(crate::vectoredit::VHit::Segment { seg, t }) => { - if ev.cmd { - self.begin_interaction("Bend")?; - self.tool.gesture = Gesture::Bend { id, seg, t }; - } else if ev.alt || ev.shift { - // Add a point on the segment. - self.begin_interaction("Add point")?; - let mut v = 0; - self.preview(|doc, _| { - v = crate::vectoredit::split_segment(doc, id, seg, t)?; - Ok(()) - })?; - let ds = self.ds_mut()?; - ds.vector_edit = Some((id, vec![v])); - self.tool.gesture = Gesture::VertexDrag { start: ev.p(), id, verts: vec![v] }; - } else { - // Select the segment's end points and drag them together. - let net_seg = match &doc.node(id).map(|n| &n.kind) { - Some(NodeKind::Vector { network }) => network.segments.get(seg).copied(), - _ => None, - }; - let verts: Vec = net_seg.map(|s| vec![s.a, s.b]).unwrap_or_default(); - let ds = self.ds_mut()?; - ds.vector_edit = Some((id, verts.clone())); - self.begin_interaction("Move segment")?; - self.tool.gesture = Gesture::VertexDrag { start: ev.p(), id, verts }; - } - } - None => { - // Outside the shape entirely (and not shift): leave edit mode. - let inside = doc.world_render_bounds(id).is_some_and(|b| b.inflate(tol * 4.0, tol * 4.0).contains(ev.p())); - if !inside && !ev.shift { - crate::vectoredit::end(self)?; - return self.move_down(ev); - } - let base = if ev.shift { sel } else { vec![] }; - let ds = self.ds_mut()?; - ds.vector_edit = Some((id, base.clone())); - ds.revision += 1; - self.tool.gesture = Gesture::VertexMarquee { start: ev.p(), id, base }; - } - } - Ok(()) - } - /// Keyboard Escape: cancel gestures, finish pens, leave text editing, then deselect. pub fn escape(&mut self) -> Result<()> { if self.tool.pen.is_some() { @@ -1595,7 +1450,7 @@ impl Session { return textedit::end(self); } if self.ds()?.vector_edit.is_some() { - return crate::vectoredit::end(self); + return crate::vectoredit::escape(self); } if self.tool.tool != ToolId::Move { self.set_tool(ToolId::Move); diff --git a/crates/engine/src/vectoredit.rs b/crates/engine/src/vectoredit.rs index f38adb62..7b7e8fda 100644 --- a/crates/engine/src/vectoredit.rs +++ b/crates/engine/src/vectoredit.rs @@ -1,21 +1,114 @@ -//! Vector edit mode: editing a vector network's vertices and bezier handles on the canvas. +//! Vector edit mode: editing a vector network's points, segments and bezier handles on the canvas, +//! with its own tools (move, pen, bend, paint bucket, lasso, cut). //! //! Entering edit mode on a non-vector shape converts it to a vector first (like the incumbent). //! Vertex coordinates are node-local; after each edit the node is re-fitted so its box wraps the -//! network again. +//! network again. The network edits themselves live in [`ops`]; pointer gestures in `pointer.rs`. + +pub mod ops; +mod pointer; +#[cfg(test)] +mod tests; use figcraft_doc::*; use figcraft_geom::{Affine, Point, Rect, Vec2}; +use serde::Serialize; use serde_json::{Value, json}; use crate::cmd::CommandSpec; use crate::params::*; use crate::{EngineError, Result, Session, bad, spec}; +pub(crate) use pointer::VGesture; + +/// The edit-mode tools (the toolbar shown while editing a vector). +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Default)] +pub enum VTool { + #[default] + Move, + Pen, + Bend, + Paint, + Lasso, + Cut, +} + +impl VTool { + pub const ALL: [VTool; 6] = [VTool::Move, VTool::Pen, VTool::Bend, VTool::Paint, VTool::Lasso, VTool::Cut]; + pub fn id(self) -> &'static str { + match self { + VTool::Move => "move", + VTool::Pen => "pen", + VTool::Bend => "bend", + VTool::Paint => "paint", + VTool::Lasso => "lasso", + VTool::Cut => "cut", + } + } + pub fn from_id(s: &str) -> Option { + VTool::ALL.into_iter().find(|t| t.id().eq_ignore_ascii_case(s)) + } + pub fn label(self) -> &'static str { + match self { + VTool::Move => "Move", + VTool::Pen => "Pen", + VTool::Bend => "Bend", + VTool::Paint => "Paint bucket", + VTool::Lasso => "Lasso", + VTool::Cut => "Cut", + } + } + /// Catalog-style shortcut ("Shift+B"); the Bend tool is held with Cmd (Ctrl elsewhere). + pub fn shortcut(self) -> &'static str { + match self { + VTool::Move => "V", + VTool::Pen => "P", + VTool::Bend => "Cmd", + VTool::Paint => "Shift+B", + VTool::Lasso => "Q", + VTool::Cut => "X", + } + } +} + +/// Vector edit mode state: the vector being edited, its selected points and segments, the active +/// edit tool and the pen's open end. +#[derive(Clone, Debug, PartialEq)] +pub struct VectorEdit { + pub id: NodeId, + pub vertices: Vec, + pub segments: Vec, + pub tool: VTool, + /// Pen: the point the next click continues from. + pub anchor: Option, + /// Pen: the outgoing handle dragged out of `anchor`, used by the next segment. + pub pen_out: Option<(f64, f64)>, +} + +impl VectorEdit { + pub fn new(id: NodeId) -> Self { + Self { id, vertices: vec![], segments: vec![], tool: VTool::Move, anchor: None, pen_out: None } + } + + /// Drop indices that no longer exist (after undo or an edit). + pub fn clamp(&mut self, net: &VectorNetwork) { + let (nv, ns) = (net.vertices.len(), net.segments.len()); + self.vertices.retain(|v| *v < nv); + self.segments.retain(|s| *s < ns); + if self.anchor.is_some_and(|a| a >= nv) { + self.anchor = None; + self.pen_out = None; + } + } +} + /// What a pointer is over in edit mode. -#[derive(Clone, Copy, Debug, PartialEq)] +#[derive(Clone, Copy, Debug, PartialEq, Serialize)] +#[serde(rename_all = "camelCase", tag = "kind")] pub enum VHit { - Vertex(usize), + Vertex { + index: usize, + }, /// Handle of segment `seg`; `start` = the handle at the segment's `a` end. Handle { seg: usize, @@ -27,6 +120,28 @@ pub enum VHit { }, } +/// A visible handle in page coordinates. +#[derive(Clone, Copy, Debug, PartialEq, Serialize)] +pub struct HandleLine { + pub seg: usize, + pub start: bool, + pub vertex: [f64; 2], + pub handle: [f64; 2], +} + +/// Page-space geometry for drawing the edit overlay. +#[derive(Clone, Debug, Default, PartialEq, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct EditOverlay { + /// Cubic control points per segment. + pub segments: Vec<[[f64; 2]; 4]>, + pub vertices: Vec<[f64; 2]>, + pub handles: Vec, + pub selected_vertices: Vec, + pub selected_segments: Vec, + pub anchor: Option, +} + /// Convert a shape to an editable vector (keeps paints, transform and look). pub fn ensure_vector(doc: &mut Document, id: NodeId) -> Result<()> { let n = doc.get(id)?.clone(); @@ -62,7 +177,7 @@ pub fn refit(doc: &mut Document, id: NodeId) -> Result<()> { let n = doc.get_mut(id)?; let NodeKind::Vector { network } = &mut n.kind else { return Ok(()) }; let Some(b) = network.bounds() else { return Ok(()) }; - if !(b.x0.is_finite() && b.y0.is_finite()) { + if !(b.x0.is_finite() && b.y0.is_finite() && b.width().is_finite() && b.height().is_finite()) { return Ok(()); } if b.x0.abs() > 1e-9 || b.y0.abs() > 1e-9 { @@ -74,243 +189,75 @@ pub fn refit(doc: &mut Document, id: NodeId) -> Result<()> { Ok(()) } -fn network(doc: &Document, id: NodeId) -> Option<&VectorNetwork> { +/// The network of vector `id`. +pub fn network(doc: &Document, id: NodeId) -> Option<&VectorNetwork> { match &doc.node(id)?.kind { NodeKind::Vector { network } => Some(network), _ => None, } } -fn network_mut(doc: &mut Document, id: NodeId) -> Option<&mut VectorNetwork> { - match &mut doc.node_mut(id)?.kind { - NodeKind::Vector { network } => Some(network), - _ => None, +fn network_mut(doc: &mut Document, id: NodeId) -> Result<&mut VectorNetwork> { + match doc.node_mut(id).map(|n| &mut n.kind) { + Some(NodeKind::Vector { network }) => Ok(network), + _ => Err(EngineError::Other("not a vector".into())), } } -/// Hit test in page coordinates with a tolerance in page units. Handles of selected vertices win, -/// then vertices, then segments. -pub fn hit(doc: &Document, id: NodeId, selected: &[usize], p: Point, tol: f64) -> Option { - let net = network(doc, id)?; - let w = doc.world_transform(id); +/// Edit the network of `id`, then re-fit the node. +pub fn edit(doc: &mut Document, id: NodeId, f: impl FnOnce(&mut VectorNetwork) -> T) -> Result { + let out = f(network_mut(doc, id)?); + refit(doc, id)?; + Ok(out) +} + +/// Handles drawn and hit-tested: at selected points, and at both ends of selected segments. +fn visible_handles(net: &VectorNetwork, ve: &VectorEdit) -> Vec<(usize, bool)> { + let mut out = Vec::new(); + for (si, s) in net.segments.iter().enumerate() { + let seg_on = ve.segments.contains(&si); + for (start, vi, t) in [(true, s.a, s.ta), (false, s.b, s.tb)] { + if t != (0.0, 0.0) && (seg_on || ve.vertices.contains(&vi)) { + out.push((si, start)); + } + } + } + out +} + +/// Hit test in page coordinates with a tolerance in page units. Visible handles win, then +/// vertices, then segments. +pub fn hit(doc: &Document, ve: &VectorEdit, p: Point, tol: f64) -> Option { + let net = network(doc, ve.id)?; + let w = doc.world_transform(ve.id); let lp = w.inverse() * p; // Tolerance in local units (approximate for non-uniform scale). let s = (w.determinant().abs()).sqrt().max(1e-9); let tl = tol / s; - for (si, seg) in net.segments.iter().enumerate() { - for (start, vi, t) in [(true, seg.a, seg.ta), (false, seg.b, seg.tb)] { - if !selected.contains(&vi) || t == (0.0, 0.0) { - continue; - } - let Some(v) = net.vertices.get(vi) else { continue }; - if (Point::new(v.x + t.0, v.y + t.1) - lp).hypot() <= tl { - return Some(VHit::Handle { seg: si, start }); - } + if !(lp.x.is_finite() && lp.y.is_finite()) { + return None; + } + for (si, start) in visible_handles(net, ve) { + let (Some(seg), Some(t)) = (net.segments.get(si), net.handle(si, start)) else { continue }; + let Some(v) = net.vertices.get(if start { seg.a } else { seg.b }) else { continue }; + if (Point::new(v.x + t.0, v.y + t.1) - lp).hypot() <= tl { + return Some(VHit::Handle { seg: si, start }); } } - for (vi, v) in net.vertices.iter().enumerate() { - if (v.point() - lp).hypot() <= tl { - return Some(VHit::Vertex(vi)); - } + let nearest_vertex = + net.vertices.iter().enumerate().map(|(i, v)| (i, (v.point() - lp).hypot())).filter(|(_, d)| *d <= tl).min_by(|a, b| a.1.total_cmp(&b.1)); + if let Some((index, _)) = nearest_vertex { + return Some(VHit::Vertex { index }); } - use figcraft_geom::kurbo::{CubicBez, ParamCurveNearest}; - for (si, seg) in net.segments.iter().enumerate() { - let (Some(a), Some(b)) = (net.vertices.get(seg.a), net.vertices.get(seg.b)) else { continue }; - let c = CubicBez::new(a.point(), Point::new(a.x + seg.ta.0, a.y + seg.ta.1), Point::new(b.x + seg.tb.0, b.y + seg.tb.1), b.point()); - let near = c.nearest(lp, 0.01); - if near.distance_sq.sqrt() <= tl { - return Some(VHit::Segment { seg: si, t: near.t }); - } - } - None -} - -/// Move vertices by `d` (local units); their handles move with them. -pub fn move_vertices(doc: &mut Document, id: NodeId, idx: &[usize], d: Vec2) -> Result<()> { - let net = network_mut(doc, id).ok_or_else(|| EngineError::Other("not a vector".into()))?; - for i in idx { - if let Some(v) = net.vertices.get_mut(*i) { - v.x += d.x; - v.y += d.y; - } - } - Ok(()) -} - -/// Set a handle to absolute local position `p`; the opposite handle at the same vertex mirrors -/// (angle and length) unless `independent`. -pub fn set_handle(doc: &mut Document, id: NodeId, seg: usize, start: bool, p: Point, independent: bool) -> Result<()> { - let net = network_mut(doc, id).ok_or_else(|| EngineError::Other("not a vector".into()))?; - let Some(s) = net.segments.get(seg).copied() else { return Err(EngineError::Other("no such segment".into())) }; - let vi = if start { s.a } else { s.b }; - let Some(v) = net.vertices.get(vi).copied() else { return Ok(()) }; - let rel = (p.x - v.x, p.y - v.y); - if let Some(sm) = net.segments.get_mut(seg) { - if start { - sm.ta = rel; - } else { - sm.tb = rel; - } - } - if !independent { - // Mirror on the other segment meeting at this vertex (smooth node). - let others: Vec<(usize, bool)> = net - .segments - .iter() - .enumerate() - .filter(|(i, _)| *i != seg) - .filter_map(|(i, o)| { - if o.a == vi { - Some((i, true)) - } else if o.b == vi { - Some((i, false)) - } else { - None - } - }) - .collect(); - if let [(oi, ostart)] = others.as_slice() - && let Some(o) = net.segments.get_mut(*oi) - { - let m = (-rel.0, -rel.1); - if *ostart { - o.ta = m; - } else { - o.tb = m; - } - } - } - Ok(()) -} - -/// Bend a segment so its curve passes through `p` at parameter `t` (the Bend tool). -pub fn bend(doc: &mut Document, id: NodeId, seg: usize, t: f64, p: Point) -> Result<()> { - let net = network_mut(doc, id).ok_or_else(|| EngineError::Other("not a vector".into()))?; - let Some(s) = net.segments.get(seg).copied() else { return Ok(()) }; - let (Some(a), Some(b)) = (net.vertices.get(s.a).copied(), net.vertices.get(s.b).copied()) else { return Ok(()) }; - let t = t.clamp(0.05, 0.95); - // Controls at the chord's thirds plus a shared offset: B(t) = L(t) + 3t(1-t)·off. - let (a, b) = (a.point(), b.point()); - let k = 3.0 * t * (1.0 - t); - let line = a.lerp(b, t); - let off = (p - line) / k; - let c1 = a + (b - a) / 3.0 + off; - let c2 = b + (a - b) / 3.0 + off; - if let Some(sm) = net.segments.get_mut(seg) { - sm.ta = (c1.x - a.x, c1.y - a.y); - sm.tb = (c2.x - b.x, c2.y - b.y); - } - Ok(()) -} - -/// Delete vertices, joining their neighbours where a vertex had exactly two segments ("heal"). -pub fn delete_vertices(doc: &mut Document, id: NodeId, idx: &[usize], heal: bool) -> Result<()> { - let net = network_mut(doc, id).ok_or_else(|| EngineError::Other("not a vector".into()))?; - let mut idx: Vec = idx.to_vec(); - idx.sort_unstable(); - idx.dedup(); - for &vi in idx.iter().rev() { - if vi >= net.vertices.len() { - continue; - } - let touching: Vec = net.segments.iter().enumerate().filter(|(_, s)| s.a == vi || s.b == vi).map(|(i, _)| i).collect(); - let mut new_seg = None; - if heal && let [s1, s2] = touching.as_slice() { - let (Some(x), Some(y)) = (net.segments.get(*s1).copied(), net.segments.get(*s2).copied()) else { continue }; - let o1 = if x.a == vi { (x.b, x.tb) } else { (x.a, x.ta) }; - let o2 = if y.a == vi { (y.b, y.tb) } else { (y.a, y.ta) }; - new_seg = Some(Segment { a: o1.0, b: o2.0, ta: o1.1, tb: o2.1 }); - } - // Remove touching segments (descending) and fix region loops. - let mut seg_map: Vec> = (0..net.segments.len()).map(Some).collect(); - for &si in touching.iter().rev() { - net.segments.remove(si); - if let Some(m) = seg_map.get_mut(si) { - *m = None; - } - } - for (k, m) in seg_map.iter_mut().flatten().enumerate() { - *m = k; - } - let healed_index = new_seg.map(|s| { - net.segments.push(s); - net.segments.len() - 1 - }); - for r in &mut net.regions { - for lp in &mut r.loops { - let mut out = Vec::new(); - let mut inserted = false; - for si in lp.iter() { - match seg_map.get(*si).copied().flatten() { - Some(n) => out.push(n), - None => { - if let (Some(h), false) = (healed_index, inserted) { - out.push(h); - inserted = true; - } - } - } - } - *lp = out; - } - r.loops.retain(|l| l.len() >= 2); - } - net.regions.retain(|r| !r.loops.is_empty()); - // Remove the vertex and shift indices. - net.vertices.remove(vi); - for s in &mut net.segments { - if s.a > vi { - s.a -= 1; - } - if s.b > vi { - s.b -= 1; - } - } - } - net.sanitize(); - Ok(()) -} - -/// Split segment `seg` at `t`, inserting a vertex; returns its index. -pub fn split_segment(doc: &mut Document, id: NodeId, seg: usize, t: f64) -> Result { - use figcraft_geom::kurbo::{CubicBez, ParamCurve}; - let net = network_mut(doc, id).ok_or_else(|| EngineError::Other("not a vector".into()))?; - let s = net.segments.get(seg).copied().ok_or_else(|| EngineError::Other("no such segment".into()))?; - let (Some(a), Some(b)) = (net.vertices.get(s.a).copied(), net.vertices.get(s.b).copied()) else { - return Err(EngineError::Other("bad segment".into())); - }; - let c = CubicBez::new(a.point(), Point::new(a.x + s.ta.0, a.y + s.ta.1), Point::new(b.x + s.tb.0, b.y + s.tb.1), b.point()); - let t = t.clamp(0.01, 0.99); - let l = c.subsegment(0.0..t); - let r = c.subsegment(t..1.0); - net.vertices.push(Vertex::new(l.p3.x, l.p3.y)); - let mid = net.vertices.len() - 1; - let straight = s.is_straight(); - if let Some(sm) = net.segments.get_mut(seg) { - sm.b = mid; - if straight { - sm.ta = (0.0, 0.0); - sm.tb = (0.0, 0.0); - } else { - sm.ta = (l.p1.x - l.p0.x, l.p1.y - l.p0.y); - sm.tb = (l.p2.x - l.p3.x, l.p2.y - l.p3.y); - } - } - let new_seg = if straight { - Segment::line(mid, s.b) - } else { - Segment { a: mid, b: s.b, ta: (r.p1.x - r.p0.x, r.p1.y - r.p0.y), tb: (r.p2.x - r.p3.x, r.p2.y - r.p3.y) } - }; - net.segments.push(new_seg); - let ni = net.segments.len() - 1; - for reg in &mut net.regions { - for lp in &mut reg.loops { - if let Some(pos) = lp.iter().position(|x| *x == seg) { - lp.insert(pos + 1, ni); - } - } - } - Ok(mid) + use figcraft_geom::kurbo::ParamCurveNearest; + let nearest_seg = (0..net.segments.len()) + .filter_map(|si| { + let near = net.cubic(si)?.nearest(lp, 0.01); + Some((si, near.t, near.distance_sq.sqrt())) + }) + .filter(|(_, _, d)| *d <= tl) + .min_by(|a, b| a.2.total_cmp(&b.2)); + nearest_seg.map(|(seg, t, _)| VHit::Segment { seg, t }) } /// Vertices inside a page-space rectangle. @@ -320,36 +267,41 @@ pub fn vertices_in(doc: &Document, id: NodeId, r: Rect) -> Vec { net.vertices.iter().enumerate().filter(|(_, v)| r.contains(w * v.point())).map(|(i, _)| i).collect() } -/// Page-space geometry of the network for drawing the edit overlay: segments (as cubic control -/// points), vertices, and handles of the selected vertices. -pub fn overlay(doc: &Document, id: NodeId, selected: &[usize]) -> Option { - let net = network(doc, id)?; +/// Vertices inside a page-space lasso polygon. +pub fn vertices_in_polygon(doc: &Document, id: NodeId, poly: &[Point]) -> Vec { + let Some(net) = network(doc, id) else { return vec![] }; let w = doc.world_transform(id); - let p = |x: f64, y: f64| { - let q = w * Point::new(x, y); - json!([q.x, q.y]) + let pts: Vec = net.vertices.iter().map(|v| w * v.point()).collect(); + ops::in_polygon(&pts, poly) +} + +/// Page-space geometry of the network for drawing the edit overlay. +pub fn overlay(doc: &Document, ve: &VectorEdit) -> Option { + let net = network(doc, ve.id)?; + let w = doc.world_transform(ve.id); + let p = |q: Point| { + let q = w * q; + [q.x, q.y] }; - let segs: Vec = net - .segments - .iter() - .filter_map(|s| { - let (a, b) = (net.vertices.get(s.a)?, net.vertices.get(s.b)?); - Some(json!([p(a.x, a.y), p(a.x + s.ta.0, a.y + s.ta.1), p(b.x + s.tb.0, b.y + s.tb.1), p(b.x, b.y)])) + let segments = (0..net.segments.len()).filter_map(|i| net.cubic(i)).map(|c| [p(c.p0), p(c.p1), p(c.p2), p(c.p3)]).collect(); + let vertices = net.vertices.iter().map(|v| p(v.point())).collect(); + let handles = visible_handles(net, ve) + .into_iter() + .filter_map(|(si, start)| { + let s = net.segments.get(si)?; + let v = net.vertices.get(if start { s.a } else { s.b })?; + let t = net.handle(si, start)?; + Some(HandleLine { seg: si, start, vertex: p(v.point()), handle: p(Point::new(v.x + t.0, v.y + t.1)) }) }) .collect(); - let verts: Vec = net.vertices.iter().map(|v| p(v.x, v.y)).collect(); - let mut handles = Vec::new(); - for s in &net.segments { - for (vi, t) in [(s.a, s.ta), (s.b, s.tb)] { - if selected.contains(&vi) - && t != (0.0, 0.0) - && let Some(v) = net.vertices.get(vi) - { - handles.push(json!([p(v.x, v.y), p(v.x + t.0, v.y + t.1)])); - } - } - } - Some(json!({"segments": segs, "vertices": verts, "handles": handles, "selected": selected})) + Some(EditOverlay { + segments, + vertices, + handles, + selected_vertices: ve.vertices.clone(), + selected_segments: ve.segments.clone(), + anchor: ve.anchor, + }) } /// Start editing `id` as a vector. @@ -364,7 +316,7 @@ pub fn begin(s: &mut Session, id: NodeId) -> Result<()> { ds.history.undo.push(crate::HistoryEntry { label: "Edit vector".into(), doc: before, selection: ds.selection.clone(), page: ds.page }); ds.history.redo.clear(); } - ds.vector_edit = Some((id, vec![])); + ds.vector_edit = Some(VectorEdit::new(id)); ds.selection = vec![id]; ds.text_edit = None; ds.revision += 1; @@ -375,13 +327,179 @@ pub fn end(s: &mut Session) -> Result<()> { let ds = s.ds_mut()?; ds.vector_edit = None; ds.revision += 1; + s.tool.overlay = Default::default(); Ok(()) } -fn editing(s: &Session) -> Result<(NodeId, Vec)> { +pub fn editing(s: &Session) -> Result { s.ds()?.vector_edit.clone().ok_or_else(|| EngineError::Disabled("vector".into(), "not in vector edit mode".into())) } +/// Replace the edit state (selection, tool, pen end) and repaint. +pub(crate) fn set_state(s: &mut Session, f: impl FnOnce(&mut VectorEdit)) -> Result<()> { + let ds = s.ds_mut()?; + if let Some(ve) = ds.vector_edit.as_mut() { + f(ve); + } + ds.revision += 1; + Ok(()) +} + +pub fn set_tool(s: &mut Session, tool: VTool) -> Result<()> { + s.tool.overlay = Default::default(); + set_state(s, |ve| { + ve.tool = tool; + if tool != VTool::Pen { + ve.anchor = None; + ve.pen_out = None; + } + }) +} + +/// Escape: end the pen's path first, then leave edit mode. +pub fn escape(s: &mut Session) -> Result<()> { + let ve = editing(s)?; + if ve.anchor.is_some() { + s.tool.overlay.rubber = None; + return set_state(s, |ve| { + ve.anchor = None; + ve.pen_out = None; + }); + } + end(s) +} + +/// Parse `[i, ...]` from params. +fn indices(p: &Value, key: &str) -> Option> { + match get(p, key) { + Some(Value::Array(a)) => Some(a.iter().filter_map(f64_of).filter(|x| *x >= 0.0 && *x < 1e9).map(|x| x as usize).collect()), + _ => None, + } +} + +fn index(cmd: &str, p: &Value, key: &str) -> Result { + let v = req_num(cmd, p, key)?; + if !(0.0..1e9).contains(&v) { + return Err(bad(cmd, format!("`{key}` out of range"))); + } + Ok(v as usize) +} + +/// Delete the selected points and segments (`heal` keeps paths through deleted points closed). +fn delete_selection(s: &mut Session, verts: Vec, segs: Vec, heal: bool) -> Result<()> { + let id = editing(s)?.id; + edit(s.doc_mut()?, id, |net| { + // Segments first (their indices refer to the network before points go). + let segs: Vec = + segs.into_iter().filter(|si| net.segments.get(*si).is_some_and(|x| !verts.contains(&x.a) && !verts.contains(&x.b))).collect(); + let pts: Vec = verts.iter().filter_map(|v| net.vertices.get(*v)).map(|v| v.point()).collect(); + ops::remove_segments(net, &segs); + // Point indices may have shifted: find them again by position. + let now: Vec = pts.iter().filter_map(|p| net.vertices.iter().position(|v| v.point() == *p)).collect(); + ops::delete_vertices(net, &now, heal); + })?; + set_state(s, |ve| { + ve.vertices.clear(); + ve.segments.clear(); + ve.anchor = None; + ve.pen_out = None; + }) +} + +/// Selection bounds' top-left in the parent's coordinates (what the X/Y fields show). +pub fn selection_position(doc: &Document, ve: &VectorEdit) -> Option { + let net = network(doc, ve.id)?; + let t = doc.node(ve.id)?.transform; + let pts: Vec = selected_points(net, ve).into_iter().filter_map(|v| net.vertices.get(v)).map(|v| t * v.point()).collect(); + let x = pts.iter().map(|p| p.x).fold(f64::INFINITY, f64::min); + let y = pts.iter().map(|p| p.y).fold(f64::INFINITY, f64::min); + (x.is_finite() && y.is_finite()).then(|| Point::new(x, y)) +} + +fn default_points(s: &Session, ve: &VectorEdit) -> Vec { + s.doc().ok().and_then(|d| network(d, ve.id)).map(|n| selected_points(n, ve)).unwrap_or_default() +} + +/// Selected points plus the ends of selected segments. +pub fn selected_points(net: &VectorNetwork, ve: &VectorEdit) -> Vec { + let mut v = ve.vertices.clone(); + for s in ve.segments.iter().filter_map(|i| net.segments.get(*i)) { + v.extend([s.a, s.b]); + } + v.sort_unstable(); + v.dedup(); + v +} + +/// Keyboard in edit mode. Returns whether the key was used (others fall through to shortcuts). +pub fn key(s: &mut Session, name: &str, shift: bool, alt: bool, cmd: bool) -> Result { + let Ok(ve) = editing(s) else { return Ok(false) }; + let nudge = |big: bool, s: &Session| if big { s.prefs.nudge_big } else { s.prefs.nudge_small }; + let arrow = match name { + "Left" | "ArrowLeft" => Some((-1.0, 0.0)), + "Right" | "ArrowRight" => Some((1.0, 0.0)), + "Up" | "ArrowUp" => Some((0.0, -1.0)), + "Down" | "ArrowDown" => Some((0.0, 1.0)), + _ => None, + }; + if let Some((dx, dy)) = arrow { + if cmd || alt { + return Ok(false); + } + let n = nudge(shift, s); + s.execute("vector.edit.nudge", &json!({"dx": dx * n, "dy": dy * n}))?; + return Ok(true); + } + match (name, shift, alt, cmd) { + ("Escape", ..) => escape(s)?, + ("Enter", ..) => { + if ve.anchor.is_some() { + escape(s)?; + } else { + end(s)?; + } + } + ("Backspace" | "Delete", heal, false, false) => { + s.execute(if heal { "vector.deleteHeal" } else { "vector.edit.delete" }, &json!({}))?; + } + ("A", false, false, true) => { + s.execute("vector.edit.selectAll", &json!({}))?; + } + ("J", smooth, false, true) => { + s.execute(if smooth { "vector.smoothJoin" } else { "vector.join" }, &json!({}))?; + } + ("V", false, false, false) => set_tool(s, VTool::Move)?, + ("P", false, false, false) => set_tool(s, VTool::Pen)?, + ("B", true, false, false) => set_tool(s, VTool::Paint)?, + ("Q", false, false, false) => set_tool(s, VTool::Lasso)?, + ("X", false, false, false) => set_tool(s, VTool::Cut)?, + _ => return Ok(false), + } + Ok(true) +} + +fn join_cmd(s: &mut Session, smooth: bool) -> Result { + let ve = editing(s)?; + let doc = s.doc()?; + let net = network(doc, ve.id).ok_or_else(|| bad("vector.join", "not a vector"))?; + let verts = selected_points(net, &ve); + let joins = edit(s.doc_mut()?, ve.id, |net| ops::join(net, &verts, smooth))?; + set_state(s, |ve| ve.segments.clear())?; + Ok(json!({"joins": joins})) +} + +/// `vector.join` / `vector.smoothJoin` while editing: join the selected points. +pub fn join_in_edit_mode(s: &mut Session, smooth: bool) -> Option> { + editing(s).ok()?; + Some(join_cmd(s, smooth)) +} + +/// Page point → the edited node's local coordinates. +fn local(s: &Session, id: NodeId, p: &Value, cmd: &str) -> Result { + let pt = Point::new(req_num(cmd, p, "x")?, req_num(cmd, p, "y")?); + Ok(s.doc()?.world_transform(id).inverse() * pt) +} + pub fn specs() -> Vec { vec![ spec!("vector.edit.begin", "Edit vector", "{id?} (converts shapes to vectors)", false, |s, p| { @@ -393,89 +511,252 @@ pub fn specs() -> Vec { end(s)?; Ok(json!({"ok": true})) }), - spec!("vector.edit.state", "Vector edit state", "{}", false, |s, _| { - let (id, sel) = editing(s)?; - Ok(overlay(s.doc()?, id, &sel).unwrap_or(Value::Null)) + spec!("vector.edit.state", "Vector edit state", "{} → page-space overlay plus the local network", false, |s, _| { + let ve = editing(s)?; + let doc = s.doc()?; + let o = overlay(doc, &ve).map(|o| serde_json::to_value(o).unwrap_or(Value::Null)).unwrap_or(Value::Null); + let net = network(doc, ve.id).map(|n| serde_json::to_value(n).unwrap_or(Value::Null)).unwrap_or(Value::Null); + let mirroring: Vec<&str> = network(doc, ve.id).map(|n| (0..n.vertices.len()).map(|v| n.mirroring(v).id()).collect()).unwrap_or_default(); + Ok(json!({"id": ve.id, "tool": ve.tool.id(), "overlay": o, "network": net, "mirroring": mirroring})) }), - spec!("vector.edit.select", "Select vertices", "{vertices: [i, ...]}", false, |s, p| { - let (id, _) = editing(s)?; - let v: Vec = match get(p, "vertices") { - Some(Value::Array(a)) => a.iter().filter_map(f64_of).map(|x| x.max(0.0) as usize).collect(), - _ => vec![], - }; + spec!("vector.edit.tool", "Vector edit tool", "{tool: move|pen|bend|paint|lasso|cut}", false, |s, p| { + editing(s)?; + let t = string(p, "tool").and_then(|t| VTool::from_id(&t)).ok_or_else(|| bad("vector.edit.tool", "unknown tool"))?; + set_tool(s, t)?; + Ok(json!({"tool": t.id()})) + }), + spec!("vector.edit.select", "Select points", "{vertices?: [i, ...], segments?: [i, ...], add?}", false, |s, p| { + editing(s)?; + let (v, sg, add) = + (indices(p, "vertices").unwrap_or_default(), indices(p, "segments").unwrap_or_default(), boolean(p, "add").unwrap_or(false)); + set_state(s, |ve| { + if !add { + ve.vertices.clear(); + ve.segments.clear(); + } + ve.vertices.extend(v); + ve.segments.extend(sg); + })?; + let doc = s.doc()?.clone(); let ds = s.ds_mut()?; - ds.vector_edit = Some((id, v)); - ds.revision += 1; + if let Some(ve) = ds.vector_edit.as_mut() + && let Some(net) = network(&doc, ve.id) + { + ve.vertices.sort_unstable(); + ve.vertices.dedup(); + ve.segments.sort_unstable(); + ve.segments.dedup(); + ve.clamp(net); + } Ok(json!({"ok": true})) }), - spec!("vector.edit.moveVertices", "Move vertices", "{vertices?, dx, dy} (local units; default the selected vertices)", true, |s, p| { - let (id, sel) = editing(s)?; - let v: Vec = match get(p, "vertices") { - Some(Value::Array(a)) => a.iter().filter_map(f64_of).map(|x| x.max(0.0) as usize).collect(), - _ => sel, - }; + spec!("vector.edit.selectAll", "Select all points", "{}", false, |s, _| { + let ve = editing(s)?; + let n = network(s.doc()?, ve.id).map(|n| n.vertices.len()).unwrap_or(0); + set_state(s, |ve| { + ve.vertices = (0..n).collect(); + ve.segments.clear(); + })?; + Ok(json!({"count": n})) + }), + spec!("vector.edit.moveVertices", "Move points", "{vertices?, dx, dy} (local units; default the selected points)", true, |s, p| { + let ve = editing(s)?; + let v = indices(p, "vertices").unwrap_or_else(|| default_points(s, &ve)); let d = Vec2::new(num_or(p, "dx", 0.0), num_or(p, "dy", 0.0)); - let doc = s.doc_mut()?; - move_vertices(doc, id, &v, d)?; - refit(doc, id)?; + edit(s.doc_mut()?, ve.id, |net| ops::move_vertices(net, &v, d))?; + Ok(json!({"ok": true})) + }), + spec!("vector.edit.nudge", "Nudge points", "{dx, dy} (page units)", true, |s, p| { + let ve = editing(s)?; + let doc = s.doc()?; + let v = network(doc, ve.id).map(|n| selected_points(n, &ve)).unwrap_or_default(); + let inv = doc.world_transform(ve.id).inverse(); + let d = inv * (Point::ZERO + Vec2::new(num_or(p, "dx", 0.0), num_or(p, "dy", 0.0))) - inv * Point::ZERO; + edit(s.doc_mut()?, ve.id, |net| ops::move_vertices(net, &v, d))?; + Ok(json!({"ok": true})) + }), + spec!("vector.edit.position", "Point position", "{x?, y?} (the selected points' top-left, in the parent's coordinates)", true, |s, p| { + let ve = editing(s)?; + let doc = s.doc()?; + let cur = selection_position(doc, &ve).ok_or_else(|| bad("vector.edit.position", "select points"))?; + let target = Point::new(num_or(p, "x", cur.x), num_or(p, "y", cur.y)); + let t = doc.node(ve.id).map(|n| n.transform).unwrap_or_default(); + let inv = t.inverse(); + let d = inv * target - inv * cur; + let v = network(doc, ve.id).map(|n| selected_points(n, &ve)).unwrap_or_default(); + edit(s.doc_mut()?, ve.id, |net| ops::move_vertices(net, &v, d))?; Ok(json!({"ok": true})) }), spec!("vector.edit.setHandle", "Set handle", "{segment, start (bool), x, y (local), independent?}", true, |s, p| { - let (id, _) = editing(s)?; - let seg = req_num("vector.edit.setHandle", p, "segment")?.max(0.0) as usize; + let ve = editing(s)?; + let seg = index("vector.edit.setHandle", p, "segment")?; let start = boolean(p, "start").unwrap_or(true); let pt = Point::new(req_num("vector.edit.setHandle", p, "x")?, req_num("vector.edit.setHandle", p, "y")?); - let doc = s.doc_mut()?; - set_handle(doc, id, seg, start, pt, boolean(p, "independent").unwrap_or(false))?; - refit(doc, id)?; + let independent = boolean(p, "independent").unwrap_or(false); + edit(s.doc_mut()?, ve.id, |net| { + let Some(sg) = net.segments.get(seg).copied() else { return }; + let Some(v) = net.vertices.get(if start { sg.a } else { sg.b }).copied() else { return }; + ops::set_handle(net, seg, start, (pt.x - v.x, pt.y - v.y), independent); + })?; + Ok(json!({"ok": true})) + }), + spec!("vector.edit.mirroring", "Handle mirroring", "{mode: none|angle|angleAndLength, vertices?}", true, |s, p| { + let ve = editing(s)?; + let mode = string(p, "mode") + .and_then(|m| HandleMirroring::from_id(&m)) + .ok_or_else(|| bad("vector.edit.mirroring", "mode: none, angle or angleAndLength"))?; + let v = indices(p, "vertices").unwrap_or_else(|| default_points(s, &ve)); + edit(s.doc_mut()?, ve.id, |net| ops::set_mirroring(net, &v, mode))?; + Ok(json!({"ok": true})) + }), + spec!("vector.edit.smooth", "Smooth or sharpen points", "{vertices?, smooth? (default true)}", true, |s, p| { + let ve = editing(s)?; + let smooth = boolean(p, "smooth").unwrap_or(true); + let v = indices(p, "vertices").unwrap_or_else(|| ve.vertices.clone()); + edit(s.doc_mut()?, ve.id, |net| { + for vi in v { + if smooth { + ops::auto_smooth(net, vi); + } else { + ops::make_sharp(net, vi); + } + } + })?; + Ok(json!({"ok": true})) + }), + spec!("vector.edit.bend", "Bend segment", "{segment, t (0..1), x, y (page point the curve passes through)}", true, |s, p| { + let ve = editing(s)?; + let seg = index("vector.edit.bend", p, "segment")?; + let t = num_or(p, "t", 0.5); + let lp = local(s, ve.id, p, "vector.edit.bend")?; + edit(s.doc_mut()?, ve.id, |net| ops::bend(net, seg, t, lp))?; Ok(json!({"ok": true})) }), spec!("vector.edit.addVertex", "Add point", "{segment, t (0..1)}", true, |s, p| { - let (id, _) = editing(s)?; - let seg = req_num("vector.edit.addVertex", p, "segment")?.max(0.0) as usize; + let ve = editing(s)?; + let seg = index("vector.edit.addVertex", p, "segment")?; let t = num_or(p, "t", 0.5); - let v = split_segment(s.doc_mut()?, id, seg, t)?; - let ds = s.ds_mut()?; - ds.vector_edit = Some((id, vec![v])); + let v = + edit(s.doc_mut()?, ve.id, |net| ops::split_segment(net, seg, t))?.ok_or_else(|| bad("vector.edit.addVertex", "no such segment"))?; + set_state(s, |ve| { + ve.vertices = vec![v]; + ve.segments.clear(); + })?; Ok(json!({"vertex": v})) }), spec!("vector.deleteHeal", "Delete and heal selection", "{vertices?}", true, |s, p| { - let (id, sel) = editing(s)?; - let v: Vec = match get(p, "vertices") { - Some(Value::Array(a)) => a.iter().filter_map(f64_of).map(|x| x.max(0.0) as usize).collect(), - _ => sel, - }; - let doc = s.doc_mut()?; - delete_vertices(doc, id, &v, true)?; - refit(doc, id)?; - let ds = s.ds_mut()?; - ds.vector_edit = Some((id, vec![])); + let ve = editing(s)?; + delete_selection(s, indices(p, "vertices").unwrap_or(ve.vertices), vec![], true)?; Ok(json!({"ok": true})) }), - spec!("vector.edit.delete", "Delete points", "{vertices?}", true, |s, p| { - let (id, sel) = editing(s)?; - let v: Vec = match get(p, "vertices") { - Some(Value::Array(a)) => a.iter().filter_map(f64_of).map(|x| x.max(0.0) as usize).collect(), - _ => sel, + spec!("vector.edit.delete", "Delete points", "{vertices?, segments?} (default the selection)", true, |s, p| { + let ve = editing(s)?; + let (v, sg) = match (indices(p, "vertices"), indices(p, "segments")) { + (None, None) => (ve.vertices, ve.segments), + (v, sg) => (v.unwrap_or_default(), sg.unwrap_or_default()), }; - let doc = s.doc_mut()?; - delete_vertices(doc, id, &v, false)?; - refit(doc, id)?; - let ds = s.ds_mut()?; - ds.vector_edit = Some((id, vec![])); + delete_selection(s, v, sg, false)?; Ok(json!({"ok": true})) }), spec!("vector.edit.cornerRadius", "Point corner radius", "{radius, vertices?}", true, |s, p| { - let (id, sel) = editing(s)?; - let r = req_num("vector.edit.cornerRadius", p, "radius")?.max(0.0); - if let Some(net) = network_mut(s.doc_mut()?, id) { - for i in sel { - if let Some(v) = net.vertices.get_mut(i) { - v.radius = r; + let ve = editing(s)?; + let r = req_num("vector.edit.cornerRadius", p, "radius")?.clamp(0.0, 1e6); + let v = indices(p, "vertices").unwrap_or_else(|| default_points(s, &ve)); + edit(s.doc_mut()?, ve.id, |net| { + for i in v { + if let Some(x) = net.vertices.get_mut(i) { + x.radius = r; } } + })?; + Ok(json!({"ok": true})) + }), + spec!("vector.edit.paint", "Paint bucket", "{x, y} (page point: fills or unfills the closed area under it)", true, |s, p| { + let ve = editing(s)?; + let lp = local(s, ve.id, p, "vector.edit.paint")?; + let filled = paint(s.doc_mut()?, ve.id, lp)?; + Ok(json!({"filled": filled})) + }), + spec!("vector.edit.cut", "Cut path", "{segment, t?} | {vertex}", true, |s, p| { + let ve = editing(s)?; + let ends = if let Some(v) = num(p, "vertex") { + let v = if v >= 0.0 { v as usize } else { usize::MAX }; + edit(s.doc_mut()?, ve.id, |net| ops::cut_vertex(net, v))? + } else { + let seg = index("vector.edit.cut", p, "segment")?; + let t = num_or(p, "t", 0.5); + edit(s.doc_mut()?, ve.id, |net| ops::cut_segment(net, seg, t))?.map(|(a, b)| vec![a, b]).unwrap_or_default() + }; + if ends.is_empty() { + return Err(bad("vector.edit.cut", "nothing to cut there")); } + set_state(s, |ve| { + ve.vertices = ends.clone(); + ve.segments.clear(); + })?; + Ok(json!({"vertices": ends})) + }), + spec!("vector.edit.connect", "Connect points", "{a, b} (adds a straight segment)", true, |s, p| { + let ve = editing(s)?; + let (a, b) = (index("vector.edit.connect", p, "a")?, index("vector.edit.connect", p, "b")?); + let seg = edit(s.doc_mut()?, ve.id, |net| ops::connect(net, a, b, (0.0, 0.0), (0.0, 0.0)))? + .ok_or_else(|| bad("vector.edit.connect", "can't connect those points"))?; + Ok(json!({"segment": seg})) + }), + spec!("vector.edit.lasso", "Lasso select", "{points: [[x, y], ...] (page), add?}", false, |s, p| { + let ve = editing(s)?; + let poly: Vec = match get(p, "points") { + Some(Value::Array(a)) => { + a.iter().filter_map(|q| Some(Point::new(q.get(0).and_then(f64_of)?, q.get(1).and_then(f64_of)?))).take(100_000).collect() + } + _ => vec![], + }; + let found = vertices_in_polygon(s.doc()?, ve.id, &poly); + let add = boolean(p, "add").unwrap_or(false); + set_state(s, |ve| { + if !add { + ve.vertices.clear(); + ve.segments.clear(); + } + for v in &found { + if !ve.vertices.contains(v) { + ve.vertices.push(*v); + } + } + })?; + Ok(json!({"vertices": found})) + }), + spec!( + "vector.edit.pen", + "Pen point", + "{x, y (page), dx?, dy? (handle drag)} — continues from the pen's open end; clicking a point connects to it", + true, + |s, p| { + let ve = editing(s)?; + let pt = Point::new(req_num("vector.edit.pen", p, "x")?, req_num("vector.edit.pen", p, "y")?); + let drag = Vec2::new(num_or(p, "dx", 0.0), num_or(p, "dy", 0.0)); + let v = s.pen_click(&ve, pt, drag, 1.0)?; + Ok(json!({"vertex": v})) + } + ), + spec!("vector.edit.penEnd", "End pen path", "{}", false, |s, _| { + editing(s)?; + set_state(s, |ve| { + ve.anchor = None; + ve.pen_out = None; + })?; Ok(json!({"ok": true})) }), ] } + +/// The paint bucket on node `id` at local point `lp`. A vector without fills gets the default +/// fill so the painted area shows. +pub fn paint(doc: &mut Document, id: NodeId, lp: Point) -> Result { + let filled = edit(doc, id, |net| net.paint(lp))?.ok_or_else(|| bad("vector.edit.paint", "click inside a closed area"))?; + let n = doc.get_mut(id)?; + if filled && n.fills.iter().all(|f| !f.visible) { + n.fills = vec![figcraft_color::Paint::solid(figcraft_color::Color::DEFAULT_SHAPE)]; + } + Ok(filled) +} diff --git a/crates/engine/src/vectoredit/ops.rs b/crates/engine/src/vectoredit/ops.rs new file mode 100644 index 00000000..93e67b5f --- /dev/null +++ b/crates/engine/src/vectoredit/ops.rs @@ -0,0 +1,721 @@ +//! Vector network edits in node-local coordinates: points, handles and mirroring, bending, adding, +//! deleting, cutting and joining. Pure functions on a [`VectorNetwork`]; the session wrappers in +//! `vectoredit.rs` re-fit the node afterwards. + +use figcraft_doc::*; +use figcraft_geom::kurbo::{CubicBez, ParamCurve}; +use figcraft_geom::{Point, Vec2}; + +fn tvec(t: (f64, f64)) -> Vec2 { + Vec2::new(t.0, t.1) +} + +fn finite(v: Vec2) -> bool { + v.x.is_finite() && v.y.is_finite() +} + +/// Move vertices by `d`; their handles move with them. +pub fn move_vertices(net: &mut VectorNetwork, idx: &[usize], d: Vec2) { + if !finite(d) { + return; + } + let mut seen = std::collections::BTreeSet::new(); + for i in idx { + if seen.insert(*i) + && let Some(v) = net.vertices.get_mut(*i) + { + v.x += d.x; + v.y += d.y; + } + } +} + +/// Set a handle to `rel` (relative to its vertex). The vertex's other handle follows its mirroring +/// (none, angle, or angle and length); `independent` (Alt-drag) breaks the mirroring. +pub fn set_handle(net: &mut VectorNetwork, seg: usize, start: bool, rel: (f64, f64), independent: bool) { + if !(rel.0.is_finite() && rel.1.is_finite()) { + return; + } + let Some(s) = net.segments.get(seg).copied() else { return }; + let vi = if start { s.a } else { s.b }; + let mode = if independent { HandleMirroring::None } else { net.mirroring(vi) }; + net.set_handle(seg, start, rel); + if independent { + if let Some(v) = net.vertices.get_mut(vi) { + v.mirror = Some(HandleMirroring::None); + } + return; + } + let others: Vec<(usize, bool)> = net.incident(vi).into_iter().filter(|(i, st)| !(*i == seg && *st == start)).collect(); + let [(oi, ostart)] = others.as_slice() else { return }; + let r = tvec(rel); + let mirrored = match mode { + HandleMirroring::None => return, + HandleMirroring::AngleAndLength => -r, + HandleMirroring::Angle => { + let len = net.handle(*oi, *ostart).map(|h| tvec(h).hypot()).unwrap_or(0.0); + if r.hypot() < 1e-9 { + return; + } + -r.normalize() * if len > 1e-9 { len } else { r.hypot() } + } + }; + net.set_handle(*oi, *ostart, (mirrored.x, mirrored.y)); +} + +/// Set the mirroring of vertices and make their handles agree with it. +pub fn set_mirroring(net: &mut VectorNetwork, verts: &[usize], mode: HandleMirroring) { + for &vi in verts { + let inc = net.incident(vi); + if let [(s1, a1), (s2, a2)] = inc.as_slice() + && let (Some(h1), Some(h2)) = (net.handle(*s1, *a1), net.handle(*s2, *a2)) + { + let (h1, h2) = (tvec(h1), tvec(h2)); + match mode { + HandleMirroring::None => {} + HandleMirroring::Angle | HandleMirroring::AngleAndLength => { + // Keep the longer handle's direction; the other turns opposite. + let (lead, lead_is_first) = if h1.hypot() >= h2.hypot() { (h1, true) } else { (h2, false) }; + if lead.hypot() > 1e-9 { + let other_len = if mode == HandleMirroring::AngleAndLength { + (h1.hypot() + h2.hypot()) / 2.0 + } else if lead_is_first { + h2.hypot() + } else { + h1.hypot() + }; + let dir = lead.normalize(); + let lead_len = if mode == HandleMirroring::AngleAndLength { other_len } else { lead.hypot() }; + let (a, b) = (dir * lead_len, -dir * if other_len > 1e-9 { other_len } else { lead_len }); + let (n1, n2) = if lead_is_first { (a, b) } else { (b, a) }; + net.set_handle(*s1, *a1, (n1.x, n1.y)); + net.set_handle(*s2, *a2, (n2.x, n2.y)); + } + } + } + } + if let Some(v) = net.vertices.get_mut(vi) { + v.mirror = Some(mode); + } + } +} + +/// Direction from vertex `vi` along segment `seg` (towards its other end). +fn away(net: &VectorNetwork, seg: usize, at_start: bool) -> Option { + let c = net.cubic(seg)?; + let d = if at_start { c.p3 - c.p0 } else { c.p0 - c.p3 }; + (d.hypot() > 1e-9).then(|| d.normalize()) +} + +/// Pull symmetric handles out of a point (the Bend tool dragged on a point): `d` is the handle on +/// the side the drag points towards; the opposite side gets `-d`. Mirroring becomes "angle". +pub fn make_smooth(net: &mut VectorNetwork, vi: usize, d: Vec2) { + if !finite(d) || d.hypot() < 1e-9 { + return; + } + let inc = net.incident(vi); + let scored: Vec<(usize, bool, f64)> = inc.iter().map(|(s, st)| (*s, *st, away(net, *s, *st).map(|a| a.dot(d)).unwrap_or(0.0))).collect(); + match scored.as_slice() { + [] => return, + [(s, st, dot)] => { + let h = if *dot >= 0.0 { d } else { -d }; + net.set_handle(*s, *st, (h.x, h.y)); + } + _ => { + let fwd = scored.iter().copied().max_by(|a, b| a.2.total_cmp(&b.2)); + let back = scored.iter().copied().filter(|x| Some(*x) != fwd).min_by(|a, b| a.2.total_cmp(&b.2)); + if let (Some((s1, a1, _)), Some((s2, a2, _))) = (fwd, back) { + net.set_handle(s1, a1, (d.x, d.y)); + net.set_handle(s2, a2, (-d.x, -d.y)); + } + } + } + if let Some(v) = net.vertices.get_mut(vi) { + v.mirror = Some(HandleMirroring::Angle); + } +} + +/// Smooth points automatically: handles along the line between the neighbours, a third of the way +/// to each (endpoints stay as they are). +pub fn auto_smooth(net: &mut VectorNetwork, vi: usize) { + let inc = net.incident(vi); + let [(s1, a1), (s2, a2)] = inc.as_slice() else { return }; + let other = |s: usize, st: bool| net.segments.get(s).and_then(|x| net.vertices.get(if st { x.b } else { x.a })).map(|v| v.point()); + let (Some(v), Some(p1), Some(p2)) = (net.vertices.get(vi).map(|v| v.point()), other(*s1, *a1), other(*s2, *a2)) else { return }; + let dir = p1 - p2; + if dir.hypot() < 1e-9 { + return; + } + let dir = dir.normalize(); + let (l1, l2) = ((p1 - v).hypot() / 3.0, (p2 - v).hypot() / 3.0); + let (h1, h2) = (dir * l1, -dir * l2); + net.set_handle(*s1, *a1, (h1.x, h1.y)); + net.set_handle(*s2, *a2, (h2.x, h2.y)); + if let Some(x) = net.vertices.get_mut(vi) { + x.mirror = Some(HandleMirroring::Angle); + } +} + +/// Remove a point's handles (a sharp corner). +pub fn make_sharp(net: &mut VectorNetwork, vi: usize) { + for (s, st) in net.incident(vi) { + net.set_handle(s, st, (0.0, 0.0)); + } + if let Some(v) = net.vertices.get_mut(vi) { + v.mirror = None; + } +} + +/// Bend a segment so its curve passes through `p` at parameter `t` (the Bend tool). +pub fn bend(net: &mut VectorNetwork, seg: usize, t: f64, p: Point) { + let Some(s) = net.segments.get(seg).copied() else { return }; + let (Some(a), Some(b)) = (net.vertices.get(s.a).copied(), net.vertices.get(s.b).copied()) else { return }; + if !(t.is_finite() && p.x.is_finite() && p.y.is_finite()) { + return; + } + let t = t.clamp(0.05, 0.95); + // Controls at the chord's thirds plus a shared offset: B(t) = L(t) + 3t(1-t)·off. + let (a, b) = (a.point(), b.point()); + let k = 3.0 * t * (1.0 - t); + let off = (p - a.lerp(b, t)) / k; + let c1 = a + (b - a) / 3.0 + off; + let c2 = b + (a - b) / 3.0 + off; + net.set_handle(seg, true, (c1.x - a.x, c1.y - a.y)); + net.set_handle(seg, false, (c2.x - b.x, c2.y - b.y)); +} + +/// Split segment `seg` at `t`, inserting a vertex; returns its index. +pub fn split_segment(net: &mut VectorNetwork, seg: usize, t: f64) -> Option { + let s = net.segments.get(seg).copied()?; + let c: CubicBez = net.cubic(seg)?; + let t = if t.is_finite() { t.clamp(0.01, 0.99) } else { 0.5 }; + let l = c.subsegment(0.0..t); + let r = c.subsegment(t..1.0); + net.vertices.push(Vertex::new(l.p3.x, l.p3.y)); + let mid = net.vertices.len() - 1; + let straight = s.is_straight(); + if let Some(sm) = net.segments.get_mut(seg) { + sm.b = mid; + if straight { + sm.ta = (0.0, 0.0); + sm.tb = (0.0, 0.0); + } else { + sm.ta = (l.p1.x - l.p0.x, l.p1.y - l.p0.y); + sm.tb = (l.p2.x - l.p3.x, l.p2.y - l.p3.y); + } + } + let new_seg = if straight { + Segment::line(mid, s.b) + } else { + // A point added on a curve keeps it smooth. + if let Some(v) = net.vertices.get_mut(mid) { + v.mirror = Some(HandleMirroring::Angle); + } + Segment { a: mid, b: s.b, ta: (r.p1.x - r.p0.x, r.p1.y - r.p0.y), tb: (r.p2.x - r.p3.x, r.p2.y - r.p3.y) } + }; + net.segments.push(new_seg); + let ni = net.segments.len() - 1; + for reg in &mut net.regions { + for lp in &mut reg.loops { + if let Some(pos) = lp.iter().position(|x| *x == seg) { + lp.insert(pos + 1, ni); + } + } + } + Some(mid) +} + +/// Remove vertex `vi` (no segment may use it) and shift higher indices down. +fn remove_vertex_index(net: &mut VectorNetwork, vi: usize) { + if vi >= net.vertices.len() { + return; + } + net.vertices.remove(vi); + for s in &mut net.segments { + if s.a > vi { + s.a -= 1; + } + if s.b > vi { + s.b -= 1; + } + } +} + +/// Remove segments (fixing region loops); points left without any segment go too. +pub fn remove_segments(net: &mut VectorNetwork, segs: &[usize]) { + let mut touched: Vec = segs.iter().filter_map(|s| net.segments.get(*s)).flat_map(|s| [s.a, s.b]).collect(); + remove_segments_only(net, segs); + touched.sort_unstable(); + touched.dedup(); + for &vi in touched.iter().rev() { + if net.incident(vi).is_empty() { + remove_vertex_index(net, vi); + } + } + reopen_loops(net); +} + +fn remove_segments_only(net: &mut VectorNetwork, segs: &[usize]) { + let mut segs: Vec = segs.iter().copied().filter(|s| *s < net.segments.len()).collect(); + segs.sort_unstable(); + segs.dedup(); + let mut map: Vec> = (0..net.segments.len()).map(Some).collect(); + for &si in segs.iter().rev() { + net.segments.remove(si); + if let Some(m) = map.get_mut(si) { + *m = None; + } + } + for (k, m) in map.iter_mut().flatten().enumerate() { + *m = k; + } + for r in &mut net.regions { + for lp in &mut r.loops { + *lp = lp.iter().filter_map(|i| map.get(*i).copied().flatten()).collect(); + } + r.loops.retain(|l| l.len() >= 2); + } + net.regions.retain(|r| !r.loops.is_empty()); +} + +/// Delete vertices, joining their neighbours where a vertex had exactly two segments (`heal`). +pub fn delete_vertices(net: &mut VectorNetwork, idx: &[usize], heal: bool) { + let mut idx: Vec = idx.to_vec(); + idx.sort_unstable(); + idx.dedup(); + for &vi in idx.iter().rev() { + if vi >= net.vertices.len() { + continue; + } + let touching: Vec = net.incident(vi).into_iter().map(|(i, _)| i).collect(); + let mut healed = None; + if heal && let [s1, s2] = touching.as_slice() { + let (Some(x), Some(y)) = (net.segments.get(*s1).copied(), net.segments.get(*s2).copied()) else { continue }; + let o1 = if x.a == vi { (x.b, x.tb) } else { (x.a, x.ta) }; + let o2 = if y.a == vi { (y.b, y.tb) } else { (y.a, y.ta) }; + if o1.0 != o2.0 { + healed = Some(Segment { a: o1.0, b: o2.0, ta: o1.1, tb: o2.1 }); + } + } + // Remove touching segments (descending) and fix region loops (the healed segment takes + // the removed ones' place). + let mut map: Vec> = (0..net.segments.len()).map(Some).collect(); + for &si in touching.iter().rev() { + net.segments.remove(si); + if let Some(m) = map.get_mut(si) { + *m = None; + } + } + for (k, m) in map.iter_mut().flatten().enumerate() { + *m = k; + } + let healed_index = healed.map(|s| { + net.segments.push(s); + net.segments.len() - 1 + }); + for r in &mut net.regions { + for lp in &mut r.loops { + let mut out = Vec::new(); + let mut inserted = false; + for si in lp.iter() { + match map.get(*si).copied().flatten() { + Some(n) => out.push(n), + None => { + if let (Some(h), false) = (healed_index, inserted) { + out.push(h); + inserted = true; + } + } + } + } + *lp = out; + } + r.loops.retain(|l| l.len() >= 2); + } + net.regions.retain(|r| !r.loops.is_empty()); + remove_vertex_index(net, vi); + } + net.sanitize(); + reopen_loops(net); +} + +/// After a loop was broken open, start it where the break is so it's one continuous chain (the fill +/// then closes it with a straight line, like an open path's fill). +fn reopen_loops(net: &mut VectorNetwork) { + let segs = net.segments.clone(); + let shares = |x: usize, y: usize| -> bool { + match (segs.get(x), segs.get(y)) { + (Some(a), Some(b)) => a.a == b.a || a.a == b.b || a.b == b.a || a.b == b.b, + _ => false, + } + }; + for r in &mut net.regions { + for lp in &mut r.loops { + let n = lp.len(); + if n < 2 { + continue; + } + let brk = (0..n).find(|k| { + let prev = lp.get((k + n - 1) % n).copied().unwrap_or(0); + let cur = lp.get(*k).copied().unwrap_or(0); + !shares(prev, cur) + }); + if let Some(k) = brk { + lp.rotate_left(k); + } + } + } +} + +/// Cut a segment at `t` into two open ends at the same spot. Returns the two end vertices. +pub fn cut_segment(net: &mut VectorNetwork, seg: usize, t: f64) -> Option<(usize, usize)> { + let mid = split_segment(net, seg, t)?; + let ni = net.segments.len().checked_sub(1)?; + let v = *net.vertices.get(mid)?; + net.vertices.push(Vertex { mirror: None, ..v }); + let mid2 = net.vertices.len() - 1; + if let Some(s) = net.segments.get_mut(ni) { + s.a = mid2; + } + if let Some(x) = net.vertices.get_mut(mid) { + x.mirror = None; + } + reopen_loops(net); + Some((mid, mid2)) +} + +/// Cut the path at a point: every segment after the first gets its own copy of the point. +pub fn cut_vertex(net: &mut VectorNetwork, vi: usize) -> Vec { + let inc = net.incident(vi); + let Some(v) = net.vertices.get(vi).copied() else { return vec![] }; + let mut out = vec![vi]; + for (s, st) in inc.into_iter().skip(1) { + net.vertices.push(Vertex { mirror: None, ..v }); + let nv = net.vertices.len() - 1; + if let Some(seg) = net.segments.get_mut(s) { + if st { + seg.a = nv; + } else { + seg.b = nv; + } + } + out.push(nv); + } + if let Some(x) = net.vertices.get_mut(vi) { + x.mirror = None; + } + reopen_loops(net); + out +} + +/// Shortest chain of segments from `from` to `to` (breadth first), skipping segment `skip`. +fn path_between(net: &VectorNetwork, from: usize, to: usize, skip: usize) -> Option> { + let n = net.vertices.len(); + let mut prev: Vec> = vec![None; n]; + let mut seen = vec![false; n]; + let mut queue = std::collections::VecDeque::from([from]); + if let Some(s) = seen.get_mut(from) { + *s = true; + } + while let Some(v) = queue.pop_front() { + if v == to { + let mut segs = Vec::new(); + let mut cur = to; + while cur != from { + let (pv, ps) = prev.get(cur).copied().flatten()?; + segs.push(ps); + cur = pv; + } + segs.reverse(); + return Some(segs); + } + for (s, st) in net.incident(v) { + if s == skip { + continue; + } + let Some(seg) = net.segments.get(s) else { continue }; + let w = if st { seg.b } else { seg.a }; + if !seen.get(w).copied().unwrap_or(true) { + if let Some(x) = seen.get_mut(w) { + *x = true; + } + if let Some(x) = prev.get_mut(w) { + *x = Some((v, s)); + } + queue.push_back(w); + } + } + } + None +} + +/// Connect two points with a new segment (handles relative to each end). Closing an open path +/// (both points were its ends) makes the loop a fill region. Returns the new segment. +pub fn connect(net: &mut VectorNetwork, a: usize, b: usize, ta: (f64, f64), tb: (f64, f64)) -> Option { + if a == b || a >= net.vertices.len() || b >= net.vertices.len() { + return None; + } + let ends = net.incident(a).len() == 1 && net.incident(b).len() == 1; + let finite_t = |t: (f64, f64)| if t.0.is_finite() && t.1.is_finite() { t } else { (0.0, 0.0) }; + net.segments.push(Segment { a, b, ta: finite_t(ta), tb: finite_t(tb) }); + let si = net.segments.len() - 1; + if ends && let Some(mut lp) = path_between(net, b, a, si) { + let unfilled = !net.regions.iter().any(|r| r.loops.iter().flatten().any(|s| lp.contains(s))); + if unfilled { + lp.insert(0, si); + net.regions.push(Region { loops: vec![lp], winding: WindingRule::NonZero }); + } + } + Some(si) +} + +/// Merge vertex `drop` into `keep` (segments re-attach; ones that collapse go). +pub fn merge_vertices(net: &mut VectorNetwork, keep: usize, drop: usize) { + if keep == drop || keep >= net.vertices.len() || drop >= net.vertices.len() { + return; + } + for s in &mut net.segments { + if s.a == drop { + s.a = keep; + } + if s.b == drop { + s.b = keep; + } + } + let collapsed: Vec = net.segments.iter().enumerate().filter(|(_, s)| s.a == s.b && s.is_straight()).map(|(i, _)| i).collect(); + remove_segments_only(net, &collapsed); + remove_vertex_index(net, drop); + reopen_loops(net); +} + +/// Join points (⌘J): two points that overlap merge; otherwise open ends are connected in pairs +/// (nearest first). `smooth` continues each end's curve. Returns the number of joins. +pub fn join(net: &mut VectorNetwork, verts: &[usize], smooth: bool) -> usize { + let mut verts: Vec = verts.iter().copied().filter(|v| *v < net.vertices.len()).collect(); + verts.sort_unstable(); + verts.dedup(); + if let [a, b] = verts.as_slice() { + let (pa, pb) = (net.vertices.get(*a).map(|v| v.point()), net.vertices.get(*b).map(|v| v.point())); + if let (Some(pa), Some(pb)) = (pa, pb) + && (pa - pb).hypot() < 0.5 + { + merge_vertices(net, *a, *b); + return 1; + } + } + let mut ends: Vec = if verts.len() == 2 { verts.clone() } else { verts.iter().copied().filter(|v| net.incident(*v).len() <= 1).collect() }; + let mut joins = 0; + while ends.len() >= 2 { + let a = ends.remove(0); + let Some(pa) = net.vertices.get(a).map(|v| v.point()) else { continue }; + let Some((k, _)) = ends + .iter() + .enumerate() + .filter_map(|(k, b)| net.vertices.get(*b).map(|v| (k, (v.point() - pa).hypot()))) + .min_by(|x, y| x.1.total_cmp(&y.1)) + else { + break; + }; + let b = ends.remove(k); + let Some(pb) = net.vertices.get(b).map(|v| v.point()) else { continue }; + let (ta, tb) = if smooth { + let len = (pb - pa).hypot() / 3.0; + let out = |v: usize, toward: Vec2| -> Vec2 { + // Continue the existing curve out of the end; fall back to the chord. + let inc = net.incident(v); + let dir = match inc.as_slice() { + [(s, st)] => { + net.handle(*s, *st).map(tvec).filter(|h| h.hypot() > 1e-9).map(|h| -h.normalize()).or_else(|| away(net, *s, *st).map(|a| -a)) + } + _ => None, + }; + dir.unwrap_or(toward) * len + }; + let chord = if (pb - pa).hypot() > 1e-9 { (pb - pa).normalize() } else { Vec2::ZERO }; + let (oa, ob) = (out(a, chord), out(b, -chord)); + ((oa.x, oa.y), (ob.x, ob.y)) + } else { + ((0.0, 0.0), (0.0, 0.0)) + }; + if connect(net, a, b, ta, tb).is_some() { + joins += 1; + } + } + joins +} + +/// Vertices inside a closed polygon (even-odd), all in the same coordinates. +pub fn in_polygon(points: &[Point], poly: &[Point]) -> Vec { + if poly.len() < 3 { + return vec![]; + } + points + .iter() + .enumerate() + .filter(|(_, p)| { + let mut inside = false; + let n = poly.len(); + for k in 0..n { + let (Some(a), Some(b)) = (poly.get(k), poly.get((k + 1) % n)) else { continue }; + if (a.y > p.y) != (b.y > p.y) { + let x = a.x + (p.y - a.y) * (b.x - a.x) / (b.y - a.y); + if p.x < x { + inside = !inside; + } + } + } + inside + }) + .map(|(i, _)| i) + .collect() +} + +#[cfg(test)] +mod tests { + use super::*; + + fn square() -> VectorNetwork { + VectorNetwork::from_points(&[Point::new(0.0, 0.0), Point::new(100.0, 0.0), Point::new(100.0, 100.0), Point::new(0.0, 100.0)], true) + } + + fn open_line() -> VectorNetwork { + VectorNetwork::from_points(&[Point::new(0.0, 0.0), Point::new(50.0, 0.0), Point::new(100.0, 0.0)], false) + } + + #[test] + fn handles_follow_mirroring() { + let mut n = open_line(); + set_mirroring(&mut n, &[1], HandleMirroring::AngleAndLength); + // Seg 0 ends at v1 (tb), seg 1 starts there (ta). + set_handle(&mut n, 1, true, (20.0, 10.0), false); + assert_eq!(n.segments[0].tb, (-20.0, -10.0)); + set_mirroring(&mut n, &[1], HandleMirroring::Angle); + set_handle(&mut n, 1, true, (0.0, 30.0), false); + let other = n.segments[0].tb; + assert!(other.0.abs() < 1e-9 && (other.1 + 22.360679).abs() < 1e-4, "angle mirrors, length kept: {other:?}"); + assert_eq!(n.mirroring(1), HandleMirroring::Angle); + set_handle(&mut n, 1, true, (10.0, 0.0), true); + assert_eq!(n.mirroring(1), HandleMirroring::None); + assert!(n.segments[0].tb.1 < -20.0, "independent drag leaves the other handle"); + set_mirroring(&mut n, &[1], HandleMirroring::AngleAndLength); + let (a, b) = (tvec(n.segments[1].ta), tvec(n.segments[0].tb)); + assert!((a + b).hypot() < 1e-9, "made symmetric: {a:?} {b:?}"); + } + + #[test] + fn inferred_mirroring() { + let mut n = open_line(); + assert_eq!(n.mirroring(1), HandleMirroring::None); + n.segments[0].tb = (-10.0, 0.0); + n.segments[1].ta = (10.0, 0.0); + assert_eq!(n.mirroring(1), HandleMirroring::AngleAndLength); + n.segments[1].ta = (20.0, 0.0); + assert_eq!(n.mirroring(1), HandleMirroring::Angle); + n.segments[1].ta = (20.0, 5.0); + assert_eq!(n.mirroring(1), HandleMirroring::None); + } + + #[test] + fn smooth_and_sharp() { + let mut n = square(); + make_smooth(&mut n, 0, Vec2::new(30.0, 0.0)); + // Seg 0 goes 0→1 (towards +x): gets +d; seg 3 (3→0) gets -d at its b end. + assert_eq!(n.segments[0].ta, (30.0, 0.0)); + assert_eq!(n.segments[3].tb, (-30.0, 0.0)); + assert_eq!(n.mirroring(0), HandleMirroring::Angle); + make_sharp(&mut n, 0); + assert!(n.segments[0].is_straight() && n.segments[3].is_straight()); + auto_smooth(&mut n, 1); + assert_eq!(n.mirroring(1), HandleMirroring::Angle); + assert!(!n.segments[0].is_straight()); + } + + #[test] + fn cut_opens_a_closed_shape_but_keeps_its_fill() { + let mut n = square(); + let (a, b) = cut_segment(&mut n, 0, 0.5).unwrap(); + assert_ne!(a, b); + assert_eq!(n.vertices[a].point(), n.vertices[b].point()); + assert_eq!(n.incident(a).len(), 1); + assert_eq!(n.incident(b).len(), 1); + assert!(n.fill_contains(Point::new(50.0, 50.0)), "fill kept"); + // Cutting at a corner detaches it. + let mut m = square(); + let vs = cut_vertex(&mut m, 2); + assert_eq!(vs.len(), 2); + assert!(vs.iter().all(|v| m.incident(*v).len() == 1)); + assert!(m.fill_contains(Point::new(50.0, 50.0))); + } + + #[test] + fn connecting_ends_closes_and_fills() { + let mut n = open_line(); + n.vertices[2].y = 100.0; + assert!(n.regions.is_empty()); + let s = connect(&mut n, 2, 0, (0.0, 0.0), (0.0, 0.0)).unwrap(); + assert_eq!(n.regions.len(), 1); + assert!(n.regions[0].loops[0].contains(&s)); + assert!(n.fill_contains(Point::new(50.0, 20.0))); + // Branching from the middle point doesn't make a region. + n.vertices.push(Vertex::new(50.0, -50.0)); + connect(&mut n, 1, 3, (0.0, 0.0), (0.0, 0.0)).unwrap(); + assert_eq!(n.regions.len(), 1); + assert!(connect(&mut n, 1, 1, (0.0, 0.0), (0.0, 0.0)).is_none()); + assert!(connect(&mut n, 1, 99, (0.0, 0.0), (0.0, 0.0)).is_none()); + } + + #[test] + fn join_merges_overlapping_points_and_connects_ends() { + let mut n = open_line(); + n.vertices.push(Vertex::new(100.2, 0.0)); + n.vertices.push(Vertex::new(150.0, 0.0)); + n.segments.push(Segment::line(3, 4)); + assert_eq!(join(&mut n, &[2, 3], false), 1); + assert_eq!(n.vertices.len(), 4, "merged"); + assert_eq!(n.incident(2).len(), 2); + // Two separate open ends far apart: connected (smoothly). + let mut m = open_line(); + m.vertices.push(Vertex::new(200.0, 50.0)); + m.vertices.push(Vertex::new(300.0, 50.0)); + m.segments.push(Segment::line(3, 4)); + assert_eq!(join(&mut m, &[0, 2, 3, 4], true), 2); + assert!(m.segments.iter().skip(3).any(|s| !s.is_straight())); + } + + #[test] + fn deleting_segments_and_points() { + let mut n = square(); + remove_segments(&mut n, &[0]); + assert_eq!(n.segments.len(), 3); + assert_eq!(n.vertices.len(), 4, "points with other segments stay"); + let mut m = open_line(); + remove_segments(&mut m, &[1]); + assert_eq!(m.vertices.len(), 2, "the orphaned end goes"); + let mut h = square(); + delete_vertices(&mut h, &[1], true); + assert_eq!((h.vertices.len(), h.segments.len(), h.regions.len()), (3, 3, 1)); + let mut d = square(); + delete_vertices(&mut d, &[1], false); + assert_eq!((d.vertices.len(), d.segments.len()), (3, 2)); + // Junk indices. + remove_segments(&mut d, &[99]); + delete_vertices(&mut d, &[99], true); + assert!(split_segment(&mut d, 99, 0.5).is_none()); + assert!(cut_segment(&mut d, 99, f64::NAN).is_none()); + assert!(cut_vertex(&mut d, 99).is_empty()); + set_handle(&mut d, 99, true, (1.0, 1.0), false); + set_handle(&mut d, 0, true, (f64::NAN, 1.0), false); + make_smooth(&mut d, 99, Vec2::new(1.0, 1.0)); + bend(&mut d, 0, f64::NAN, Point::new(1.0, 1.0)); + move_vertices(&mut d, &[0], Vec2::new(f64::INFINITY, 0.0)); + assert!(d.vertices.iter().all(|v| v.x.is_finite() && v.y.is_finite())); + } + + #[test] + fn lasso_polygon() { + let pts = [Point::new(5.0, 5.0), Point::new(50.0, 50.0), Point::new(15.0, 5.0)]; + let poly = [Point::new(0.0, 0.0), Point::new(20.0, 0.0), Point::new(20.0, 20.0), Point::new(0.0, 20.0)]; + assert_eq!(in_polygon(&pts, &poly), vec![0, 2]); + assert!(in_polygon(&pts, &poly[..2]).is_empty()); + } +} diff --git a/crates/engine/src/vectoredit/pointer.rs b/crates/engine/src/vectoredit/pointer.rs new file mode 100644 index 00000000..1a37506a --- /dev/null +++ b/crates/engine/src/vectoredit/pointer.rs @@ -0,0 +1,569 @@ +//! Pointer gestures in vector edit mode, one per edit tool. Each gesture is one undo step: it +//! starts an interaction and previews its edit against the snapshot until the pointer goes up. + +use figcraft_doc::*; +use figcraft_geom::{Point, Rect, Vec2}; + +use super::{VHit, VTool, VectorEdit, edit, editing, hit, network, ops, set_state}; +use crate::tools::{Cursor, Gesture, PointerEvent, PointerKind}; +use crate::{Result, Session}; + +/// An in-progress edit-mode gesture. +#[derive(Clone, Debug)] +pub(crate) enum VGesture { + /// Drag points (also a segment's ends). `split` re-adds a point on a segment first. + Points { + start: Point, + verts: Vec, + split: Option<(usize, f64)>, + moved: bool, + }, + Handle { + seg: usize, + start: bool, + independent: bool, + }, + BendSegment { + seg: usize, + t: f64, + }, + /// Bend tool on a point: drag pulls out handles, a click on a smooth point sharpens it. + BendVertex { + v: usize, + origin: Point, + moved: bool, + smooth: bool, + }, + Marquee { + start: Point, + base: Vec, + }, + Lasso { + points: Vec, + base: Vec, + }, + Pen { + plan: PenPlan, + origin: Point, + out: Option<(f64, f64)>, + }, +} + +/// What a pen click does (replayed against the snapshot while the handle is dragged). +#[derive(Clone, Copy, Debug, PartialEq)] +pub(crate) enum PenPlan { + /// A new point at `at` (local), connected from the pen's open end. + New { at: Point, from: Option }, + /// Connect the open end to an existing point (ends the path). + Connect { from: usize, to: usize }, + /// Add a point on a segment, connected from the open end if any (ends the path). + Split { seg: usize, t: f64, from: Option }, +} + +/// Apply a pen plan; `out` is the open end's outgoing handle, `drag` the handle being dragged out +/// of the new point. Returns the point the click landed on. +fn apply_pen(net: &mut VectorNetwork, plan: PenPlan, out: Option<(f64, f64)>, drag: Option) -> Option { + let out = out.unwrap_or((0.0, 0.0)); + let back = drag.map(|d| (-d.x, -d.y)).unwrap_or((0.0, 0.0)); + match plan { + PenPlan::New { at, from } => { + net.vertices.push(Vertex::new(at.x, at.y)); + let v = net.vertices.len() - 1; + if let Some(f) = from { + ops::connect(net, f, v, out, back); + } + if drag.is_some() + && let Some(x) = net.vertices.get_mut(v) + { + x.mirror = Some(HandleMirroring::AngleAndLength); + } + Some(v) + } + PenPlan::Connect { from, to } => { + let others = net.incident(to); + let seg = ops::connect(net, from, to, out, back)?; + // Dragging while closing shapes the curve on both sides of the point. + if let (Some(d), [(os, ost)]) = (drag, others.as_slice()) { + net.set_handle(*os, *ost, (d.x, d.y)); + if let Some(x) = net.vertices.get_mut(to) { + x.mirror = Some(HandleMirroring::AngleAndLength); + } + } + let _ = seg; + Some(to) + } + PenPlan::Split { seg, t, from } => { + let v = ops::split_segment(net, seg, t)?; + if let Some(f) = from { + ops::connect(net, f, v, out, (0.0, 0.0)); + } + Some(v) + } + } +} + +impl Session { + /// Feed a pointer event to vector edit mode (the canvas is in edit mode and the main tool is + /// Move). Returns false when edit mode ended and the event should go to the normal tool. + pub(crate) fn vector_pointer(&mut self, ev: &PointerEvent) -> Result { + let Ok(ve) = editing(self) else { return Ok(false) }; + match ev.kind { + PointerKind::Hover => self.vector_hover(&ve, ev).map(|()| true), + PointerKind::Down => self.vector_down(&ve, ev), + PointerKind::Move => self.vector_drag(&ve, ev).map(|()| true), + PointerKind::Up => self.vector_up(&ve, ev).map(|()| true), + PointerKind::DoubleClick => { + let tol = 6.0 / ev.zoom.max(1e-6); + let doc = self.doc()?.clone(); + if ve.anchor.is_some() { + super::escape(self)?; + } else if hit(&doc, &ve, ev.p(), tol).is_none() && ve.tool == VTool::Move { + super::end(self)?; + } + Ok(true) + } + } + } + + fn vgesture(&mut self, g: VGesture) { + self.tool.gesture = Gesture::Vector(g); + } + + fn vector_hover(&mut self, ve: &VectorEdit, ev: &PointerEvent) -> Result<()> { + let doc = self.doc()?.clone(); + let tol = 6.0 / ev.zoom.max(1e-6); + let h = hit(&doc, ve, ev.p(), tol); + let ov = &mut self.tool.overlay; + ov.vector_hover = h; + ov.face.clear(); + ov.rubber = None; + ov.cursor = match ve.tool { + VTool::Move if ev.cmd => Cursor::Crosshair, + VTool::Move => Cursor::Default, + VTool::Pen => Cursor::Pen, + _ => Cursor::Crosshair, + }; + let w = doc.world_transform(ve.id); + match ve.tool { + VTool::Pen => { + if let Some(a) = ve.anchor.and_then(|a| network(&doc, ve.id)?.vertices.get(a).copied()) { + let ap = w * a.point(); + self.tool.overlay.rubber = Some([ap.x, ap.y, ev.x, ev.y]); + } + } + VTool::Paint => { + // Highlight the closed area the bucket would fill (skipped on huge networks). + if let Some(net) = network(&doc, ve.id).filter(|n| n.segments.len() <= 3000) + && let Some(face) = net.face_at(w.inverse() * ev.p()) + { + let mut polys: Vec> = Vec::new(); + let mut path = face.path.clone(); + path.apply_affine(w); + figcraft_geom::kurbo::flatten(path.iter(), 0.25 / ev.zoom.max(1e-6), |el| { + use figcraft_geom::kurbo::PathEl; + match el { + PathEl::MoveTo(p) => polys.push(vec![[p.x, p.y]]), + PathEl::LineTo(p) => { + if let Some(l) = polys.last_mut() { + l.push([p.x, p.y]); + } + } + _ => {} + } + }); + self.tool.overlay.face = polys; + } + } + _ => {} + } + if let Ok(ds) = self.ds_mut() { + ds.revision += 1; + } + Ok(()) + } + + /// Returns false when the click left edit mode (the caller then runs the normal tool). + fn vector_down(&mut self, ve: &VectorEdit, ev: &PointerEvent) -> Result { + let doc = self.doc()?.clone(); + let tol = 6.0 / ev.zoom.max(1e-6); + let h = hit(&doc, ve, ev.p(), tol); + self.tool.overlay.vector_hover = None; + self.tool.overlay.face.clear(); + let tool = if ev.cmd && ve.tool == VTool::Move { VTool::Bend } else { ve.tool }; + let id = ve.id; + let w = doc.world_transform(id); + match tool { + VTool::Move => match h { + Some(VHit::Handle { seg, start }) => { + self.begin_interaction("Edit handle")?; + self.vgesture(VGesture::Handle { seg, start, independent: ev.alt }); + } + Some(VHit::Vertex { index }) => { + let verts = if ev.shift { + let mut v = ve.vertices.clone(); + if let Some(i) = v.iter().position(|x| *x == index) { + v.remove(i); + } else { + v.push(index); + } + v + } else if ve.vertices.contains(&index) { + ve.vertices.clone() + } else { + vec![index] + }; + let keep_segs = ev.shift; + set_state(self, |e| { + e.vertices = verts.clone(); + if !keep_segs { + e.segments.clear(); + } + })?; + let moving = network(&doc, id) + .map(|n| { + super::selected_points( + n, + &VectorEdit { vertices: verts, segments: if keep_segs { ve.segments.clone() } else { vec![] }, ..ve.clone() }, + ) + }) + .unwrap_or_default(); + self.begin_interaction("Move points")?; + self.vgesture(VGesture::Points { start: ev.p(), verts: moving, split: None, moved: false }); + } + Some(VHit::Segment { seg, t }) => { + if ev.alt { + // Add a point on the segment and drag it. + self.begin_interaction("Add point")?; + let mut v = None; + self.preview(|doc, _| { + v = edit(doc, id, |net| ops::split_segment(net, seg, t))?; + Ok(()) + })?; + let Some(v) = v else { return Ok(true) }; + set_state(self, |e| { + e.vertices = vec![v]; + e.segments.clear(); + })?; + self.vgesture(VGesture::Points { start: ev.p(), verts: vec![v], split: Some((seg, t)), moved: false }); + } else if ev.shift { + set_state(self, |e| { + if let Some(i) = e.segments.iter().position(|x| *x == seg) { + e.segments.remove(i); + } else { + e.segments.push(seg); + } + })?; + } else { + let ends = network(&doc, id).and_then(|n| n.segments.get(seg)).map(|s| vec![s.a, s.b]).unwrap_or_default(); + set_state(self, |e| { + e.vertices.clear(); + e.segments = vec![seg]; + })?; + self.begin_interaction("Move segment")?; + self.vgesture(VGesture::Points { start: ev.p(), verts: ends, split: None, moved: false }); + } + } + None => { + // Outside the shape entirely (and not shift): leave edit mode. + let inside = doc.world_render_bounds(id).is_some_and(|b| b.inflate(tol * 4.0, tol * 4.0).contains(ev.p())); + if !inside && !ev.shift { + super::end(self)?; + return Ok(false); + } + let base = if ev.shift { ve.vertices.clone() } else { vec![] }; + set_state(self, |e| { + e.vertices = base.clone(); + if !ev.shift { + e.segments.clear(); + } + })?; + self.vgesture(VGesture::Marquee { start: ev.p(), base }); + } + }, + VTool::Bend => match h { + Some(VHit::Handle { seg, start }) => { + self.begin_interaction("Edit handle")?; + self.vgesture(VGesture::Handle { seg, start, independent: true }); + } + Some(VHit::Vertex { index }) => { + let smooth = + network(&doc, id).is_some_and(|n| n.incident(index).iter().any(|(s, st)| n.handle(*s, *st).is_some_and(|h| h != (0.0, 0.0)))); + let origin = network(&doc, id).and_then(|n| n.vertices.get(index)).map(|v| v.point()).unwrap_or_default(); + set_state(self, |e| { + e.vertices = vec![index]; + e.segments.clear(); + })?; + self.begin_interaction("Bend")?; + self.vgesture(VGesture::BendVertex { v: index, origin, moved: false, smooth }); + } + Some(VHit::Segment { seg, t }) => { + self.begin_interaction("Bend")?; + self.vgesture(VGesture::BendSegment { seg, t }); + } + None => { + let base = if ev.shift { ve.vertices.clone() } else { vec![] }; + self.vgesture(VGesture::Marquee { start: ev.p(), base }); + } + }, + VTool::Pen => { + let Some(plan) = self.pen_plan(ve, h, w.inverse() * ev.p(), ev.shift) else { return Ok(true) }; + self.begin_interaction("Pen")?; + let out = ve.pen_out; + let mut v = None; + self.preview(|doc, _| { + v = edit(doc, id, |net| apply_pen(net, plan, out, None))?; + Ok(()) + })?; + self.pen_state(plan, v, None)?; + self.vgesture(VGesture::Pen { plan, origin: ev.p(), out }); + } + VTool::Paint => { + self.begin_interaction("Paint bucket")?; + let lp = w.inverse() * ev.p(); + if self.preview(|doc, _| super::paint(doc, id, lp).map(|_| ())).is_ok() { + self.commit_interaction()?; + } else { + self.cancel_interaction()?; + } + } + VTool::Lasso => { + let base = if ev.shift { ve.vertices.clone() } else { vec![] }; + self.tool.overlay.lasso = vec![[ev.x, ev.y]]; + self.vgesture(VGesture::Lasso { points: vec![ev.p()], base }); + } + VTool::Cut => { + let res: Option> = match h { + Some(VHit::Vertex { index }) => { + self.begin_interaction("Cut")?; + let mut out = vec![]; + self.preview(|doc, _| { + out = edit(doc, id, |net| ops::cut_vertex(net, index))?; + Ok(()) + })?; + Some(out) + } + Some(VHit::Segment { seg, t }) => { + self.begin_interaction("Cut")?; + let mut out = vec![]; + self.preview(|doc, _| { + out = edit(doc, id, |net| ops::cut_segment(net, seg, t))?.map(|(a, b)| vec![a, b]).unwrap_or_default(); + Ok(()) + })?; + Some(out) + } + _ => None, + }; + if let Some(ends) = res { + self.commit_interaction()?; + set_state(self, |e| { + e.vertices = ends; + e.segments.clear(); + })?; + } + } + } + Ok(true) + } + + /// What a pen click at local point `lp` does. + fn pen_plan(&mut self, ve: &VectorEdit, h: Option, lp: Point, shift: bool) -> Option { + let doc = self.doc().ok()?; + let net = network(doc, ve.id)?; + match h { + Some(VHit::Vertex { index }) => match ve.anchor { + Some(a) if a != index => Some(PenPlan::Connect { from: a, to: index }), + Some(_) => { + let _ = super::escape(self); + None + } + None => { + // Continue (or branch) from an existing point. + let _ = set_state(self, |e| { + e.anchor = Some(index); + e.pen_out = None; + e.vertices = vec![index]; + e.segments.clear(); + }); + None + } + }, + Some(VHit::Segment { seg, t }) => Some(PenPlan::Split { seg, t, from: ve.anchor }), + _ => { + let mut at = lp; + // Shift: 45° steps from the open end. + if shift && let Some(a) = ve.anchor.and_then(|a| net.vertices.get(a)) { + let v = lp - a.point(); + let step = std::f64::consts::FRAC_PI_4; + let ang = (v.atan2() / step).round() * step; + at = a.point() + Vec2::from_angle(ang) * v.hypot(); + } + Some(PenPlan::New { at, from: ve.anchor }) + } + } + } + + /// Edit state after a pen click. + fn pen_state(&mut self, plan: PenPlan, v: Option, out: Option<(f64, f64)>) -> Result<()> { + set_state(self, |e| { + e.segments.clear(); + e.vertices = v.into_iter().collect(); + match plan { + PenPlan::New { .. } => { + e.anchor = v; + e.pen_out = out; + } + PenPlan::Connect { .. } | PenPlan::Split { .. } => { + e.anchor = None; + e.pen_out = None; + } + } + }) + } + + /// A pen click from a command (`drag` = the handle pulled out of the new point, page units). + pub(crate) fn pen_click(&mut self, ve: &VectorEdit, p: Point, drag: Vec2, zoom: f64) -> Result> { + let doc = self.doc()?.clone(); + let tol = 6.0 / zoom.max(1e-6); + let w = doc.world_transform(ve.id); + let Some(plan) = self.pen_plan(ve, hit(&doc, ve, p, tol), w.inverse() * p, false) else { + return Ok(self.ds()?.vector_edit.as_ref().and_then(|e| e.anchor)); + }; + let inv = w.inverse(); + let ld = inv * (Point::ZERO + drag) - inv * Point::ZERO; + let drag = (ld.hypot() > 1e-9 && ld.x.is_finite() && ld.y.is_finite()).then_some(ld); + let v = edit(self.doc_mut()?, ve.id, |net| apply_pen(net, plan, ve.pen_out, drag))?; + self.pen_state(plan, v, drag.map(|d| (d.x, d.y)))?; + Ok(v) + } + + fn vector_drag(&mut self, ve: &VectorEdit, ev: &PointerEvent) -> Result<()> { + let Gesture::Vector(g) = self.tool.gesture.clone() else { return Ok(()) }; + let id = ve.id; + let w = self.doc()?.world_transform(id); + let inv = w.inverse(); + let lp = inv * ev.p(); + let to_local = |d: Vec2| inv * (Point::ZERO + d) - inv * Point::ZERO; + match g { + VGesture::Points { start, verts, split, .. } => { + let mut d = ev.p() - start; + if d.hypot() * ev.zoom < 1.0 { + return Ok(()); + } + if ev.shift { + if d.x.abs() > d.y.abs() { + d.y = 0.0; + } else { + d.x = 0.0; + } + } + let ld = to_local(d); + self.preview(|doc, _| { + edit(doc, id, |net| { + if let Some((seg, t)) = split { + ops::split_segment(net, seg, t); + } + ops::move_vertices(net, &verts, ld); + }) + })?; + self.vgesture(VGesture::Points { start, verts, split, moved: true }); + } + VGesture::Handle { seg, start, independent } => { + let alt = independent || ev.alt; + self.preview(|doc, _| { + edit(doc, id, |net| { + let Some(s) = net.segments.get(seg).copied() else { return }; + let Some(v) = net.vertices.get(if start { s.a } else { s.b }).copied() else { return }; + ops::set_handle(net, seg, start, (lp.x - v.x, lp.y - v.y), alt); + }) + })?; + } + VGesture::BendSegment { seg, t } => { + self.preview(|doc, _| edit(doc, id, |net| ops::bend(net, seg, t, lp)))?; + } + VGesture::BendVertex { v, origin, moved, smooth } => { + let d = lp - origin; + let page_d = (w * lp - w * origin).hypot() * ev.zoom; + if !moved && page_d < 2.0 { + return Ok(()); + } + self.preview(|doc, _| edit(doc, id, |net| ops::make_smooth(net, v, d)))?; + self.vgesture(VGesture::BendVertex { v, origin, moved: true, smooth }); + } + VGesture::Marquee { start, base } => { + let r = Rect::from_points(start, ev.p()); + self.tool.overlay.marquee = Some([r.x0, r.y0, r.x1, r.y1]); + let mut v = base.clone(); + for i in super::vertices_in(self.doc()?, id, r) { + if !v.contains(&i) { + v.push(i); + } + } + set_state(self, |e| e.vertices = v)?; + } + VGesture::Lasso { mut points, base } => { + if points.last().is_none_or(|l| (*l - ev.p()).hypot() * ev.zoom >= 2.0) && points.len() < 100_000 { + points.push(ev.p()); + } + self.tool.overlay.lasso = points.iter().map(|p| [p.x, p.y]).collect(); + let mut v = base.clone(); + for i in super::vertices_in_polygon(self.doc()?, id, &points) { + if !v.contains(&i) { + v.push(i); + } + } + set_state(self, |e| { + e.vertices = v; + e.segments.clear(); + })?; + self.vgesture(VGesture::Lasso { points, base }); + } + VGesture::Pen { plan, origin, out, .. } => { + let d = to_local(ev.p() - origin); + if (ev.p() - origin).hypot() * ev.zoom < 2.0 { + return Ok(()); + } + let mut v = None; + self.preview(|doc, _| { + v = edit(doc, id, |net| apply_pen(net, plan, out, Some(d)))?; + Ok(()) + })?; + self.pen_state(plan, v, Some((d.x, d.y)))?; + self.vgesture(VGesture::Pen { plan, origin, out }); + } + } + Ok(()) + } + + fn vector_up(&mut self, ve: &VectorEdit, _ev: &PointerEvent) -> Result<()> { + let g = std::mem::take(&mut self.tool.gesture); + self.tool.overlay.marquee = None; + self.tool.overlay.lasso.clear(); + let Gesture::Vector(g) = g else { return Ok(()) }; + match g { + VGesture::Points { moved, split, .. } => { + if moved || split.is_some() { + self.commit_interaction()?; + } else { + self.cancel_interaction()?; + } + } + VGesture::BendVertex { v, moved, smooth, .. } => { + if moved { + self.commit_interaction()?; + } else if smooth { + let id = ve.id; + self.preview(|doc, _| edit(doc, id, |net| ops::make_sharp(net, v)))?; + self.commit_interaction()?; + } else { + self.cancel_interaction()?; + } + } + VGesture::Handle { .. } | VGesture::BendSegment { .. } | VGesture::Pen { .. } => self.commit_interaction()?, + VGesture::Marquee { .. } | VGesture::Lasso { .. } => {} + } + if let Ok(ds) = self.ds_mut() { + ds.revision += 1; + } + Ok(()) + } +} diff --git a/crates/engine/src/vectoredit/tests.rs b/crates/engine/src/vectoredit/tests.rs new file mode 100644 index 00000000..1a26fbf7 --- /dev/null +++ b/crates/engine/src/vectoredit/tests.rs @@ -0,0 +1,321 @@ +//! Vector edit mode through the session: tools, pointer gestures, keys and undo. + +use serde_json::{Value, json}; + +use super::*; +use crate::EngineError; +use crate::tools::{PointerEvent, PointerKind}; + +fn ex(s: &mut Session, c: &str, p: Value) -> Value { + s.execute(c, &p).unwrap_or_else(|e| panic!("{c}: {e}")) +} + +fn net(s: &Session, id: NodeId) -> VectorNetwork { + network(s.doc().unwrap(), id).unwrap().clone() +} + +fn ev(kind: PointerKind, x: f64, y: f64) -> PointerEvent { + PointerEvent::at(kind, x, y, 1.0) +} + +fn click(s: &mut Session, x: f64, y: f64) { + s.pointer(&ev(PointerKind::Down, x, y)).unwrap(); + s.pointer(&ev(PointerKind::Up, x, y)).unwrap(); +} + +fn drag(s: &mut Session, from: (f64, f64), to: (f64, f64)) { + s.pointer(&ev(PointerKind::Down, from.0, from.1)).unwrap(); + s.pointer(&ev(PointerKind::Move, (from.0 + to.0) / 2.0, (from.1 + to.1) / 2.0)).unwrap(); + s.pointer(&ev(PointerKind::Move, to.0, to.1)).unwrap(); + s.pointer(&ev(PointerKind::Up, to.0, to.1)).unwrap(); +} + +/// A 100×100 rectangle at the origin, in edit mode. +fn rect(s: &mut Session) -> NodeId { + let r = ex(s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 100, "height": 100})); + let id = crate::params::id_of(&r["id"]).unwrap(); + ex(s, "vector.edit.begin", json!({"id": id})); + id +} + +fn ve(s: &Session) -> VectorEdit { + s.ds().unwrap().vector_edit.clone().unwrap() +} + +fn vertex_at(n: &VectorNetwork, x: f64, y: f64) -> usize { + n.vertices.iter().position(|v| (v.x - x).abs() < 1e-6 && (v.y - y).abs() < 1e-6).unwrap() +} + +fn pt(x: f64, y: f64) -> Point { + Point::new(x, y) +} + +#[test] +fn pen_extends_branches_and_closes_paths() { + let mut s = Session::new(); + let r = ex(&mut s, "vector.create", json!({"points": [[0, 0], [100, 0]], "closed": false})); + let id = crate::params::id_of(&r["id"]).unwrap(); + ex(&mut s, "vector.edit.begin", json!({"id": id})); + ex(&mut s, "vector.edit.tool", json!({"tool": "pen"})); + // Click the end point to continue from it, then add a point below and close onto the start. + click(&mut s, 100.0, 0.0); + assert!(ve(&s).anchor.is_some()); + click(&mut s, 100.0, 100.0); + let n = net(&s, id); + assert_eq!((n.vertices.len(), n.segments.len()), (3, 2)); + click(&mut s, 0.0, 0.0); + let n = net(&s, id); + assert_eq!(n.segments.len(), 3); + assert_eq!(n.regions.len(), 1, "closing the path makes a fill region"); + assert!(ve(&s).anchor.is_none(), "closing ends the path"); + // Branch from an existing corner. + click(&mut s, 100.0, 100.0); + click(&mut s, 200.0, 150.0); + let n = net(&s, id); + let corner = vertex_at(&n, 100.0, 100.0); + assert_eq!(n.incident(corner).len(), 3, "a vector network branch"); + // Escape ends the path but stays in edit mode; the next Escape leaves. + s.escape().unwrap(); + assert!(ve(&s).anchor.is_none()); + s.escape().unwrap(); + assert!(s.ds().unwrap().vector_edit.is_none()); +} + +#[test] +fn pen_drag_makes_a_smooth_point() { + let mut s = Session::new(); + let id = rect(&mut s); + ex(&mut s, "vector.edit.tool", json!({"tool": "pen"})); + click(&mut s, 100.0, 0.0); + drag(&mut s, (150.0, 50.0), (150.0, 80.0)); + let n = net(&s, id); + let v = n.vertices.len() - 1; + assert_eq!(n.mirroring(v), HandleMirroring::AngleAndLength); + let (seg, start) = n.incident(v)[0]; + let h = n.handle(seg, start).unwrap(); + assert!(h.0.abs() < 1e-6 && (h.1 + 30.0).abs() < 1e-6, "incoming handle mirrors the drag: {h:?}"); + assert_eq!(ve(&s).pen_out, Some((0.0, 30.0))); + // The next segment starts with the dragged-out handle. + click(&mut s, 250.0, 50.0); + let n = net(&s, id); + let last = *n.segments.last().unwrap(); + assert_eq!(last.ta, (0.0, 30.0)); + // One undo step per click. + assert!(s.undo().unwrap()); + assert_eq!(net(&s, id).vertices.len(), n.vertices.len() - 1); +} + +#[test] +fn bend_tool_smooths_and_sharpens_points() { + let mut s = Session::new(); + let id = rect(&mut s); + ex(&mut s, "vector.edit.tool", json!({"tool": "bend"})); + drag(&mut s, (100.0, 0.0), (130.0, 0.0)); + let n = net(&s, id); + let v = vertex_at(&n, 100.0, 0.0); + assert_eq!(n.mirroring(v), HandleMirroring::Angle); + assert!(n.incident(v).iter().all(|(s, st)| n.handle(*s, *st) != Some((0.0, 0.0)))); + click(&mut s, 100.0, 0.0); + let n = net(&s, id); + let v = vertex_at(&n, 100.0, 0.0); + assert!(n.incident(v).iter().all(|(s, st)| n.handle(*s, *st) == Some((0.0, 0.0))), "a click sharpens it"); + // ⌘-drag on a segment with the Move tool bends it. + ex(&mut s, "vector.edit.tool", json!({"tool": "move"})); + let mut down = ev(PointerKind::Down, 0.0, 50.0); + down.cmd = true; + s.pointer(&down).unwrap(); + s.pointer(&ev(PointerKind::Move, -40.0, 50.0)).unwrap(); + s.pointer(&ev(PointerKind::Up, -40.0, 50.0)).unwrap(); + let b = s.doc().unwrap().world_bounds(id).unwrap(); + assert!(b.x0 < -25.0, "bent outwards: {b:?}"); +} + +#[test] +fn paint_bucket_fills_and_unfills_areas() { + let mut s = Session::new(); + let id = rect(&mut s); + ex(&mut s, "vector.edit.connect", json!({"a": 0, "b": 2})); + ex(&mut s, "vector.edit.tool", json!({"tool": "paint"})); + assert!(net(&s, id).fill_contains(pt(75.0, 25.0))); + // Hovering highlights the area; clicking unfills just that triangle. + s.pointer(&ev(PointerKind::Hover, 75.0, 25.0)).unwrap(); + assert!(!s.tool.overlay.face.is_empty()); + click(&mut s, 75.0, 25.0); + let n = net(&s, id); + assert!(!n.fill_contains(pt(75.0, 25.0))); + assert!(n.fill_contains(pt(25.0, 75.0))); + click(&mut s, 75.0, 25.0); + assert!(net(&s, id).fill_contains(pt(75.0, 25.0))); + s.undo().unwrap(); + assert!(!net(&s, id).fill_contains(pt(75.0, 25.0))); + // A vector without fills gets one when painted. + ex(&mut s, "node.set", json!({"id": id, "props": {"fills": []}})); + let r = ex(&mut s, "vector.edit.paint", json!({"x": 75, "y": 25})); + assert_eq!(r["filled"], json!(true)); + assert!(!s.doc().unwrap().node(id).unwrap().fills.is_empty()); + assert!(s.execute("vector.edit.paint", &json!({"x": 500, "y": 500})).is_err(), "outside any area"); +} + +#[test] +fn lasso_marquee_and_segment_selection() { + let mut s = Session::new(); + let _id = rect(&mut s); + ex(&mut s, "vector.edit.tool", json!({"tool": "lasso"})); + s.pointer(&ev(PointerKind::Down, -10.0, -10.0)).unwrap(); + for (x, y) in [(110.0, -10.0), (110.0, 10.0), (-10.0, 10.0)] { + s.pointer(&ev(PointerKind::Move, x, y)).unwrap(); + } + assert!(!s.tool.overlay.lasso.is_empty()); + s.pointer(&ev(PointerKind::Up, -10.0, 10.0)).unwrap(); + assert_eq!(ve(&s).vertices.len(), 2, "the top two points"); + assert!(s.tool.overlay.lasso.is_empty()); + // Move tool: clicking a segment selects it; shift adds another. + ex(&mut s, "vector.edit.tool", json!({"tool": "move"})); + click(&mut s, 50.0, 100.0); + assert_eq!(ve(&s).segments.len(), 1); + assert!(ve(&s).vertices.is_empty()); + let mut sh = ev(PointerKind::Down, 0.0, 50.0); + sh.shift = true; + s.pointer(&sh).unwrap(); + s.pointer(&ev(PointerKind::Up, 0.0, 50.0)).unwrap(); + assert_eq!(ve(&s).segments.len(), 2); + ex(&mut s, "vector.edit.selectAll", json!({})); + assert_eq!(ve(&s).vertices.len(), 4); +} + +#[test] +fn alt_click_adds_a_point_that_drags_in_the_same_gesture() { + let mut s = Session::new(); + let id = rect(&mut s); + let mut down = ev(PointerKind::Down, 50.0, 0.0); + down.alt = true; + s.pointer(&down).unwrap(); + s.pointer(&ev(PointerKind::Move, 50.0, -20.0)).unwrap(); + s.pointer(&ev(PointerKind::Up, 50.0, -20.0)).unwrap(); + assert_eq!(net(&s, id).vertices.len(), 5); + let b = s.doc().unwrap().world_bounds(id).unwrap(); + assert_eq!(b.y0, -20.0, "the new point was dragged up"); + s.undo().unwrap(); + assert_eq!(net(&s, id).vertices.len(), 4, "add + drag is one step"); +} + +#[test] +fn cut_tool_and_keys() { + let mut s = Session::new(); + let id = rect(&mut s); + ex(&mut s, "vector.edit.tool", json!({"tool": "cut"})); + click(&mut s, 50.0, 0.0); + assert_eq!(net(&s, id).vertices.len(), 6); + assert_eq!(ve(&s).vertices.len(), 2); + // Keys: tool letters, arrows nudge, ⌘A selects all, Delete removes, Enter leaves. + assert!(key(&mut s, "V", false, false, false).unwrap()); + assert_eq!(ve(&s).tool, VTool::Move); + assert!(key(&mut s, "Q", false, false, false).unwrap()); + assert_eq!(ve(&s).tool, VTool::Lasso); + assert!(key(&mut s, "B", true, false, false).unwrap()); + assert_eq!(ve(&s).tool, VTool::Paint); + let v = vertex_at(&net(&s, id), 100.0, 100.0); + ex(&mut s, "vector.edit.select", json!({"vertices": [v]})); + assert!(key(&mut s, "Right", false, false, false).unwrap()); + let w = s.doc().unwrap().world_transform(id); + assert_eq!((w * net(&s, id).vertices[v].point()).x, 101.0); + assert!(key(&mut s, "Down", true, false, false).unwrap()); + let w = s.doc().unwrap().world_transform(id); + assert_eq!((w * net(&s, id).vertices[v].point()).y, 110.0); + assert!(key(&mut s, "A", false, false, true).unwrap()); + assert_eq!(ve(&s).vertices.len(), 6); + assert!(!key(&mut s, "Z", false, false, true).unwrap(), "undo falls through to shortcuts"); + ex(&mut s, "vector.edit.select", json!({"vertices": [v]})); + assert!(key(&mut s, "Backspace", false, false, false).unwrap()); + assert_eq!(net(&s, id).vertices.len(), 5); + assert!(key(&mut s, "Enter", false, false, false).unwrap()); + assert!(s.ds().unwrap().vector_edit.is_none()); + assert!(!key(&mut s, "V", false, false, false).unwrap(), "keys pass through outside edit mode"); +} + +#[test] +fn delete_vs_delete_and_heal() { + let mut s = Session::new(); + let id = rect(&mut s); + ex(&mut s, "vector.edit.select", json!({"vertices": [1]})); + ex(&mut s, "vector.edit.delete", json!({})); + let n = net(&s, id); + assert_eq!((n.vertices.len(), n.segments.len()), (3, 2), "the path opens"); + s.undo().unwrap(); + ex(&mut s, "vector.edit.select", json!({"vertices": [1]})); + ex(&mut s, "vector.deleteHeal", json!({})); + let n = net(&s, id); + assert_eq!((n.vertices.len(), n.segments.len(), n.regions.len()), (3, 3, 1), "healed and closed"); + // Deleting a selected segment keeps its points. + s.undo().unwrap(); + ex(&mut s, "vector.edit.select", json!({"segments": [0]})); + ex(&mut s, "vector.edit.delete", json!({})); + let n = net(&s, id); + assert_eq!((n.vertices.len(), n.segments.len()), (4, 3)); +} + +#[test] +fn mirroring_position_and_join_commands() { + let mut s = Session::new(); + let id = rect(&mut s); + ex(&mut s, "vector.edit.select", json!({"vertices": [1]})); + ex(&mut s, "vector.edit.smooth", json!({})); + ex(&mut s, "vector.edit.mirroring", json!({"mode": "angleAndLength"})); + let st = ex(&mut s, "vector.edit.state", json!({})); + assert_eq!(st["mirroring"][1], json!("angleAndLength")); + assert_eq!(st["tool"], json!("move")); + assert!(s.execute("vector.edit.mirroring", &json!({"mode": "sideways"})).is_err()); + // Position: move the selected point to x = -50 in parent coordinates. + ex(&mut s, "vector.edit.select", json!({"vertices": [0]})); + ex(&mut s, "vector.edit.position", json!({"x": -50})); + let p = selection_position(s.doc().unwrap(), &ve(&s)).unwrap(); + assert!((p.x + 50.0).abs() < 1e-6, "{p:?}"); + // Join: cut a corner open, then join its two ends back (they overlap: merged). + ex(&mut s, "vector.edit.cut", json!({"vertex": 2})); + let before = net(&s, id).vertices.len(); + ex(&mut s, "vector.join", json!({})); + assert_eq!(net(&s, id).vertices.len(), before - 1); + // Outside edit mode, vector.join keeps its layer behaviour. + ex(&mut s, "vector.edit.end", json!({})); + assert!(s.execute("vector.join", &json!({"ids": [id]})).is_ok()); +} + +#[test] +fn undo_back_past_the_conversion_leaves_edit_mode() { + let mut s = Session::new(); + let id = rect(&mut s); + assert!(s.ds().unwrap().vector_edit.is_some()); + s.undo().unwrap(); + assert_eq!(s.doc().unwrap().node(id).unwrap().kind.type_name(), "RECTANGLE"); + assert!(s.ds().unwrap().vector_edit.is_none()); + // Choosing a drawing tool leaves edit mode too. + let _ = rect(&mut s); + s.set_tool(crate::tools::ToolId::Rectangle); + assert!(s.ds().unwrap().vector_edit.is_none()); +} + +#[test] +fn every_command_survives_junk_params_while_editing() { + let junk = [ + json!({}), + json!(null), + json!({"vertices": [-1, 1e12, "x"], "segments": [99999], "segment": -5, "t": "NaN", "x": 1e308, "y": -1e308}), + json!({"segment": 0, "t": 2, "x": 5, "y": 5, "dx": 1e300, "dy": 1, "a": 0, "b": 0, "vertex": 99}), + json!({"points": [[0, 0], [1], "x", [5, 5], [0, 9]], "mode": 7, "tool": "nope", "radius": -3}), + ]; + for spec in crate::all_commands().iter().filter(|c| c.id.starts_with("vector.")) { + for j in &junk { + let mut s = Session::new(); + let _ = rect(&mut s); + if let Err(EngineError::Internal { cmd, msg }) = s.execute(spec.id, j) { + panic!("{cmd} panicked on {j}: {msg}"); + } + // The network stays sane. + if let Some(ve) = s.ds().unwrap().vector_edit.clone() + && let Some(n) = network(s.doc().unwrap(), ve.id) + { + assert!(n.segments.iter().all(|x| x.a < n.vertices.len() && x.b < n.vertices.len()), "{} broke the network", spec.id); + } + } + } +} diff --git a/crates/pathops/src/lib.rs b/crates/pathops/src/lib.rs index 6252a7e2..6a11d855 100644 --- a/crates/pathops/src/lib.rs +++ b/crates/pathops/src/lib.rs @@ -133,7 +133,7 @@ fn kjoin(j: StrokeJoin) -> Join { /// Plain centred stroke of `path` at `width`. pub fn stroke_center(path: &BezPath, width: f64, props: &StrokeProps) -> BezPath { - if !(width.is_finite() && width > 0.0) || !finite(path) { + if !(width.is_finite() && width > 0.0 && finite(path)) { return BezPath::new(); } let mut style = kurbo::Stroke::new(width) diff --git a/crates/pdf/src/draw.rs b/crates/pdf/src/draw.rs index e85348d9..ad3bdc42 100644 --- a/crates/pdf/src/draw.rs +++ b/crates/pdf/src/draw.rs @@ -443,7 +443,7 @@ impl<'a> Exporter<'a> { #[allow(clippy::too_many_arguments)] fn raster_paint(&mut self, s: &mut Surface, path: &BezPath, kp: &Path, r: FillRule, p: &Paint, w: f64, h: f64, xf: Affine) { let bb = path.bounding_box(); - if !(bb.width() > 0.0 && bb.height() > 0.0) || !crate::rect_finite(bb) { + if !(bb.width() > 0.0 && bb.height() > 0.0 && crate::rect_finite(bb)) { return; } let page_scale = xf.determinant().abs().sqrt(); diff --git a/crates/pdf/src/raster.rs b/crates/pdf/src/raster.rs index 4bb445a2..cc98413b 100644 --- a/crates/pdf/src/raster.rs +++ b/crates/pdf/src/raster.rs @@ -46,7 +46,7 @@ impl Exporter<'_> { /// [`MAX_RASTER_SIDE`] pixels a side. fn raster_view(&self, b: Rect) -> Option { let b = b.intersect(self.page_rect); - if !(b.width() > 0.0 && b.height() > 0.0) || !crate::rect_finite(b) { + if !(b.width() > 0.0 && b.height() > 0.0 && crate::rect_finite(b)) { return None; } let mut k = self.raster_scale(); diff --git a/crates/text/src/layout.rs b/crates/text/src/layout.rs index 4af7f08c..613b2c75 100644 --- a/crates/text/src/layout.rs +++ b/crates/text/src/layout.rs @@ -606,7 +606,7 @@ impl TextLayout { let last_line = li + 1 == self.lines.len(); let in_line = index >= line.char_start && (index < line.char_end || (last_line && index <= line.char_end)); // A caret at the end of a soft-wrapped line belongs to the next line. - if !in_line && !(index == line.char_end && (line.para_end && !last_line)) { + if !(in_line || index == line.char_end && line.para_end && !last_line) { continue; } if index == line.char_end && line.para_end && !last_line { diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs index c6f6c887..ca8db56c 100644 --- a/crates/ui-egui/src/canvas.rs +++ b/crates/ui-egui/src/canvas.rs @@ -512,32 +512,10 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) { painter.line_segment([app.to_screen(x0, y0), app.to_screen(x1, y1)], stroke(ACCENT, 2.0)); } // Vector edit mode. - if let Some((vid, vsel)) = ds.vector_edit.clone() - && let Some(o) = figcraft_engine::vectoredit::overlay(&doc, vid, &vsel) + if let Some(ve) = ds.vector_edit.clone() + && let Some(o) = figcraft_engine::vectoredit::overlay(&doc, &ve) { - let pt = |v: &serde_json::Value| -> Option { Some(app.to_screen(v.get(0)?.as_f64()?, v.get(1)?.as_f64()?)) }; - for seg in o["segments"].as_array().cloned().unwrap_or_default() { - let pts: Vec = seg.as_array().map(|a| a.iter().filter_map(pt).collect()).unwrap_or_default(); - if let [a, b, c, d] = pts.as_slice() { - painter.add(egui::epaint::CubicBezierShape::from_points_stroke([*a, *b, *c, *d], false, Color32::TRANSPARENT, stroke(ACCENT, 1.5))); - } - } - for h in o["handles"].as_array().cloned().unwrap_or_default() { - let pts: Vec = h.as_array().map(|a| a.iter().filter_map(pt).collect()).unwrap_or_default(); - if let [a, b] = pts.as_slice() { - painter.line_segment([*a, *b], stroke(ACCENT, 1.0)); - painter.circle_filled(*b, 3.5, Color32::WHITE); - painter.circle_stroke(*b, 3.5, stroke(ACCENT, 1.0)); - } - } - for (i, v) in o["vertices"].as_array().cloned().unwrap_or_default().iter().enumerate() { - if let Some(p) = pt(v) { - let r = Rect::from_center_size(p, vec2(7.0, 7.0)); - let on = vsel.contains(&i); - painter.rect_filled(r, CornerRadius::same(4), if on { ACCENT } else { Color32::WHITE }); - painter.rect_stroke(r, CornerRadius::same(4), stroke(ACCENT, 1.0), StrokeKind::Inside); - } - } + vector_overlay(app, painter, &o); } // Selection. let editing = ds.text_edit.clone(); @@ -658,12 +636,112 @@ fn overlays(app: &FigApp, painter: &egui::Painter, t: &Tokens) { } } } + // Lasso (vector edit mode). + if ov.lasso.len() > 1 { + let mut pts: Vec = ov.lasso.iter().map(|[x, y]| app.to_screen(*x, *y)).collect(); + if let Some(first) = pts.first().copied() { + pts.push(first); + } + painter.add(Shape::dashed_line(&pts, stroke(ACCENT, 1.0), 4.0, 3.0)); + } // Rulers. if view.rulers { rulers(app, painter, t, &doc, &sel); } } +/// Vector edit mode: the network's segments, handles and points, the hovered part, the closed +/// area under the paint bucket and the pen's rubber band. +fn vector_overlay(app: &FigApp, painter: &egui::Painter, o: &figcraft_engine::vectoredit::EditOverlay) { + use figcraft_engine::vectoredit::VHit; + let ov = &app.session.tool.overlay; + let sp = |p: &[f64; 2]| app.to_screen(p[0], p[1]); + // Paint bucket target: hatched like a fill to come. + if !ov.face.is_empty() { + let polys: Vec> = ov.face.iter().map(|poly| poly.iter().map(sp).collect()).collect(); + for l in hatch(&polys, 5.0) { + painter.line_segment(l, stroke(ACCENT, 1.0)); + } + for poly in &polys { + painter.add(Shape::closed_line(poly.clone(), stroke(ACCENT, 2.0))); + } + } + let hover_seg = match ov.vector_hover { + Some(VHit::Segment { seg, .. }) => Some(seg), + _ => None, + }; + for (i, seg) in o.segments.iter().enumerate() { + let [a, b, c, d] = [sp(&seg[0]), sp(&seg[1]), sp(&seg[2]), sp(&seg[3])]; + let w = if o.selected_segments.contains(&i) { + 3.0 + } else if hover_seg == Some(i) { + 2.5 + } else { + 1.5 + }; + painter.add(egui::epaint::CubicBezierShape::from_points_stroke([a, b, c, d], false, Color32::TRANSPARENT, stroke(ACCENT, w))); + } + for h in &o.handles { + let (v, e) = (sp(&h.vertex), sp(&h.handle)); + painter.line_segment([v, e], stroke(ACCENT, 1.0)); + let hovered = ov.vector_hover == Some(VHit::Handle { seg: h.seg, start: h.start }); + let r = if hovered { 4.5 } else { 3.5 }; + painter.circle_filled(e, r, Color32::WHITE); + painter.circle_stroke(e, r, stroke(ACCENT, 1.0)); + } + for (i, v) in o.vertices.iter().enumerate() { + let p = sp(v); + let hovered = matches!(ov.vector_hover, Some(VHit::Vertex { index }) if index == i); + let size = if hovered { 9.0 } else { 7.0 }; + let r = Rect::from_center_size(p, vec2(size, size)); + let on = o.selected_vertices.contains(&i); + painter.rect_filled(r, CornerRadius::same(5), if on { ACCENT } else { Color32::WHITE }); + painter.rect_stroke(r, CornerRadius::same(5), stroke(ACCENT, 1.0), StrokeKind::Inside); + if o.anchor == Some(i) { + painter.circle_stroke(p, 7.5, stroke(ACCENT, 1.0)); + } + } + if let Some([x0, y0, x1, y1]) = ov.rubber { + painter.add(Shape::dashed_line(&[app.to_screen(x0, y0), app.to_screen(x1, y1)], stroke(ACCENT, 1.0), 4.0, 3.0)); + } +} + +/// 45° hatch lines `gap` apart inside polygons (even-odd), in screen space. +fn hatch(polys: &[Vec], gap: f32) -> Vec<[Pos2; 2]> { + // Rotate so the hatch is horizontal, scan, rotate back. + let rot = |p: Pos2| pos2((p.x + p.y) * std::f32::consts::FRAC_1_SQRT_2, (p.y - p.x) * std::f32::consts::FRAC_1_SQRT_2); + let back = |x: f32, y: f32| pos2((x - y) * std::f32::consts::FRAC_1_SQRT_2, (x + y) * std::f32::consts::FRAC_1_SQRT_2); + let edges: Vec<(Pos2, Pos2)> = polys + .iter() + .flat_map(|poly| { + let pts: Vec = poly.iter().map(|p| rot(*p)).collect(); + let n = pts.len(); + (0..n).filter_map(move |k| Some((*pts.get(k)?, *pts.get((k + 1) % n)?))) + }) + .collect(); + let (y0, y1) = edges.iter().fold((f32::INFINITY, f32::NEG_INFINITY), |(lo, hi), (a, b)| (lo.min(a.y).min(b.y), hi.max(a.y).max(b.y))); + let mut out = Vec::new(); + if !(y0.is_finite() && y1.is_finite()) || (y1 - y0) / gap > 4000.0 { + return out; + } + let mut y = (y0 / gap).ceil() * gap; + while y < y1 { + let mut xs: Vec = edges + .iter() + .filter(|(a, b)| (a.y <= y && y < b.y) || (b.y <= y && y < a.y)) + .map(|(a, b)| a.x + (y - a.y) * (b.x - a.x) / (b.y - a.y)) + .collect(); + xs.sort_by(f32::total_cmp); + for pair in xs.chunks_exact(2) { + if let [a, b] = pair { + out.push([back(*a, y), back(*b, y)]); + } + } + y += gap; + } + out +} + fn rulers(app: &FigApp, painter: &egui::Painter, t: &Tokens, doc: &Document, sel: &[NodeId]) { let r = app.canvas.rect; let size = 20.0; diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs index 30c2f873..881d3e9e 100644 --- a/crates/ui-egui/src/control.rs +++ b/crates/ui-egui/src/control.rs @@ -136,6 +136,12 @@ pub fn handle(app: &mut FigApp, ctx: &Context, method: &str, p: &Value) -> Resul figcraft_engine::textedit::key(&mut app.session, key, b(p, "shift"), b(p, "alt"), b(p, "cmd")).map_err(|e| e.to_string())?; return Ok(json!({"ok": true})); } + // Vector edit mode keys (tools, nudging points, delete, join). + if app.session.ds().is_ok_and(|d| d.vector_edit.is_some()) + && figcraft_engine::vectoredit::key(&mut app.session, key, b(p, "shift"), b(p, "alt"), b(p, "cmd")).map_err(|e| e.to_string())? + { + return Ok(json!({"ok": true})); + } match crate::shortcuts::parse(&spec) { Some(want) => { let id = figcraft_engine::catalog::MENU diff --git a/crates/ui-egui/src/icons.rs b/crates/ui-egui/src/icons.rs index e7883742..4c23b478 100644 --- a/crates/ui-egui/src/icons.rs +++ b/crates/ui-egui/src/icons.rs @@ -38,6 +38,10 @@ pub enum Icon { ComponentSet, Group, Vector, + Bend, + PaintBucket, + Lasso, + Cut, Boolean, Page, Check, @@ -202,6 +206,43 @@ pub fn paint(painter: &Painter, rect: Rect, icon: Icon, color: Color32) { p.line(3.0, 13.0, 13.0, 3.0); p.rect(2.5, 2.5, 13.5, 13.5, 0.0); } + Bend => { + // A curve with a smooth point and its handle line. + let pts: Vec<(f32, f32)> = (0..=12) + .map(|i| { + let t = i as f32 / 12.0; + let u = 1.0 - t; + (u * u * 2.5 + 2.0 * u * t * 8.0 + t * t * 13.5, u * u * 13.0 + 2.0 * u * t * 1.5 + t * t * 13.0) + }) + .collect(); + p.poly(&pts, false); + p.line(3.5, 7.25, 12.5, 7.25); + p.dot(3.5, 7.25, 1.2); + p.dot(12.5, 7.25, 1.2); + p.fill_rect(6.9, 6.15, 9.1, 8.35, 0.4); + } + PaintBucket => { + p.poly(&[(2.5, 8.0), (7.5, 3.0), (12.5, 8.0), (7.5, 13.0)], true); + p.line(4.0, 6.5, 11.0, 6.5); + p.line(7.5, 3.0, 5.5, 1.0); + p.dot(13.5, 11.8, 1.4); + } + Lasso => { + let pts: Vec<(f32, f32)> = (0..=20) + .map(|i| { + let a = i as f32 / 20.0 * std::f32::consts::TAU; + (8.5 + 5.5 * a.cos(), 6.0 + 3.5 * a.sin()) + }) + .collect(); + p.poly(&pts, true); + p.poly(&[(5.0, 8.8), (4.6, 11.0), (5.6, 12.6), (4.2, 14.5)], false); + } + Cut => { + p.circle(4.5, 11.5, 2.2); + p.circle(11.5, 11.5, 2.2); + p.line(6.0, 9.8, 11.5, 2.5); + p.line(10.0, 9.8, 4.5, 2.5); + } Rectangle => p.rect(3.0, 3.0, 13.0, 13.0, 0.5), Line => p.line(3.0, 13.0, 13.0, 3.0), Arrow => { diff --git a/crates/ui-egui/src/layers.rs b/crates/ui-egui/src/layers.rs index 54e77f89..4d915e3a 100644 --- a/crates/ui-egui/src/layers.rs +++ b/crates/ui-egui/src/layers.rs @@ -245,7 +245,7 @@ fn collect(doc: &Document, id: NodeId, depth: usize, expanded: &std::collections // Layers panel lists top of the stack first. for c in n.children.iter().rev() { let Some(cn) = doc.node(*c) else { continue }; - let has_kids = !cn.children.is_empty() && !matches!(cn.kind, NodeKind::BooleanOp { .. }) || matches!(cn.kind, NodeKind::BooleanOp { .. }); + let has_kids = !cn.children.is_empty() || matches!(cn.kind, NodeKind::BooleanOp { .. }); out.push(Row { id: *c, depth, has_kids }); if expanded.contains(c) && depth < 64 { collect(doc, *c, depth + 1, expanded, out); diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 23ac6e46..c94e5ef7 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -27,6 +27,7 @@ pub mod tabs; pub mod theme; pub mod toolbar; pub mod typography; +pub mod vector_panel; pub mod widgets; use std::collections::BTreeSet; diff --git a/crates/ui-egui/src/right.rs b/crates/ui-egui/src/right.rs index 6f7e2277..7ba5fc11 100644 --- a/crates/ui-egui/src/right.rs +++ b/crates/ui-egui/src/right.rs @@ -178,13 +178,17 @@ fn design(app: &mut FigApp, ui: &mut Ui) { let Ok(ds) = app.session.ds() else { return }; let doc = ds.doc.clone(); let sel = ds.selection.clone(); + let vector_edit = ds.vector_edit.clone(); if sel.is_empty() { page_section(app, ui, &doc); return; } header(app, ui, &doc, &sel); widgets::separator(ui); - position(app, ui, &doc, &sel); + match vector_edit { + Some(ve) => crate::vector_panel::points(app, ui, &doc, &ve), + None => position(app, ui, &doc, &sel), + } widgets::separator(ui); layout(app, ui, &doc, &sel); widgets::separator(ui); diff --git a/crates/ui-egui/src/shortcuts.rs b/crates/ui-egui/src/shortcuts.rs index 541edc40..49585f80 100644 --- a/crates/ui-egui/src/shortcuts.rs +++ b/crates/ui-egui/src/shortcuts.rs @@ -86,6 +86,17 @@ pub fn handle(app: &mut FigApp, ctx: &Context) { } fn key_event(app: &mut FigApp, key: Key, m: Modifiers, repeat: bool) -> bool { + // Vector edit mode has its own keys (tools, nudging points, delete, join); the rest fall through. + if app.session.ds().is_ok_and(|d| d.vector_edit.is_some()) { + match figcraft_engine::vectoredit::key(&mut app.session, key.name(), m.shift, m.alt, m.command) { + Ok(true) => return true, + Ok(false) => {} + Err(e) => { + app.toast(e.to_string()); + return true; + } + } + } // Catalog shortcuts (exact modifier match). for item in MENU.iter().filter(|i| !i.shortcut.is_empty()) { if let Some((want, k)) = parse(item.shortcut) @@ -106,10 +117,6 @@ fn key_event(app: &mut FigApp, key: Key, m: Modifiers, repeat: bool) -> bool { app.ui.context_menu = None; return true; } - if item.id == "edit.delete" && app.session.ds().map(|d| d.vector_edit.is_some()).unwrap_or(false) { - app.run("vector.deleteHeal", json!({})); - return true; - } if item.id == "edit.delete" { // Delete key also removes the pen path / ends gestures. if app.session.tool.pen.is_some() { diff --git a/crates/ui-egui/src/toolbar.rs b/crates/ui-egui/src/toolbar.rs index fc96019d..2858a15e 100644 --- a/crates/ui-egui/src/toolbar.rs +++ b/crates/ui-egui/src/toolbar.rs @@ -2,6 +2,7 @@ use egui::{Align2, Color32, CornerRadius, Rect, Sense, Stroke, StrokeKind, Ui, pos2, vec2}; use figcraft_engine::ToolId; +use figcraft_engine::vectoredit::VTool; use serde_json::json; use crate::FigApp; @@ -39,6 +40,11 @@ fn remembered(ui: &Ui, key: &str, default: ToolId) -> ToolId { pub fn show(app: &mut FigApp, ui: &mut Ui) { let t = Tokens::get(ui.ctx()); let canvas = app.canvas.rect; + // Vector edit mode swaps the tools for the edit tools. + if let Some(tool) = app.session.ds().ok().and_then(|d| d.vector_edit.as_ref()).map(|v| v.tool) { + edit_toolbar(app, ui, tool); + return; + } let cell = 32.0; let gap = 4.0; let width = GROUPS.len() as f32 * (cell + 4.0) + 4.0 * 10.0 + 2.0 * (cell + 4.0) + 16.0 + 4.0 * 34.0 + 24.0; @@ -51,21 +57,6 @@ pub fn show(app: &mut FigApp, ui: &mut Ui) { } painter.rect_filled(rect, CornerRadius::same(13), t.panel); painter.rect_stroke(rect, CornerRadius::same(13), Stroke::new(1.0, t.border), StrokeKind::Inside); - // Vector edit mode: a contextual strip above the toolbar. - if app.session.ds().map(|d| d.vector_edit.is_some()).unwrap_or(false) { - let strip = Rect::from_center_size(pos2(rect.center().x, rect.min.y - 30.0), vec2(360.0, 40.0)); - ui.painter().rect_filled(strip, CornerRadius::same(10), t.panel); - ui.painter().rect_stroke(strip, CornerRadius::same(10), Stroke::new(1.0, t.border), StrokeKind::Inside); - let hints = "Drag points · ⌘-drag bends · ⌥-click adds a point · ⌫ deletes"; - ui.painter().text(pos2(strip.min.x + 12.0, strip.center().y), Align2::LEFT_CENTER, hints, regular(10.5), t.text_secondary); - let done = Rect::from_min_size(pos2(strip.max.x - 56.0, strip.center().y - 13.0), vec2(48.0, 26.0)); - let dresp = ui.interact(done, ui.id().with("vdone"), Sense::click()); - ui.painter().rect_filled(done, CornerRadius::same(6), if dresp.hovered() { t.accent_hover } else { ACCENT }); - ui.painter().text(done.center(), Align2::CENTER_CENTER, "Done", crate::theme::semibold(11.0), Color32::WHITE); - if dresp.clicked() { - app.run("vector.edit.end", json!({})); - } - } let current = app.session.tool.tool; let mut x = rect.min.x + 8.0; let cy = rect.center().y; @@ -181,6 +172,66 @@ pub fn show(app: &mut FigApp, ui: &mut Ui) { }); } +/// The pill shown in vector edit mode: the edit tools and Done. +fn edit_toolbar(app: &mut FigApp, ui: &mut Ui, current: VTool) { + let t = Tokens::get(ui.ctx()); + let canvas = app.canvas.rect; + let cell = 32.0; + let done_w = 56.0; + let width = VTool::ALL.len() as f32 * (cell + 4.0) + 8.0 + 12.0 + done_w + 8.0; + let rect = Rect::from_center_size(pos2(canvas.center().x, canvas.max.y - 12.0 - 24.0), vec2(width, 48.0)); + let painter = ui.painter(); + for (i, a) in [(6.0, 10u8), (3.0, 16), (1.0, 24)] { + painter.rect_filled(rect.expand(i).translate(vec2(0.0, i * 0.5)), CornerRadius::same((13.0 + i) as u8), Color32::from_black_alpha(a)); + } + painter.rect_filled(rect, CornerRadius::same(13), t.panel); + painter.rect_stroke(rect, CornerRadius::same(13), Stroke::new(1.0, t.border), StrokeKind::Inside); + let cy = rect.center().y; + let mut x = rect.min.x + 8.0; + // Holding Cmd with the Move tool bends: show it. + let held = current == VTool::Move && ui.input(|i| i.modifiers.command); + for tool in VTool::ALL { + let r = Rect::from_center_size(pos2(x + cell / 2.0, cy), vec2(cell, cell)); + let tip = if tool == VTool::Bend { + format!("{} hold {}", tool.label(), pretty_shortcut(tool.shortcut())) + } else { + format!("{} {}", tool.label(), pretty_shortcut(tool.shortcut())) + }; + let resp = ui.interact(r, ui.id().with(("vtool", tool.id())), Sense::click()).on_hover_text(tip); + let active = tool == current && !held || held && tool == VTool::Bend; + let bg = if active { + ACCENT + } else if resp.hovered() { + t.hover + } else { + Color32::TRANSPARENT + }; + ui.painter().rect_filled(r, CornerRadius::same(5), bg); + let icon = match tool { + VTool::Move => Icon::Move, + VTool::Pen => Icon::Pen, + VTool::Bend => Icon::Bend, + VTool::Paint => Icon::PaintBucket, + VTool::Lasso => Icon::Lasso, + VTool::Cut => Icon::Cut, + }; + icons::paint(ui.painter(), r.shrink(7.0), icon, if active { Color32::WHITE } else { t.icon }); + if resp.clicked() { + app.run("vector.edit.tool", json!({"tool": tool.id()})); + } + x += cell + 4.0; + } + ui.painter().line_segment([pos2(x + 2.0, cy - 14.0), pos2(x + 2.0, cy + 14.0)], Stroke::new(1.0, t.border)); + x += 12.0; + let done = Rect::from_min_size(pos2(x, cy - 14.0), vec2(done_w, 28.0)); + let dresp = ui.interact(done, ui.id().with("vdone"), Sense::click()).on_hover_text("Done editing Esc"); + ui.painter().rect_filled(done, CornerRadius::same(6), if dresp.hovered() { t.accent_hover } else { ACCENT }); + ui.painter().text(done.center(), Align2::CENTER_CENTER, "Done", crate::theme::semibold(11.5), Color32::WHITE); + if dresp.clicked() { + app.run("vector.edit.end", json!({})); + } +} + fn flyout(app: &mut FigApp, ui: &mut Ui, g: &Group, bottom_left: egui::Pos2) { let t = Tokens::get(ui.ctx()); let item_h = 32.0; diff --git a/crates/ui-egui/src/vector_panel.rs b/crates/ui-egui/src/vector_panel.rs new file mode 100644 index 00000000..e2355530 --- /dev/null +++ b/crates/ui-egui/src/vector_panel.rs @@ -0,0 +1,88 @@ +//! Design panel in vector edit mode: the selected points' position, corner radius and handle +//! mirroring (in place of the layer's position section). + +use egui::{Id, Ui}; +use figcraft_doc::{Document, HandleMirroring}; +use figcraft_engine::vectoredit::{self, VectorEdit}; +use serde_json::{Value, json}; + +use crate::FigApp; +use crate::icons::Icon; +use crate::right::{menu_item, row}; +use crate::widgets::{self, FieldEdit, Lead, PAD}; + +/// Run a point command from a field: typed values are one step, scrubs one step when released. +fn point_field(app: &mut FigApp, cmd: &str, edit: Option, params: impl Fn(f64) -> Value) { + match edit { + Some(FieldEdit::Set(v)) => { + app.run(cmd, params(v)); + } + Some(FieldEdit::Scrub(v, done)) => { + let _ = app.session.begin_interaction("Edit points"); + let _ = app.session.execute(cmd, ¶ms(v)); + if done { + let _ = app.session.commit_interaction(); + } + } + None => {} + } +} + +pub fn points(app: &mut FigApp, ui: &mut Ui, doc: &Document, ve: &VectorEdit) { + let Some(net) = vectoredit::network(doc, ve.id) else { return }; + let pts = vectoredit::selected_points(net, ve); + widgets::section_header(ui, if pts.len() > 1 { "Points" } else { "Point" }, &[], false); + if pts.is_empty() { + let t = crate::theme::Tokens::get(ui.ctx()); + ui.horizontal(|ui| { + ui.add_space(PAD); + widgets::label(ui, "Select points to edit their position, radius and mirroring", t.text_secondary); + }); + ui.add_space(8.0); + return; + } + let col = widgets::col_width(ui.available_width()); + let pos = vectoredit::selection_position(doc, ve); + let round = |v: f64| (v * 100.0).round() / 100.0; + widgets::sublabels(ui, "Position", None); + row(ui, 32.0, |ui| { + let e = widgets::number_field(ui, Id::new("vpt_x"), Lead::Text("X"), pos.map(|p| round(p.x)), "", col, 1.0); + point_field(app, "vector.edit.position", e, |v| json!({"x": v})); + let e = widgets::number_field(ui, Id::new("vpt_y"), Lead::Text("Y"), pos.map(|p| round(p.y)), "", col, 1.0); + point_field(app, "vector.edit.position", e, |v| json!({"y": v})); + }); + let common = |f: &dyn Fn(usize) -> Option| -> Option { + let mut it = pts.iter().map(|v| f(*v)); + let first = it.next().flatten()?; + it.all(|x| x == Some(first)).then_some(first) + }; + let radius = common(&|v| net.vertices.get(v).map(|x| x.radius)); + let mirror = { + let mut it = pts.iter().map(|v| net.mirroring(*v)); + let first = it.next(); + first.filter(|m| it.all(|x| x == *m)) + }; + widgets::sublabels(ui, "Corner radius", None); + row(ui, 32.0, |ui| { + let e = widgets::number_field(ui, Id::new("vpt_radius"), Lead::Icon(Icon::CornerRadius), radius.map(round), "", col, 1.0); + point_field(app, "vector.edit.cornerRadius", e, |v| json!({"radius": v.max(0.0)})); + }); + widgets::sublabels(ui, "Mirroring", None); + row(ui, 32.0, |ui| { + let label = |m: HandleMirroring| match m { + HandleMirroring::None => "No mirroring", + HandleMirroring::Angle => "Mirror angle", + HandleMirroring::AngleAndLength => "Mirror angle and length", + }; + let resp = widgets::dropdown(ui, mirror.map(label).unwrap_or("Mixed"), col * 2.0 + 8.0, None); + egui::Popup::menu(&resp).show(|ui| { + for m in [HandleMirroring::None, HandleMirroring::Angle, HandleMirroring::AngleAndLength] { + if menu_item(ui, label(m), "") { + app.run("vector.edit.mirroring", json!({"mode": m.id()})); + ui.close(); + } + } + }); + }); + ui.add_space(8.0); +} diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 583f3f6b..7221aea7 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -72,7 +72,7 @@ A mouse gesture with the current tool. `kind`: `down`, `move`, `up`, `click`, `d ### `ui.key {key, shift?, alt?, cmd?, ctrl?}` -A key as if typed on the canvas: a menu shortcut (`{"key":"G","cmd":true}` groups), a tool key, +A key as if typed on the canvas (in vector edit mode the edit keys come first: `V` `P` `Q` `X` `Shift+B` tools, arrows nudge points, `Delete`/`Shift+Delete`, `Cmd+A`, `Cmd+J`): a menu shortcut (`{"key":"G","cmd":true}` groups), a tool key, `Escape`, `Delete`/`Backspace`, `Enter`, arrows (nudge; shift = big nudge). While text is being edited, keys go to the text editor. Returns `{"command": id}` for shortcuts. diff --git a/docs/mcp.md b/docs/mcp.md index fb47005b..67ffa26a 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -91,6 +91,22 @@ Or in a project's `.mcp.json`: | `type_text {text, id?}` | Type into the text being edited, or replace the contents of text layer `id`. | | `inspect_ui {}` | Tool, view and status (and panels/timings when attached). | +### Editing vectors + +Vector edit mode is driven with `run_command` (or `pointer`/`key` for gestures): +`vector.edit.begin {id}` (converts shapes to vectors), `vector.edit.state` (page-space overlay, the +local network and each point's handle mirroring), `vector.edit.tool {tool: move|pen|bend|paint|lasso|cut}`, +`vector.edit.select {vertices?, segments?, add?}`, `vector.edit.selectAll`, `vector.edit.moveVertices`, +`vector.edit.nudge`, `vector.edit.position {x?, y?}`, `vector.edit.setHandle`, `vector.edit.mirroring +{mode: none|angle|angleAndLength}`, `vector.edit.smooth {smooth?}`, `vector.edit.bend`, +`vector.edit.addVertex`, `vector.edit.connect {a, b}`, `vector.edit.pen {x, y, dx?, dy?}` (continues +from the pen's open end; clicking a point connects or branches), `vector.edit.penEnd`, +`vector.edit.paint {x, y}` (paint bucket: fills or unfills the closed area under a page point), +`vector.edit.cut {segment, t} | {vertex}`, `vector.edit.lasso {points}`, `vector.edit.delete`, +`vector.deleteHeal`, `vector.join` / `vector.smoothJoin` (join the selected points while editing), +`vector.edit.cornerRadius`, `vector.edit.end`. Point indices refer to `network.vertices` in +`vector.edit.state`; local coordinates are the layer's own. + Tool failures come back as results with `isError: true` and a message; protocol problems (unknown tool, malformed JSON, wrong parameter types) are JSON-RPC errors. Nothing crashes the server. diff --git a/docs/parity.md b/docs/parity.md index fd8296b0..aba686ec 100644 --- a/docs/parity.md +++ b/docs/parity.md @@ -1,16 +1,14 @@ # Parity report -Generated by `cargo xtask parity`: FigCraft commands registered for the incumbent's main menu and toolbar (278 commands in the engine). +Generated by `cargo xtask parity`: FigCraft commands registered for the incumbent's main menu and toolbar (327 commands in the engine). -**191 / 199 menu items (96.0%)** +**193 / 199 menu items (97.0%)** ## Missing -- `file.exportFramesPdf` - `file.openRecent` - `view.outlinesSelection` - `view.maskOutlines` -- `vector.deleteHeal` - `plugins.runLast` - `plugins.manage` - `libraries.publish`