VectorCraft: An open-source, vector art tool written by scratch in pure Rust
refactor(tools): move builder.rs items to builder/{cache,live_paint,lookup,map}.rs
aiongge987e6dc584e
diff --git a/crates/tools/src/builder.rs b/crates/tools/src/builder.rsindex d5d665e75..2ed8ff6d6 100644--- a/crates/tools/src/builder.rs+++ b/crates/tools/src/builder.rs@@ -23,914 +23,26 @@ use vectorcraft_pathops as po;use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, ToolKey, json_ids};-/// Names starting with this mark a Live Paint group, together with its sources group ([`SOURCES_NAME`]).-pub const LIVE_PAINT_PREFIX: &str = "Live Paint";-/// Default name of a new Live Paint group.-pub const LIVE_PAINT_NAME: &str = "Live Paint Group";-/// The hidden child group holding the source paths.-pub const SOURCES_NAME: &str = "Live Paint Sources";-pub const FACE_NAME: &str = "Face";-pub const EDGE_NAME: &str = "Edge";--/// Shape Builder hover hatch colour (neutral grey) and Live Paint highlight red.-pub const HATCH: [u8; 3] = [0x80, 0x80, 0x80];-pub const HIGHLIGHT_RED: [u8; 3] = [0xff, 0x2a, 0x2a];--/// Is `n` a Live Paint group: an unclipped group whose name starts with [`LIVE_PAINT_PREFIX`] and-/// that holds a group named [`SOURCES_NAME`]? A plain group with such a name is not one.-pub fn is_live_paint(n: &Node) -> bool {- matches!(n.kind, NodeKind::Group { clip: false, .. })- && n.name.as_deref().is_some_and(|s| s.starts_with(LIVE_PAINT_PREFIX))- && sources(n).is_some_and(|s| matches!(s.kind, NodeKind::Group { .. }))-}--/// Whether Live Paint can take `n` as it is: a Live Paint group, a path or compound path, or a-/// group of those. Type, images, symbols, blends, meshes and the rest have to be converted to-/// paths first (<https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/create-live-paint-groups.html>);-/// Make and Merge refuse them rather than hide them among the group's sources.-pub fn live_paint_takes(n: &Node) -> bool {- is_live_paint(n)- || match &n.kind {- NodeKind::Path { .. } | NodeKind::Compound { .. } => true,- NodeKind::Group { children, .. } => children.iter().all(|c| live_paint_takes(c)),- _ => false,- }-}--fn named(n: &Node, name: &str) -> bool {- n.name.as_deref() == Some(name)-}--/// Face children of a Live Paint group (paint order).-pub fn faces(group: &Node) -> Vec<&Arc<Node>> {- group.children().map(|c| c.iter().filter(|n| named(n, FACE_NAME)).collect()).unwrap_or_default()-}--/// Edge children of a Live Paint group.-pub fn edges(group: &Node) -> Vec<&Arc<Node>> {- group.children().map(|c| c.iter().filter(|n| named(n, EDGE_NAME)).collect()).unwrap_or_default()-}--/// The hidden sources group of a Live Paint group.-pub fn sources(group: &Node) -> Option<&Arc<Node>> {- group.children()?.iter().find(|n| named(n, SOURCES_NAME))-}--/// Does the path (filled) contain `p`?-pub fn path_contains(path: &PathData, rule: FillRule, p: Point) -> bool {- if path.bounds().is_none_or(|b| !b.inflate(1e-6, 1e-6).contains(p)) {- return false;- }- let w = path.to_bezpath().winding(p);- match rule {- FillRule::EvenOdd => w % 2 != 0,- _ => w != 0,- }-}--/// The face of `group` under `p` (front-most).-pub fn face_at(group: &Node, p: Point) -> Option<&Arc<Node>> {- front_face(faces(group).into_iter(), p)-}--/// The face of `group` under `p` (front-most) among its faces that are not hidden.-pub fn visible_face_at(group: &Node, p: Point) -> Option<&Arc<Node>> {- front_face(faces(group).into_iter().filter(|f| f.visible), p)-}--/// The face of `faces` (paint order) under `p` (front-most).-fn front_face<'a>(faces: impl DoubleEndedIterator<Item = &'a Arc<Node>>, p: Point) -> Option<&'a Arc<Node>> {- faces.rev().find(|f| f.path_data().is_some_and(|pd| path_contains(pd, FillRule::NonZero, p)))-}--/// The edge of `group` nearest to `p` within `tol`.-pub fn edge_near(group: &Node, p: Point, tol: f64) -> Option<&Arc<Node>> {- nearest_edge(edges(group), p, tol)-}--/// The edge of `group` nearest to `p` within `tol` among its edges that are not hidden.-pub fn visible_edge_near(group: &Node, p: Point, tol: f64) -> Option<&Arc<Node>> {- nearest_edge(edges(group).into_iter().filter(|e| e.visible), p, tol)-}--/// The edge of `edges` nearest to `p` within `tol`.-fn nearest_edge<'a>(edges: impl IntoIterator<Item = &'a Arc<Node>>, p: Point, tol: f64) -> Option<&'a Arc<Node>> {- let mut best: Option<(f64, &Arc<Node>)> = None;- for e in edges {- if let Some((.., d)) = e.path_data().and_then(|pd| pd.nearest(p))- && d <= tol- && best.is_none_or(|b| d < b.0)- {- best = Some((d, e));- }- }- best.map(|b| b.1)-}--/// The visible Live Paint group with a face under `p` that is not hidden (front-most in paint order).-pub fn live_paint_at(doc: &Document, p: Point) -> Option<NodeId> {- let mut hit = None;- doc.walk(|n| {- if is_live_paint(n) && doc.is_visible(n.id) && visible_face_at(n, p).is_some() {- hit = Some(n.id);- }- });- hit-}--/// Paths, compound paths (as one shape) of a subtree in paint order; guides, clipping paths and-/// hidden objects are skipped. Live Paint groups contribute their faces and edges.-pub fn leaf_shapes<'a>(n: &'a Node, out: &mut Vec<&'a Node>) {- collect_leaves(n, false, out);-}--/// [`leaf_shapes`]; with `filled_faces`, a Live Paint group contributes only its filled faces and-/// its stroked edges.-fn collect_leaves<'a>(n: &'a Node, filled_faces: bool, out: &mut Vec<&'a Node>) {- if !n.visible {- return;- }- if n.extras().shaper.is_some() {- for c in n.children().into_iter().flatten().skip(1) {- collect_leaves(c, filled_faces, out);- }- return;- }- match &n.kind {- NodeKind::Path { guide: true, .. } | NodeKind::Path { clipping: true, .. } => {}- NodeKind::Path { .. } | NodeKind::Compound { .. } => out.push(n),- NodeKind::Group { .. } if filled_faces && is_live_paint(n) => {- out.extend(faces(n).into_iter().filter(|f| f.visible && !f.appearance.fill_paint().is_none()).map(|f| &**f));- out.extend(edges(n).into_iter().filter(|e| e.visible && !e.appearance.stroke_paint().is_none()).map(|e| &**e));- }- NodeKind::Group { children, .. } | NodeKind::Layer { children, .. } => {- for c in children {- collect_leaves(c, filled_faces, out);- }- }- _ => {}- }-}--/// Filled outline of a path or compound path node.-pub fn node_outline(n: &Node) -> Option<(PathData, FillRule)> {- match &n.kind {- NodeKind::Path { path, rule, .. } => Some((path.clone(), *rule)),- NodeKind::Compound { children, rule } => {- let subs = children.iter().filter_map(|c| c.path_data()).flat_map(|p| p.subpaths.iter().cloned()).collect();- Some((PathData::new(subs), *rule))- }- _ => None,- }-}--/// How far (pt) a piece of the planar map may lie from `outline`, the outline it follows, to be-/// matched to it or cut out of it: a ten-thousandth of the outline's larger side, at least 0.05.-/// The map's pieces follow the outlines to within a few hundredths of a point.-pub fn outline_snap(outline: &PathData) -> f64 {- outline.bounds().map_or(0.05, |b| (b.width().max(b.height()) / 2000.0).max(0.25) * 0.2)-}--/// The outlines of `leaves` as they are drawn ([`node_outline`]), in their order, for-/// [`BuilderMap::stroke_at`]. A leaf without an outline, and one inside a Live Paint group or a-/// Shaper Group (which make their own paths), gets an empty outline, so no stroke of it splits.-pub fn drawn_outlines(doc: &Document, leaves: &[&Node]) -> Vec<PathData> {- let in_live_group = |id: NodeId| {- let mut up = doc.parent_of(id);- while let Some(p) = up {- if doc.node(p).is_some_and(|n| is_live_paint(n) || n.extras().shaper.is_some()) {- return true;- }- up = doc.parent_of(p);- }- false- };- leaves.iter().map(|l| if in_live_group(l.id) { None } else { node_outline(l) }.map_or_else(PathData::default, |o| o.0)).collect()-}--/// Pathfinder shapes for the given roots (back → front by the order given), keyed by leaf index,-/// with the leaves they came from.-pub fn shapes_for<'a>(doc: &'a Document, roots: &[NodeId]) -> (Vec<po::Shape>, Vec<&'a Node>) {- shapes_of(doc, roots, false)-}--/// [`shapes_for`]; with `filled_faces`, a Live Paint group contributes only its filled faces and-/// its stroked edges.-fn shapes_of<'a>(doc: &'a Document, roots: &[NodeId], filled_faces: bool) -> (Vec<po::Shape>, Vec<&'a Node>) {- let mut lv = vec![];- for id in roots {- if let Some(n) = doc.node(*id) {- collect_leaves(n, filled_faces, &mut lv);- }- }- let mut shapes = vec![];- let mut used = vec![];- for l in lv {- if let Some((p, r)) = node_outline(l)- && !p.is_empty()- && p.subpaths.iter().all(|s| s.anchors.iter().all(|a| a.p.x.is_finite() && a.p.y.is_finite()))- {- shapes.push(po::Shape::new(p, r, used.len() as u64));- used.push(l);- }- }- (shapes, used)-}--/// Shape Builder inputs: [`shapes_for`], with the open subpaths of filled paths closed where that-/// encloses an area (the fill bounds a region, as if an invisible edge closed it) when-/// `open_filled_as_closed`. Unfilled open paths and straight lines stay open and cut the regions-/// they cross, and so do filled open paths without `open_filled_as_closed`. A Live Paint group-/// contributes its filled faces as shapes and its stroked edges as open lines; its unfilled faces-/// and its edges without a stroke are left out.-pub fn shape_builder_shapes<'a>(doc: &'a Document, roots: &[NodeId], open_filled_as_closed: bool) -> (Vec<po::Shape>, Vec<&'a Node>) {- let (mut shapes, leaves) = shapes_of(doc, roots, true);- for (s, l) in shapes.iter_mut().zip(&leaves) {- if named(l, EDGE_NAME) && doc.parent_of(l.id).and_then(|p| doc.node(p)).is_some_and(is_live_paint) {- // A closed edge opens at its first anchor and keeps its closing segment.- let start = BTreeSet::from([0]);- s.path.subpaths = s.path.subpaths.iter().flat_map(|sp| sp.cut_at(&start)).collect();- continue;- }- if !open_filled_as_closed || l.appearance.fill_paint().is_none() {- continue;- }- for sp in s.path.subpaths.iter_mut().filter(|sp| !sp.closed) {- sp.closed = po::encloses_area(sp);- }- }- (shapes, leaves)-}--/// A planar-map face with its outline and bounds, ready for hit tests.-pub type Face = (po::Region, BezPath, Rect);--fn faces_of(regions: Vec<po::Region>) -> Vec<Face> {- regions- .into_iter()- .filter_map(|r| {- let bp = r.path.to_bezpath();- let b = r.path.bounds()?;- Some((r, bp, b))- })- .collect()-}--thread_local! {- /// The Shape Builder maps built on this thread ([`maps_built`]).- static MAPS_BUILT: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };-}--/// How many Shape Builder maps ([`BuilderMap::of_shapes`]) this thread has built, for tests that-/// count them.-pub fn maps_built() -> usize {- MAPS_BUILT.with(std::cell::Cell::get)-}--/// The Shape Builder's planar map of a selection.-#[derive(Default)]-pub struct BuilderMap {- /// The inputs, back → front (see [`po::shape_builder`]).- pub shapes: Vec<po::Shape>,- pub regions: Vec<Face>,- /// Pieces of the open paths that cut regions (see [`BuilderMap::new`]), keyed by input index,- /// with their bounds.- pub lines: Vec<(po::Shape, Rect)>,- /// Pieces of the other inputs' outlines (cut wherever paths meet), keyed by input index, with- /// their bounds: the edges erasing deletes. Only in a map made `with_edges`.- pub edges: Vec<(po::Shape, Rect)>,-}--/// What a Shape Builder gesture touches at a point.-#[derive(Clone, Copy, Debug, PartialEq, Eq)]-pub enum Hit {- Region(usize),- Line(usize),- Edge(usize),-}--/// The piece of `pieces` nearest `p` within `tol`, with its distance.-fn piece_near(pieces: &[(po::Shape, Rect)], p: Point, tol: f64) -> Option<(f64, usize)> {- let mut best: Option<(f64, usize)> = None;- for (i, (l, b)) in pieces.iter().enumerate() {- if b.inflate(tol, tol).contains(p)- && let Some((.., d)) = l.path.nearest(p)- && d <= tol- && best.is_none_or(|b| d < b.0)- {- best = Some((d, i));- }- }- best-}--impl BuilderMap {- /// The map of `roots` (sorted back → front), with the leaves the inputs came from; the outline- /// edges only `with_edges`. With `open_filled_as_closed` (Consider Open Filled Paths as- /// Closed), a filled open path bounds a region as if an invisible edge closed it; without it,- /// the path cuts like a line.- pub fn new<'a>(doc: &'a Document, roots: &[NodeId], with_edges: bool, open_filled_as_closed: bool) -> (Self, Vec<&'a Node>) {- Self::with_gap(doc, roots, with_edges, open_filled_as_closed, 0.0)- }-- /// The same arrangement with Gap Detection, using the shared Live Paint gap finder.- pub fn with_gap<'a>(doc: &'a Document, roots: &[NodeId], with_edges: bool, open_filled_as_closed: bool, gap: f64) -> (Self, Vec<&'a Node>) {- let (shapes, leaves) = shape_builder_shapes(doc, roots, open_filled_as_closed);- (Self::of_shapes(shapes, with_edges, gap), leaves)- }-- /// The map of `shapes` (the inputs, back → front, as [`shape_builder_shapes`] gives them), with- /// the outline edges only `with_edges`, closing gaps up to `gap`.- pub fn of_shapes(shapes: Vec<po::Shape>, with_edges: bool, gap: f64) -> Self {- if shapes.is_empty() {- return Self::default();- }- MAPS_BUILT.with(|n| n.set(n.get() + 1));- let arr = po::shape_builder_with_gap(&shapes, with_edges, gap);- let bounded = |pieces: Vec<po::Shape>| {- pieces- .into_iter()- .filter_map(|l| {- let b = l.path.bounds()?;- Some((l, b))- })- .collect()- };- Self { shapes, regions: faces_of(arr.regions), lines: bounded(arr.lines), edges: bounded(arr.edges) }- }-- /// The region containing `p`.- pub fn region_at(&self, p: Point) -> Option<usize> {- self.regions.iter().position(|(_, bp, b)| b.contains(p) && bp.winding(p) != 0)- }-- /// The regions a rectangular marquee from `from` (where the drag started) to `to` touches: each- /// region whose outline crosses the rectangle or has an anchor inside it, and the region the- /// whole rectangle lies in. Of those, the region under `from` comes first, then the one under- /// `to`, then the others in map order. A marquee of no size touches the region under `from`.- pub fn regions_in_marquee(&self, from: Point, to: Point) -> Vec<usize> {- let r = Rect::from_points(from, to);- if r.width() <= 0.0 && r.height() <= 0.0 {- return self.region_at(from).into_iter().collect();- }- let c = r.center();- let touches = |(reg, bp, b): &Face| (b.contains(c) && bp.winding(c) != 0) || vectorcraft_geom::hit::intersects_rect(®.path, r);- let mut out: Vec<usize> = self.regions.iter().enumerate().filter(|(_, f)| touches(f)).map(|(i, _)| i).collect();- for p in [to, from] {- if let Some(k) = self.region_at(p).and_then(|i| out.iter().position(|&j| j == i)) {- let i = out.remove(k);- out.insert(0, i);- }- }- out- }-- /// What a gesture at `p` touches: with `piece_tol` (erasing), the line piece or edge that- /// close, else the region under it.- pub fn hit(&self, p: Point, piece_tol: Option<f64>) -> Option<Hit> {- self.piece_hit(p, piece_tol).or_else(|| self.region_at(p).map(Hit::Region))- }-- /// The line piece or edge within `piece_tol` of `p` that [`Self::hit`] gives (None without- /// `piece_tol`).- fn piece_hit(&self, p: Point, piece_tol: Option<f64>) -> Option<Hit> {- piece_tol.and_then(|t| match (piece_near(&self.lines, p, t), piece_near(&self.edges, p, t)) {- (Some(l), Some(e)) if e.0 < l.0 => Some(Hit::Edge(e.1)),- (Some(l), _) => Some(Hit::Line(l.1)),- (None, e) => e.map(|e| Hit::Edge(e.1)),- })- }-- /// The stroke a click at `p` splits with In Merge Mode, Clicking Stroke Splits the Path: the- /// line piece or edge nearest `p` within `tol` (as [`BuilderMap::hit`] finds it), from the- /// anchor or crossing point before `p` to the one after it on the path it lies on. `outlines`- /// are the inputs' outlines as they are drawn (a filled open path without the edge that closes- /// it in the map). Returns the input's index and the run, going the way the path goes; None- /// when no piece is that close, when the run is not on the outline as drawn, when it would be a- /// whole closed subpath, when it is too short to cut out (see [`po::cut_out`]), or when it is- /// all of the path (a lone line) or leaves no more of it than [`outline_snap`], which leaves- /// nothing to split off.- pub fn stroke_at(&self, outlines: &[PathData], p: Point, tol: f64) -> Option<(usize, SubPath)> {- use kurbo::ParamCurve as _;- let piece = match self.hit(p, Some(tol))? {- Hit::Line(i) => self.lines.get(i),- Hit::Edge(i) => self.edges.get(i),- Hit::Region(_) => None,- }?;- let i = piece.0.key as usize;- let drawn = outlines.get(i)?;- let stops: Vec<Point> = drawn.anchors().map(|(.., a)| a.p).collect();- let snap = outline_snap(drawn);- let mut run = po::run_around(piece.0.path.subpaths.first()?, &stops, p, snap)?;- let n = run.segment_count();- if n == 0 {- return None;- }- let mid = run.segment(n / 2).eval(0.5);- drawn.nearest(mid).filter(|n| n.4 <= snap)?;- // A run that cannot be cut out, or that is all of the path (such as a lone line) or all- // but a speck of it, leaves nothing to split off.- if !po::cut_out(drawn, &run, false, snap).is_some_and(|rest| rest.length() > snap) {- return None;- }- // Reverse the run when the path's parameter goes down along it.- let seg = run.segment(n / 2);- if let (Some(a), Some(b)) = (drawn.nearest(seg.eval(0.25)), drawn.nearest(seg.eval(0.75)))- && a.0 == b.0- && (b.1 as f64 + b.2) < (a.1 as f64 + a.2)- {- run.reverse();- }- Some((i, run))- }-- /// What a Shape Builder gesture at `p` touches: [`Self::hit`], except that while erasing, a- /// point in a region that is no more than `2 * piece_tol` across there (see- /// [`Self::narrow_at`]) touches the region and not the line piece or edge beside it.- pub fn builder_hit(&self, p: Point, piece_tol: Option<f64>) -> Option<Hit> {- match (piece_tol, self.piece_hit(p, piece_tol)) {- (Some(tol), Some(piece)) => Some(match self.region_at(p) {- Some(r) if self.narrow_at(r, p, tol) => Hit::Region(r),- _ => piece,- }),- (_, piece) => piece.or_else(|| self.region_at(p).map(Hit::Region)),- }- }-- /// Is region `r` no more than `2 * tol` across at `p`, measured from a point of its outline- /// within `tol` of `p`, through `p`, to its outline on the other side? Every point on that line- /// is then within `tol` of the outline. The points tried are the point of the outline nearest- /// `p` and each point of a segment where the segment is square to the line to `p`, so a- /// point near the end of a thin bar measures across the bar from its sides as well as along it- /// from the end, and splitting a segment in two does not change the answer. False when `p` is- /// on the outline or more than `tol` from it.- fn narrow_at(&self, r: usize, p: Point, tol: f64) -> bool {- use kurbo::{ParamCurve as _, ParamCurveNearest as _};- let Some((_, bp, _)) = self.regions.get(r) else { return false };- // Each segment with the parameter, point and distance of its point nearest `p`.- let near: Vec<(kurbo::PathSeg, f64, Point, f64)> = bp- .segments()- .map(|seg| {- let n = seg.nearest(p, 1e-6);- (seg, n.t, seg.eval(n.t), n.distance_sq.sqrt())- })- .collect();- if !near.iter().all(|&(.., d)| d.is_finite() && d > 1e-9) {- return false;- }- let closest = near.iter().map(|&(.., d)| d).fold(f64::INFINITY, f64::min);- // A line from `p` no longer than `2 * tol` only meets segments that close to `p`.- let reach: Vec<kurbo::PathSeg> = near.iter().filter(|&&(.., d)| d <= 2.0 * tol).map(|&(seg, ..)| seg).collect();- // A segment's end is its nearest point when the segment turns away from `p` or stops- // short of the point square to it; there, only the nearest point of all the outline and- // an end where the segment is square to the line to `p` count.- let square = |seg: kurbo::PathSeg, t: f64, n: Point| {- use kurbo::ParamCurveDeriv as _;- let dir = match seg {- kurbo::PathSeg::Line(l) => l.p1 - l.p0,- kurbo::PathSeg::Quad(q) => q.deriv().eval(t).to_vec2(),- kurbo::PathSeg::Cubic(c) => c.deriv().eval(t).to_vec2(),- };- let v = p - n;- dir.hypot() > 1e-12 && dir.dot(v).abs() <= 1e-6 * dir.hypot() * v.hypot()- };- let from =- |&&(seg, t, n, d): &&(kurbo::PathSeg, f64, Point, f64)| d <= tol && (d == closest || (t > 1e-9 && t < 1.0 - 1e-9) || square(seg, t, n));- near.iter().filter(from).any(|&(_, _, n, d)| {- let line = kurbo::Line::new(p, p + (p - n) * ((2.0 * tol - d) / d));- reach.iter().any(|seg| seg.intersect_line(line).iter().any(|x| x.line_t > 1e-9 && x.line_t <= 1.0))- })- }-- /// What a gesture along the polyline `pts` touches, in order: [`Self::hit`] at each vertex and- /// at the points [`Self::probes`] picks between them, so it touches every region it crosses,- /// however narrow.- pub fn hits_along(&self, pts: &[Point], piece_tol: Option<f64>) -> Touched {- self.along(pts, piece_tol, Self::hit)- }-- /// What a Shape Builder gesture along the polyline `pts` touches: [`Self::hits_along`] with- /// [`Self::builder_hit`], so an erasing gesture also touches each region it goes into where the- /// region is no more than `2 * piece_tol` across.- pub fn builder_hits_along(&self, pts: &[Point], piece_tol: Option<f64>) -> Touched {- self.along(pts, piece_tol, Self::builder_hit)- }-- fn along(&self, pts: &[Point], piece_tol: Option<f64>, hit: fn(&Self, Point, Option<f64>) -> Option<Hit>) -> Touched {- let mut touched = Touched::default();- let mut last: Option<Point> = None;- for &p in pts {- if let Some(a) = last {- for q in self.probes(a, p, piece_tol) {- touched.add(hit(self, q, piece_tol));- }- }- touched.add(hit(self, p, piece_tol));- last = Some(p);- }- touched- }-- /// The points strictly between `a` and `b`, in order, that [`Self::hits_along`] tests: the- /// middle of each stretch between two places where the segment crosses a region's outline, and- /// with `piece_tol` (erasing) those crossings, the places where it crosses a line piece or an- /// edge, and points `piece_tol / 2` apart (at most 4,000 per segment), so the line pieces and- /// edges the segment crosses or passes close to are touched too.- fn probes(&self, a: Point, b: Point, piece_tol: Option<f64>) -> Vec<Point> {- let len = a.distance(b);- if !(len.is_finite() && len > 0.0) {- return vec![];- }- let line = kurbo::Line::new(a, b);- let lb = Rect::from_points(a, b);- let mut cross: Vec<f64> = vec![];- for (_, bp, rb) in &self.regions {- if rb.x0 > lb.x1 || rb.x1 < lb.x0 || rb.y0 > lb.y1 || rb.y1 < lb.y0 {- continue;- }- for seg in bp.segments() {- cross.extend(seg.intersect_line(line).iter().map(|x| x.line_t));- }- }- cross.retain(|t| t.is_finite() && *t > 0.0 && *t < 1.0);- cross.sort_by(f64::total_cmp);- // Crossings closer than this along the segment are one place.- let gap = 1e-9 / len;- let mut ts: Vec<f64> = vec![];- let mut from = 0.0;- for &t in cross.iter().chain([1.0].iter()) {- if t - from > gap {- ts.push((from + t) / 2.0);- from = t;- }- }- if let Some(tol) = piece_tol {- ts.extend(cross.iter().copied());- for (piece, pb) in self.lines.iter().chain(&self.edges) {- if pb.x0 > lb.x1 || pb.x1 < lb.x0 || pb.y0 > lb.y1 || pb.y1 < lb.y0 {- continue;- }- for seg in piece.path.to_bezpath().segments() {- ts.extend(seg.intersect_line(line).iter().map(|x| x.line_t).filter(|t| t.is_finite() && *t > 0.0 && *t < 1.0));- }- }- let n = ((len / (tol / 2.0).max(1e-3)).ceil() as usize).min(4000);- ts.extend((1..n).map(|k| k as f64 / n as f64));- ts.sort_by(f64::total_cmp);- }- ts.into_iter().map(|t| a.lerp(b, t)).collect()- }-- /// The regions just either side of the middle of `piece` (None: outside every region).- pub fn sides(&self, piece: &po::Shape) -> [Option<usize>; 2] {- let Some(sp) = piece.path.subpaths.first() else { return [None; 2] };- let n = sp.segment_count();- if n == 0 {- return [None; 2];- }- let c = sp.segment(n / 2);- use kurbo::{ParamCurve as _, ParamCurveDeriv as _};- let (m, d) = (c.eval(0.5), c.deriv().eval(0.5).to_vec2());- let len = d.hypot();- if !(len.is_finite() && len > 0.0) {- return [None; 2];- }- // A little to each side: inside the faces next to it, which share it exactly.- let off = d.turn_90() * (0.05f64.min(0.05 * c.p0.distance(c.p3)).max(1e-6) / len);- [m + off, m - off].map(|q| self.region_at(q))- }-- /// Does line piece `i` run between two different regions of `regions` (an edge that merging or- /// deleting them removes)? A piece with the same region on both sides, such as the end of a- /// line inside a shape, bounds nothing and stays.- pub fn line_between(&self, i: usize, regions: &[usize]) -> bool {- self.lines.get(i).is_some_and(|(l, _)| matches!(self.sides(l), [Some(a), Some(b)] if a != b && regions.contains(&a) && regions.contains(&b)))- }-- /// The edges `touched` deletes: those that bound none of its regions (deleting a region takes- /// its edges with it, so an erase drag that crosses an edge into a region deletes the region).- pub fn erased_edges(&self, touched: &Touched) -> Vec<usize> {- let bounds_one = |(e, _): &(po::Shape, Rect)| self.sides(e).iter().any(|r| r.is_some_and(|r| touched.regions.contains(&r)));- touched.edges.iter().copied().filter(|&k| self.edges.get(k).is_some_and(|e| !bounds_one(e))).collect()- }-}--/// The regions, line pieces and edges a Shape Builder gesture has touched, in the order touched.-#[derive(Clone, Debug, Default, PartialEq)]-pub struct Touched {- pub regions: Vec<usize>,- pub lines: Vec<usize>,- pub edges: Vec<usize>,-}--impl Touched {- pub fn add(&mut self, hit: Option<Hit>) {- let (list, i) = match hit {- Some(Hit::Region(i)) => (&mut self.regions, i),- Some(Hit::Line(i)) => (&mut self.lines, i),- Some(Hit::Edge(i)) => (&mut self.edges, i),- None => return,- };- if !list.contains(&i) {- list.push(i);- }- }-- /// Adds what `other` touched, in its order.- pub fn extend(&mut self, other: &Touched) {- let regions = other.regions.iter().map(|&i| Hit::Region(i));- for hit in regions.chain(other.lines.iter().map(|&i| Hit::Line(i))).chain(other.edges.iter().map(|&i| Hit::Edge(i))) {- self.add(Some(hit));- }- }-- pub fn is_empty(&self) -> bool {- self.regions.is_empty() && self.lines.is_empty() && self.edges.is_empty()- }-}--/// Selected roots sorted back → front in document order.-pub fn sorted_roots(doc: &Document, ids: &[NodeId]) -> Vec<NodeId> {- let mut v: Vec<(Vec<usize>, NodeId)> = ids.iter().filter_map(|id| doc.index_path(*id).map(|p| (p, *id))).collect();- v.sort();- v.dedup_by(|a, b| a.1 == b.1);- v.into_iter().map(|(_, id)| id).collect()-}--/// Sample points along a polyline every `step` units (always including the vertices).-pub fn sample_polyline(pts: &[Point], step: f64) -> Vec<Point> {- let mut out = vec![];- let step = step.max(1e-3);- for (i, &p) in pts.iter().enumerate() {- if i > 0 {- let a = pts[i - 1];- let n = ((a.distance(p) / step).ceil() as usize).min(4000);- for k in 1..n {- out.push(a.lerp(p, k as f64 / n as f64));- }- }- out.push(p);- }- out-}--/// Diagonal hatch lines filling `path` (the Shape Builder's grey mesh highlight), `gap` apart.-pub fn hatch(path: &BezPath, gap: f64) -> BezPath {- let mut out = BezPath::new();- let b = path.bounding_box();- if b.width() <= 0.0 || b.height() <= 0.0 {- return out;- }- // Rotate by -45° so the hatch lines become horizontal scanlines.- let s = std::f64::consts::FRAC_1_SQRT_2;- let rot = |p: Point| Point::new((p.x + p.y) * s, (p.y - p.x) * s);- let unrot = |p: Point| Point::new((p.x - p.y) * s, (p.x + p.y) * s);- let mut edges: Vec<(Point, Point)> = vec![];- let mut first = Point::ZERO;- let mut last = Point::ZERO;- kurbo::flatten(path.iter(), gap.max(1e-3) * 0.1, |el| match el {- kurbo::PathEl::MoveTo(p) => {- if last != first {- edges.push((rot(last), rot(first)));- }- first = p;- last = p;- }- kurbo::PathEl::LineTo(p) => {- edges.push((rot(last), rot(p)));- last = p;- }- kurbo::PathEl::ClosePath => {- if last != first {- edges.push((rot(last), rot(first)));- }- last = first;- }- _ => {}- });- if last != first {- edges.push((rot(last), rot(first)));- }- let (mut y0, mut y1) = (f64::INFINITY, f64::NEG_INFINITY);- for (a, c) in &edges {- y0 = y0.min(a.y.min(c.y));- y1 = y1.max(a.y.max(c.y));- }- let gap = gap.max((y1 - y0) / 400.0).max(1e-6);- let mut y = (y0 / gap).floor() * gap + gap * 0.5;- let mut xs: Vec<f64> = vec![];- while y < y1 {- xs.clear();- for (a, c) in &edges {- if (a.y <= y) != (c.y <= y) {- xs.push(a.x + (y - a.y) / (c.y - a.y) * (c.x - a.x));- }- }- xs.sort_by(f64::total_cmp);- for pair in xs.as_chunks::<2>().0 {- out.move_to(unrot(Point::new(pair[0], y)));- out.line_to(unrot(Point::new(pair[1], y)));- }- y += gap;- }- out-}--/// What a [`RegionCache`] map was built for: the document's address and revision, the selected ids-/// and whether filled open paths count as closed.-type CacheKey = (usize, (u64, u64), Vec<NodeId>, bool);--/// Hovering builds the map of inputs with more segments than this on another thread-/// ([`RegionCache::ready`]); smaller maps are built on the calling thread.-const BACKGROUND_SEGMENTS: usize = 128;--/// A map being built on another thread: the key it is for, the drawn outlines of its inputs, and-/// the channel it arrives on.-struct Pending {- key: CacheKey,- outlines: Vec<PathData>,- done: Receiver<BuilderMap>,-}--/// The planar map of the current selection, cached by document identity, revision, selection and-/// whether filled open paths count as closed.-#[derive(Default)]-struct RegionCache {- key: Option<CacheKey>,- /// The map, which the Shape Builder's merge command takes too ([`Tool::shape_builder_map`]).- map: Arc<BuilderMap>,- /// Live Paint faces (every path an edge, filled or not) rather than Shape Builder regions.- live: bool,- /// Gap Detection distance; changing tool options invalidates the cache.- gap: f64,- /// The outlines of the Shape Builder's inputs as they are drawn (see [`BuilderMap::stroke_at`]).- outlines: Vec<PathData>,- /// The map being built on another thread, if any.- pending: Option<Pending>,- /// The key of the last map whose build on another thread failed.- failed: Option<CacheKey>,- /// How many times the map has been built.- #[cfg(test)]- builds: usize,- /// How many of those builds ran on another thread.- #[cfg(test)]- background: usize,-}--/// The map of `shapes`: Live Paint faces with `live`, else the Shape Builder map with its edges,-/// closing gaps up to `gap`.-fn build_map(shapes: Vec<po::Shape>, live: bool, gap: f64) -> BuilderMap {- if live {- let regions = if shapes.is_empty() { vec![] } else { faces_of(po::live_paint(&shapes).0) };- BuilderMap { regions, ..Default::default() }- } else {- BuilderMap::of_shapes(shapes, true, gap)- }-}--/// Builds the map of `shapes` ([`build_map`]) on a new thread; None when no thread starts.-#[cfg(not(target_arch = "wasm32"))]-fn spawn_build(shapes: Vec<po::Shape>, live: bool, gap: f64) -> Option<Receiver<BuilderMap>> {- let (tx, done) = std::sync::mpsc::channel();- let spawned = std::thread::Builder::new().name("vectorcraft-region-map".into()).spawn(move || {- // The tool may have dropped the receiver meanwhile (another tool, another selection).- let _ = tx.send(build_map(shapes, live, gap));- });- spawned.is_ok().then_some(done)-}--/// The web build has no threads.-#[cfg(target_arch = "wasm32")]-fn spawn_build(_shapes: Vec<po::Shape>, _live: bool, _gap: f64) -> Option<Receiver<BuilderMap>> {- None-}--impl RegionCache {- fn live_paint() -> Self {- Self { live: true, ..Default::default() }- }-- fn key_for(cx: &ToolContext, open_filled_as_closed: bool) -> CacheKey {- (cx.doc as *const Document as usize, cx.revision, cx.selection.objects.clone(), open_filled_as_closed)- }-- /// The inputs of the selection's map, back → front, and their drawn outlines (Shape Builder- /// only).- fn inputs(&self, cx: &ToolContext, open_filled_as_closed: bool) -> (Vec<po::Shape>, Vec<PathData>) {- let roots = sorted_roots(cx.doc, &cx.selection.objects);- if self.live {- (shapes_for(cx.doc, &roots).0, vec![])- } else {- let (shapes, leaves) = shape_builder_shapes(cx.doc, &roots, open_filled_as_closed);- let outlines = drawn_outlines(cx.doc, &leaves);- (shapes, outlines)- }- }-- fn install(&mut self, key: CacheKey, map: BuilderMap, outlines: Vec<PathData>) {- self.map = Arc::new(map);- self.outlines = outlines;- self.key = Some(key);- #[cfg(test)]- {- self.builds += 1;- }- }-- /// Forgets the map and any map being built (the tool options changed).- fn clear(&mut self) {- self.key = None;- self.pending = None;- self.failed = None;- }-- /// Is a map being built on another thread?- fn waiting(&self) -> bool {- self.pending.is_some()- }-- /// The map, built again only when the key changes, with filled open paths closed when- /// `open_filled_as_closed` (Shape Builder only). A Shape Builder map has the outline edges too,- /// so hovering and erasing use the same map. Waits for a map being built on another thread for- /// the same key.- fn get(&mut self, cx: &ToolContext, open_filled_as_closed: bool) -> &BuilderMap {- let key = Self::key_for(cx, open_filled_as_closed);- if self.key.as_ref() != Some(&key) {- let built = self.pending.take().filter(|p| p.key == key).and_then(|p| Some((p.done.recv().ok()?, p.outlines)));- let (map, outlines) = match built {- Some(b) => {- #[cfg(test)]- {- self.background += 1;- }- b- }- None => {- let (shapes, outlines) = self.inputs(cx, open_filled_as_closed);- (build_map(shapes, self.live, self.gap), outlines)- }- };- self.install(key, map, outlines);- }- &self.map- }-- /// Takes the map being built on another thread once it has arrived, or with `wait` once it- /// arrives, as the map for the key it was built for.- fn settle(&mut self, wait: bool) {- let Some(p) = self.pending.take() else { return };- let got = if wait { p.done.recv().map_err(|_| TryRecvError::Disconnected) } else { p.done.try_recv() };- match got {- Ok(map) => {- #[cfg(test)]- {- self.background += 1;- }- self.install(p.key, map, p.outlines);- }- // The build failed (a bug in the planar map): hovering does not build it again, and a- // gesture builds it on the calling thread, which reports the failure.- Err(TryRecvError::Disconnected) => self.failed = Some(p.key),- Err(TryRecvError::Empty) => self.pending = Some(p),- }- }-- /// The map as [`Self::get`] gives it, without waiting: when the key changes and the inputs have- /// more than [`BACKGROUND_SEGMENTS`] segments, the map is built on another thread, and this is- /// None until it arrives ([`Self::waiting`] holds meanwhile). A map being built for an earlier- /// key is let finish before the next one starts.- fn ready(&mut self, cx: &ToolContext, open_filled_as_closed: bool) -> Option<&BuilderMap> {- self.settle(false);- let key = Self::key_for(cx, open_filled_as_closed);- if self.key.as_ref() == Some(&key) {- return Some(&self.map);- }- if self.pending.is_some() || self.failed.as_ref() == Some(&key) {- return None;- }- let (shapes, outlines) = self.inputs(cx, open_filled_as_closed);- let segments: usize = shapes.iter().map(|s| s.path.subpaths.iter().map(|sp| sp.segment_count()).sum::<usize>()).sum();- if segments > BACKGROUND_SEGMENTS && cfg!(not(target_arch = "wasm32")) {- if let Some(done) = spawn_build(shapes, self.live, self.gap) {- self.pending = Some(Pending { key, outlines, done });- return None;- }- // No thread started: build here.- return Some(self.get(cx, open_filled_as_closed));- }- let map = build_map(shapes, self.live, self.gap);- self.install(key, map, outlines);- Some(&self.map)- }-- fn at(&mut self, cx: &ToolContext, p: Point) -> Option<usize> {- self.get(cx, true).region_at(p)- }-}-// ---------- Shape Builder ----------pub use po::SHAPE_BUILDER_MAX_GAP;++mod cache;+mod live_paint;+mod lookup;+mod map;++use cache::RegionCache;+#[cfg(test)]+use live_paint::LpHover;+use live_paint::lp_color;+pub use live_paint::{LP_SELECT_WIDTH, LP_SELECT_WIDTH_RANGE, LivePaintBucketTool, LivePaintSelectionTool};+pub use lookup::{+ EDGE_NAME, FACE_NAME, Face, LIVE_PAINT_NAME, LIVE_PAINT_PREFIX, SOURCES_NAME, drawn_outlines, edge_near, edges, face_at, faces, is_live_paint,+ leaf_shapes, live_paint_at, live_paint_takes, node_outline, outline_snap, path_contains, shape_builder_shapes, shapes_for, sources,+ visible_edge_near, visible_face_at,+};+pub use map::{BuilderMap, HATCH, HIGHLIGHT_RED, Hit, Touched, hatch, maps_built, sample_polyline, sorted_roots};/// Small, Medium and Large gap lengths in points.pub const GAP_LENGTHS: [f64; 3] = [3.0, 6.0, 12.0];@@ -1409,266 +521,6 @@ impl Tool for ShapeBuilderTool {}}-// ---------- Live Paint Bucket ------------/// What the Live Paint tools highlight under the cursor.-#[derive(Clone, Debug, Default, PartialEq)]-enum LpHover {- #[default]- None,- /// A face (or edge) of an existing Live Paint group.- Part(BezPath),- /// A region of the (not yet live) selection.- Region(usize),-}--/// The Live Paint group and part the Live Paint tools hover and click at `p`. Inside a visible face-/// of a visible Live Paint group ([`live_paint_at`]) it is that group with its visible face under-/// `p`, or with `edge` its visible edge nearest `p` within `tol` (None when there is none). Outside-/// every visible face, with `edge`, it is the visible edge nearest `p` within `tol` among the-/// visible Live Paint groups (the front-most group's on a tie). None when no group is found.-fn lp_part_at(doc: &Document, p: Point, tol: f64, edge: bool) -> Option<(NodeId, Option<&Arc<Node>>)> {- if let Some(g) = live_paint_at(doc, p).and_then(|id| doc.node(id)) {- return Some((g.id, if edge { visible_edge_near(g, p, tol) } else { visible_face_at(g, p) }));- }- if !edge {- return None;- }- let mut best: Option<(f64, NodeId, &Arc<Node>)> = None;- doc.walk(|n| {- if is_live_paint(n)- && let Some(e) = visible_edge_near(n, p, tol)- && let Some((.., d)) = e.path_data().and_then(|pd| pd.nearest(p))- && best.is_none_or(|b| d <= b.0)- && doc.is_visible(n.id)- {- best = Some((d, n.id, e));- }- });- best.map(|(_, g, e)| (g, Some(e)))-}--/// What the Live Paint tools highlight at `p`: the part of a Live Paint group ([`lp_part_at`]), else-/// with `cache` the region of the selection under `p`. A large selection's regions are found on-/// another thread ([`RegionCache::ready`]), and until they are, no region is highlighted.-fn lp_hover(cx: &ToolContext, cache: Option<&mut RegionCache>, p: Point, edge: bool) -> LpHover {- if let Some((_, part)) = lp_part_at(cx.doc, p, cx.tol(4.0), edge) {- return part.and_then(|n| n.path_data()).map(|pd| LpHover::Part(pd.to_bezpath())).unwrap_or_default();- }- let sel_is_live = cx.selection.objects.iter().any(|id| cx.doc.node(*id).is_some_and(is_live_paint));- if !sel_is_live && let Some(i) = cache.and_then(|c| c.ready(cx, true)).and_then(|m| m.region_at(p)) {- return LpHover::Region(i);- }- LpHover::None-}--/// The highlight of `h`, `width` screen pixels wide in `color`.-fn lp_overlays(h: &LpHover, cache: &RegionCache, color: [u8; 3], width: f32) -> Vec<Overlay> {- match h {- LpHover::None => vec![],- LpHover::Part(bp) => vec![Overlay::Path { path: bp.clone(), color, width, dashed: false }],- LpHover::Region(i) => {- cache.map.regions.get(*i).map(|(_, bp, _)| vec![Overlay::Path { path: bp.clone(), color, width, dashed: false }]).unwrap_or_default()- }- }-}--/// Live Paint Bucket: click fills the face under the cursor with the current fill; Shift-click-/// paints the nearest edge with the current stroke. Clicking selected ordinary paths makes them a-/// Live Paint group first.-pub struct LivePaintBucketTool {- cache: RegionCache,- hover: LpHover,- /// Where the pointer last moved, and whether Shift was held.- at: Option<(Point, bool)>,-}--impl Default for LivePaintBucketTool {- fn default() -> Self {- Self { cache: RegionCache::live_paint(), hover: LpHover::None, at: None }- }-}--impl Tool for LivePaintBucketTool {- fn id(&self) -> &'static str {- "livePaintBucket"- }-- fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {- let p = ev.pos;- match ev.kind {- PointerKind::Move => {- self.at = Some((p, ev.mods.shift));- self.hover = lp_hover(cx, Some(&mut self.cache), p, ev.mods.shift);- vec![]- }- PointerKind::Down => {- self.hover = LpHover::None;- let point = json!([p.x, p.y]);- if ev.mods.shift {- return match lp_part_at(cx.doc, p, cx.tol(4.0), true) {- Some((g, Some(_))) => {- vec![Action::Exec("livePaint.strokeEdge".into(), json!({ "group": g.0, "point": point, "tolerance": cx.tol(4.0) }))]- }- _ => vec![],- };- }- if let Some(g) = live_paint_at(cx.doc, p) {- return vec![Action::Exec("livePaint.fill".into(), json!({ "group": g.0, "point": point }))];- }- if self.cache.at(cx, p).is_some() {- let roots = sorted_roots(cx.doc, &cx.selection.objects);- return vec![Action::Exec("livePaint.fill".into(), json!({ "ids": json_ids(&roots), "point": point }))];- }- vec![]- }- _ => vec![],- }- }-- fn overlays(&self, _cx: &ToolContext) -> Vec<Overlay> {- lp_overlays(&self.hover, &self.cache, HIGHLIGHT_RED, 4.0)- }-- fn cursor(&self, _cx: &ToolContext, _p: Point, _m: Mods) -> Cursor {- Cursor::LivePaintBucket- }-- fn waiting(&self) -> bool {- self.cache.waiting()- }-- fn poll(&mut self, cx: &ToolContext, wait: bool) {- if !self.cache.waiting() {- return;- }- // As the Shape Builder's: the map that arrives may be for an earlier revision. Over a part- // of a Live Paint group the hover takes no map.- loop {- self.cache.settle(wait);- if let Some((p, shift)) = self.at {- self.hover = lp_hover(cx, Some(&mut self.cache), p, shift);- }- if !wait || !self.cache.waiting() {- break;- }- }- }-}--// ---------- Live Paint Selection ------------/// The Live Paint Selection tool's highlight width (screen pixels) by default.-pub const LP_SELECT_WIDTH: f64 = 4.0;-/// The least and greatest highlight width (screen pixels) the Live Paint Selection tool takes.-pub const LP_SELECT_WIDTH_RANGE: (f64, f64) = (1.0, 20.0);--/// Live Paint Selection: click selects a face (Shift adds); Alt-click selects an edge. Its Tool-/// Options (double-click the tool) are `selectFills` and `selectStrokes` (both on), the highlight-/// `color` (`#rrggbb`, red by default) and its `width` ([`LP_SELECT_WIDTH`] pixels). With Select-/// Strokes off, Alt-click selects the face under the pointer as a click does; with Select Fills-/// off, a click selects the edge nearest the pointer as Alt-click does; with both off, a click-/// selects no face or edge.-pub struct LivePaintSelectionTool {- cache: RegionCache,- hover: LpHover,- fills: bool,- strokes: bool,- color: [u8; 3],- width: f64,-}--impl Default for LivePaintSelectionTool {- fn default() -> Self {- Self { cache: RegionCache::live_paint(), hover: LpHover::None, fills: true, strokes: true, color: HIGHLIGHT_RED, width: LP_SELECT_WIDTH }- }-}--impl LivePaintSelectionTool {- /// What a click picks, Alt held or not: Some(true) an edge, Some(false) a face, None nothing.- fn picks_edge(&self, alt: bool) -> Option<bool> {- match (self.fills, self.strokes) {- (true, true) => Some(alt),- (true, false) => Some(false),- (false, true) => Some(true),- (false, false) => None,- }- }-}--/// A highlight color option: `#rrggbb` or a layer color's name (any case).-fn lp_color(v: &Value) -> Option<[u8; 3]> {- let s = v.as_str()?.trim();- if let Some((_, c)) = vectorcraft_doc::LAYER_COLORS.iter().find(|(name, _)| name.eq_ignore_ascii_case(s)) {- return Some(*c);- }- let [r, g, b, _] = vectorcraft_color::Color::from_hex(s)?.to_rgba8(1.0);- Some([r, g, b])-}--impl Tool for LivePaintSelectionTool {- fn id(&self) -> &'static str {- "livePaintSelection"- }-- fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {- let p = ev.pos;- let edge = self.picks_edge(ev.mods.alt);- match ev.kind {- PointerKind::Move => {- // Only the parts of Live Paint groups highlight, so no map of the selection is built.- self.hover = match edge.map(|e| lp_hover(cx, None, p, e)) {- Some(h @ LpHover::Part(_)) => h,- _ => LpHover::None,- };- vec![]- }- PointerKind::Down => {- let hit = edge.and_then(|e| lp_part_at(cx.doc, p, cx.tol(4.0), e)).and_then(|(_, part)| part).map(|n| n.id);- match (hit, ev.mods.shift) {- (Some(id), true) => vec![Action::Exec("select.toggle".into(), json!({ "id": id.0 }))],- (Some(id), false) => vec![Action::Exec("select.set".into(), json!({ "ids": [id.0] }))],- (None, true) => vec![],- (None, false) => vec![Action::Exec("select.none".into(), json!({}))],- }- }- _ => vec![],- }- }-- fn overlays(&self, _cx: &ToolContext) -> Vec<Overlay> {- lp_overlays(&self.hover, &self.cache, self.color, self.width as f32)- }-- fn cursor(&self, _cx: &ToolContext, _p: Point, _m: Mods) -> Cursor {- Cursor::Arrow- }-- fn options(&self) -> Value {- let [r, g, b] = self.color;- json!({- "selectFills": self.fills,- "selectStrokes": self.strokes,- "color": format!("#{r:02x}{g:02x}{b:02x}"),- "width": self.width,- })- }-- fn set_option(&mut self, key: &str, v: &Value) {- match key {- "selectFills" => self.fills = v.as_bool().unwrap_or(self.fills),- "selectStrokes" => self.strokes = v.as_bool().unwrap_or(self.strokes),- "color" => self.color = lp_color(v).unwrap_or(self.color),- "width" => {- let (min, max) = LP_SELECT_WIDTH_RANGE;- self.width = v.as_f64().filter(|w| w.is_finite()).map_or(self.width, |w| w.clamp(min, max));- }- _ => return,- }- self.hover = LpHover::None;- }-}-/// Create a builder-family tool by id (None = not one of ours).pub fn create(id: &str) -> Option<Box<dyn Tool>> {Some(match id {diff --git a/crates/tools/src/builder/cache.rs b/crates/tools/src/builder/cache.rsnew file mode 100644index 000000000..27487e4c3--- /dev/null+++ b/crates/tools/src/builder/cache.rs@@ -0,0 +1,195 @@+use super::lookup::{drawn_outlines, faces_of, shape_builder_shapes, shapes_for};+use super::map::{BuilderMap, sorted_roots};+use super::*;++/// What a [`RegionCache`] map was built for: the document's address and revision, the selected ids+/// and whether filled open paths count as closed.+pub(super) type CacheKey = (usize, (u64, u64), Vec<NodeId>, bool);++/// Hovering builds the map of inputs with more segments than this on another thread+/// ([`RegionCache::ready`]); smaller maps are built on the calling thread.+const BACKGROUND_SEGMENTS: usize = 128;++/// A map being built on another thread: the key it is for, the drawn outlines of its inputs, and+/// the channel it arrives on.+struct Pending {+ key: CacheKey,+ outlines: Vec<PathData>,+ done: Receiver<BuilderMap>,+}++/// The planar map of the current selection, cached by document identity, revision, selection and+/// whether filled open paths count as closed.+#[derive(Default)]+pub(super) struct RegionCache {+ pub(super) key: Option<CacheKey>,+ /// The map, which the Shape Builder's merge command takes too ([`Tool::shape_builder_map`]).+ pub(super) map: Arc<BuilderMap>,+ /// Live Paint faces (every path an edge, filled or not) rather than Shape Builder regions.+ live: bool,+ /// Gap Detection distance; changing tool options invalidates the cache.+ pub(super) gap: f64,+ /// The outlines of the Shape Builder's inputs as they are drawn (see [`BuilderMap::stroke_at`]).+ pub(super) outlines: Vec<PathData>,+ /// The map being built on another thread, if any.+ pending: Option<Pending>,+ /// The key of the last map whose build on another thread failed.+ failed: Option<CacheKey>,+ /// How many times the map has been built.+ #[cfg(test)]+ pub(super) builds: usize,+ /// How many of those builds ran on another thread.+ #[cfg(test)]+ pub(super) background: usize,+}++/// The map of `shapes`: Live Paint faces with `live`, else the Shape Builder map with its edges,+/// closing gaps up to `gap`.+fn build_map(shapes: Vec<po::Shape>, live: bool, gap: f64) -> BuilderMap {+ if live {+ let regions = if shapes.is_empty() { vec![] } else { faces_of(po::live_paint(&shapes).0) };+ BuilderMap { regions, ..Default::default() }+ } else {+ BuilderMap::of_shapes(shapes, true, gap)+ }+}++/// Builds the map of `shapes` ([`build_map`]) on a new thread; None when no thread starts.+#[cfg(not(target_arch = "wasm32"))]+fn spawn_build(shapes: Vec<po::Shape>, live: bool, gap: f64) -> Option<Receiver<BuilderMap>> {+ let (tx, done) = std::sync::mpsc::channel();+ let spawned = std::thread::Builder::new().name("vectorcraft-region-map".into()).spawn(move || {+ // The tool may have dropped the receiver meanwhile (another tool, another selection).+ let _ = tx.send(build_map(shapes, live, gap));+ });+ spawned.is_ok().then_some(done)+}++/// The web build has no threads.+#[cfg(target_arch = "wasm32")]+fn spawn_build(_shapes: Vec<po::Shape>, _live: bool, _gap: f64) -> Option<Receiver<BuilderMap>> {+ None+}++impl RegionCache {+ pub(super) fn live_paint() -> Self {+ Self { live: true, ..Default::default() }+ }++ fn key_for(cx: &ToolContext, open_filled_as_closed: bool) -> CacheKey {+ (cx.doc as *const Document as usize, cx.revision, cx.selection.objects.clone(), open_filled_as_closed)+ }++ /// The inputs of the selection's map, back → front, and their drawn outlines (Shape Builder+ /// only).+ fn inputs(&self, cx: &ToolContext, open_filled_as_closed: bool) -> (Vec<po::Shape>, Vec<PathData>) {+ let roots = sorted_roots(cx.doc, &cx.selection.objects);+ if self.live {+ (shapes_for(cx.doc, &roots).0, vec![])+ } else {+ let (shapes, leaves) = shape_builder_shapes(cx.doc, &roots, open_filled_as_closed);+ let outlines = drawn_outlines(cx.doc, &leaves);+ (shapes, outlines)+ }+ }++ fn install(&mut self, key: CacheKey, map: BuilderMap, outlines: Vec<PathData>) {+ self.map = Arc::new(map);+ self.outlines = outlines;+ self.key = Some(key);+ #[cfg(test)]+ {+ self.builds += 1;+ }+ }++ /// Forgets the map and any map being built (the tool options changed).+ pub(super) fn clear(&mut self) {+ self.key = None;+ self.pending = None;+ self.failed = None;+ }++ /// Is a map being built on another thread?+ pub(super) fn waiting(&self) -> bool {+ self.pending.is_some()+ }++ /// The map, built again only when the key changes, with filled open paths closed when+ /// `open_filled_as_closed` (Shape Builder only). A Shape Builder map has the outline edges too,+ /// so hovering and erasing use the same map. Waits for a map being built on another thread for+ /// the same key.+ pub(super) fn get(&mut self, cx: &ToolContext, open_filled_as_closed: bool) -> &BuilderMap {+ let key = Self::key_for(cx, open_filled_as_closed);+ if self.key.as_ref() != Some(&key) {+ let built = self.pending.take().filter(|p| p.key == key).and_then(|p| Some((p.done.recv().ok()?, p.outlines)));+ let (map, outlines) = match built {+ Some(b) => {+ #[cfg(test)]+ {+ self.background += 1;+ }+ b+ }+ None => {+ let (shapes, outlines) = self.inputs(cx, open_filled_as_closed);+ (build_map(shapes, self.live, self.gap), outlines)+ }+ };+ self.install(key, map, outlines);+ }+ &self.map+ }++ /// Takes the map being built on another thread once it has arrived, or with `wait` once it+ /// arrives, as the map for the key it was built for.+ pub(super) fn settle(&mut self, wait: bool) {+ let Some(p) = self.pending.take() else { return };+ let got = if wait { p.done.recv().map_err(|_| TryRecvError::Disconnected) } else { p.done.try_recv() };+ match got {+ Ok(map) => {+ #[cfg(test)]+ {+ self.background += 1;+ }+ self.install(p.key, map, p.outlines);+ }+ // The build failed (a bug in the planar map): hovering does not build it again, and a+ // gesture builds it on the calling thread, which reports the failure.+ Err(TryRecvError::Disconnected) => self.failed = Some(p.key),+ Err(TryRecvError::Empty) => self.pending = Some(p),+ }+ }++ /// The map as [`Self::get`] gives it, without waiting: when the key changes and the inputs have+ /// more than [`BACKGROUND_SEGMENTS`] segments, the map is built on another thread, and this is+ /// None until it arrives ([`Self::waiting`] holds meanwhile). A map being built for an earlier+ /// key is let finish before the next one starts.+ pub(super) fn ready(&mut self, cx: &ToolContext, open_filled_as_closed: bool) -> Option<&BuilderMap> {+ self.settle(false);+ let key = Self::key_for(cx, open_filled_as_closed);+ if self.key.as_ref() == Some(&key) {+ return Some(&self.map);+ }+ if self.pending.is_some() || self.failed.as_ref() == Some(&key) {+ return None;+ }+ let (shapes, outlines) = self.inputs(cx, open_filled_as_closed);+ let segments: usize = shapes.iter().map(|s| s.path.subpaths.iter().map(|sp| sp.segment_count()).sum::<usize>()).sum();+ if segments > BACKGROUND_SEGMENTS && cfg!(not(target_arch = "wasm32")) {+ if let Some(done) = spawn_build(shapes, self.live, self.gap) {+ self.pending = Some(Pending { key, outlines, done });+ return None;+ }+ // No thread started: build here.+ return Some(self.get(cx, open_filled_as_closed));+ }+ let map = build_map(shapes, self.live, self.gap);+ self.install(key, map, outlines);+ Some(&self.map)+ }++ pub(super) fn at(&mut self, cx: &ToolContext, p: Point) -> Option<usize> {+ self.get(cx, true).region_at(p)+ }+}diff --git a/crates/tools/src/builder/live_paint.rs b/crates/tools/src/builder/live_paint.rsnew file mode 100644index 000000000..667a6e2e3--- /dev/null+++ b/crates/tools/src/builder/live_paint.rs@@ -0,0 +1,265 @@+use super::cache::RegionCache;+use super::lookup::{is_live_paint, live_paint_at, visible_edge_near, visible_face_at};+use super::map::{HIGHLIGHT_RED, sorted_roots};+use super::*;++// ---------- Live Paint Bucket ----------++/// What the Live Paint tools highlight under the cursor.+#[derive(Clone, Debug, Default, PartialEq)]+pub(super) enum LpHover {+ #[default]+ None,+ /// A face (or edge) of an existing Live Paint group.+ Part(BezPath),+ /// A region of the (not yet live) selection.+ Region(usize),+}++/// The Live Paint group and part the Live Paint tools hover and click at `p`. Inside a visible face+/// of a visible Live Paint group ([`live_paint_at`]) it is that group with its visible face under+/// `p`, or with `edge` its visible edge nearest `p` within `tol` (None when there is none). Outside+/// every visible face, with `edge`, it is the visible edge nearest `p` within `tol` among the+/// visible Live Paint groups (the front-most group's on a tie). None when no group is found.+fn lp_part_at(doc: &Document, p: Point, tol: f64, edge: bool) -> Option<(NodeId, Option<&Arc<Node>>)> {+ if let Some(g) = live_paint_at(doc, p).and_then(|id| doc.node(id)) {+ return Some((g.id, if edge { visible_edge_near(g, p, tol) } else { visible_face_at(g, p) }));+ }+ if !edge {+ return None;+ }+ let mut best: Option<(f64, NodeId, &Arc<Node>)> = None;+ doc.walk(|n| {+ if is_live_paint(n)+ && let Some(e) = visible_edge_near(n, p, tol)+ && let Some((.., d)) = e.path_data().and_then(|pd| pd.nearest(p))+ && best.is_none_or(|b| d <= b.0)+ && doc.is_visible(n.id)+ {+ best = Some((d, n.id, e));+ }+ });+ best.map(|(_, g, e)| (g, Some(e)))+}++/// What the Live Paint tools highlight at `p`: the part of a Live Paint group ([`lp_part_at`]), else+/// with `cache` the region of the selection under `p`. A large selection's regions are found on+/// another thread ([`RegionCache::ready`]), and until they are, no region is highlighted.+fn lp_hover(cx: &ToolContext, cache: Option<&mut RegionCache>, p: Point, edge: bool) -> LpHover {+ if let Some((_, part)) = lp_part_at(cx.doc, p, cx.tol(4.0), edge) {+ return part.and_then(|n| n.path_data()).map(|pd| LpHover::Part(pd.to_bezpath())).unwrap_or_default();+ }+ let sel_is_live = cx.selection.objects.iter().any(|id| cx.doc.node(*id).is_some_and(is_live_paint));+ if !sel_is_live && let Some(i) = cache.and_then(|c| c.ready(cx, true)).and_then(|m| m.region_at(p)) {+ return LpHover::Region(i);+ }+ LpHover::None+}++/// The highlight of `h`, `width` screen pixels wide in `color`.+fn lp_overlays(h: &LpHover, cache: &RegionCache, color: [u8; 3], width: f32) -> Vec<Overlay> {+ match h {+ LpHover::None => vec![],+ LpHover::Part(bp) => vec![Overlay::Path { path: bp.clone(), color, width, dashed: false }],+ LpHover::Region(i) => {+ cache.map.regions.get(*i).map(|(_, bp, _)| vec![Overlay::Path { path: bp.clone(), color, width, dashed: false }]).unwrap_or_default()+ }+ }+}++/// Live Paint Bucket: click fills the face under the cursor with the current fill; Shift-click+/// paints the nearest edge with the current stroke. Clicking selected ordinary paths makes them a+/// Live Paint group first.+pub struct LivePaintBucketTool {+ pub(super) cache: RegionCache,+ pub(super) hover: LpHover,+ /// Where the pointer last moved, and whether Shift was held.+ at: Option<(Point, bool)>,+}++impl Default for LivePaintBucketTool {+ fn default() -> Self {+ Self { cache: RegionCache::live_paint(), hover: LpHover::None, at: None }+ }+}++impl Tool for LivePaintBucketTool {+ fn id(&self) -> &'static str {+ "livePaintBucket"+ }++ fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {+ let p = ev.pos;+ match ev.kind {+ PointerKind::Move => {+ self.at = Some((p, ev.mods.shift));+ self.hover = lp_hover(cx, Some(&mut self.cache), p, ev.mods.shift);+ vec![]+ }+ PointerKind::Down => {+ self.hover = LpHover::None;+ let point = json!([p.x, p.y]);+ if ev.mods.shift {+ return match lp_part_at(cx.doc, p, cx.tol(4.0), true) {+ Some((g, Some(_))) => {+ vec![Action::Exec("livePaint.strokeEdge".into(), json!({ "group": g.0, "point": point, "tolerance": cx.tol(4.0) }))]+ }+ _ => vec![],+ };+ }+ if let Some(g) = live_paint_at(cx.doc, p) {+ return vec![Action::Exec("livePaint.fill".into(), json!({ "group": g.0, "point": point }))];+ }+ if self.cache.at(cx, p).is_some() {+ let roots = sorted_roots(cx.doc, &cx.selection.objects);+ return vec![Action::Exec("livePaint.fill".into(), json!({ "ids": json_ids(&roots), "point": point }))];+ }+ vec![]+ }+ _ => vec![],+ }+ }++ fn overlays(&self, _cx: &ToolContext) -> Vec<Overlay> {+ lp_overlays(&self.hover, &self.cache, HIGHLIGHT_RED, 4.0)+ }++ fn cursor(&self, _cx: &ToolContext, _p: Point, _m: Mods) -> Cursor {+ Cursor::LivePaintBucket+ }++ fn waiting(&self) -> bool {+ self.cache.waiting()+ }++ fn poll(&mut self, cx: &ToolContext, wait: bool) {+ if !self.cache.waiting() {+ return;+ }+ // As the Shape Builder's: the map that arrives may be for an earlier revision. Over a part+ // of a Live Paint group the hover takes no map.+ loop {+ self.cache.settle(wait);+ if let Some((p, shift)) = self.at {+ self.hover = lp_hover(cx, Some(&mut self.cache), p, shift);+ }+ if !wait || !self.cache.waiting() {+ break;+ }+ }+ }+}++// ---------- Live Paint Selection ----------++/// The Live Paint Selection tool's highlight width (screen pixels) by default.+pub const LP_SELECT_WIDTH: f64 = 4.0;++/// The least and greatest highlight width (screen pixels) the Live Paint Selection tool takes.+pub const LP_SELECT_WIDTH_RANGE: (f64, f64) = (1.0, 20.0);++/// Live Paint Selection: click selects a face (Shift adds); Alt-click selects an edge. Its Tool+/// Options (double-click the tool) are `selectFills` and `selectStrokes` (both on), the highlight+/// `color` (`#rrggbb`, red by default) and its `width` ([`LP_SELECT_WIDTH`] pixels). With Select+/// Strokes off, Alt-click selects the face under the pointer as a click does; with Select Fills+/// off, a click selects the edge nearest the pointer as Alt-click does; with both off, a click+/// selects no face or edge.+pub struct LivePaintSelectionTool {+ pub(super) cache: RegionCache,+ pub(super) hover: LpHover,+ fills: bool,+ strokes: bool,+ color: [u8; 3],+ width: f64,+}++impl Default for LivePaintSelectionTool {+ fn default() -> Self {+ Self { cache: RegionCache::live_paint(), hover: LpHover::None, fills: true, strokes: true, color: HIGHLIGHT_RED, width: LP_SELECT_WIDTH }+ }+}++impl LivePaintSelectionTool {+ /// What a click picks, Alt held or not: Some(true) an edge, Some(false) a face, None nothing.+ fn picks_edge(&self, alt: bool) -> Option<bool> {+ match (self.fills, self.strokes) {+ (true, true) => Some(alt),+ (true, false) => Some(false),+ (false, true) => Some(true),+ (false, false) => None,+ }+ }+}++/// A highlight color option: `#rrggbb` or a layer color's name (any case).+pub(super) fn lp_color(v: &Value) -> Option<[u8; 3]> {+ let s = v.as_str()?.trim();+ if let Some((_, c)) = vectorcraft_doc::LAYER_COLORS.iter().find(|(name, _)| name.eq_ignore_ascii_case(s)) {+ return Some(*c);+ }+ let [r, g, b, _] = vectorcraft_color::Color::from_hex(s)?.to_rgba8(1.0);+ Some([r, g, b])+}++impl Tool for LivePaintSelectionTool {+ fn id(&self) -> &'static str {+ "livePaintSelection"+ }++ fn pointer(&mut self, cx: &ToolContext, ev: &PointerEvent) -> Vec<Action> {+ let p = ev.pos;+ let edge = self.picks_edge(ev.mods.alt);+ match ev.kind {+ PointerKind::Move => {+ // Only the parts of Live Paint groups highlight, so no map of the selection is built.+ self.hover = match edge.map(|e| lp_hover(cx, None, p, e)) {+ Some(h @ LpHover::Part(_)) => h,+ _ => LpHover::None,+ };+ vec![]+ }+ PointerKind::Down => {+ let hit = edge.and_then(|e| lp_part_at(cx.doc, p, cx.tol(4.0), e)).and_then(|(_, part)| part).map(|n| n.id);+ match (hit, ev.mods.shift) {+ (Some(id), true) => vec![Action::Exec("select.toggle".into(), json!({ "id": id.0 }))],+ (Some(id), false) => vec![Action::Exec("select.set".into(), json!({ "ids": [id.0] }))],+ (None, true) => vec![],+ (None, false) => vec![Action::Exec("select.none".into(), json!({}))],+ }+ }+ _ => vec![],+ }+ }++ fn overlays(&self, _cx: &ToolContext) -> Vec<Overlay> {+ lp_overlays(&self.hover, &self.cache, self.color, self.width as f32)+ }++ fn cursor(&self, _cx: &ToolContext, _p: Point, _m: Mods) -> Cursor {+ Cursor::Arrow+ }++ fn options(&self) -> Value {+ let [r, g, b] = self.color;+ json!({+ "selectFills": self.fills,+ "selectStrokes": self.strokes,+ "color": format!("#{r:02x}{g:02x}{b:02x}"),+ "width": self.width,+ })+ }++ fn set_option(&mut self, key: &str, v: &Value) {+ match key {+ "selectFills" => self.fills = v.as_bool().unwrap_or(self.fills),+ "selectStrokes" => self.strokes = v.as_bool().unwrap_or(self.strokes),+ "color" => self.color = lp_color(v).unwrap_or(self.color),+ "width" => {+ let (min, max) = LP_SELECT_WIDTH_RANGE;+ self.width = v.as_f64().filter(|w| w.is_finite()).map_or(self.width, |w| w.clamp(min, max));+ }+ _ => return,+ }+ self.hover = LpHover::None;+ }+}diff --git a/crates/tools/src/builder/lookup.rs b/crates/tools/src/builder/lookup.rsnew file mode 100644index 000000000..30475be34--- /dev/null+++ b/crates/tools/src/builder/lookup.rs@@ -0,0 +1,259 @@+use super::*;++/// Names starting with this mark a Live Paint group, together with its sources group ([`SOURCES_NAME`]).+pub const LIVE_PAINT_PREFIX: &str = "Live Paint";++/// Default name of a new Live Paint group.+pub const LIVE_PAINT_NAME: &str = "Live Paint Group";++/// The hidden child group holding the source paths.+pub const SOURCES_NAME: &str = "Live Paint Sources";++pub const FACE_NAME: &str = "Face";++pub const EDGE_NAME: &str = "Edge";++/// Is `n` a Live Paint group: an unclipped group whose name starts with [`LIVE_PAINT_PREFIX`] and+/// that holds a group named [`SOURCES_NAME`]? A plain group with such a name is not one.+pub fn is_live_paint(n: &Node) -> bool {+ matches!(n.kind, NodeKind::Group { clip: false, .. })+ && n.name.as_deref().is_some_and(|s| s.starts_with(LIVE_PAINT_PREFIX))+ && sources(n).is_some_and(|s| matches!(s.kind, NodeKind::Group { .. }))+}++/// Whether Live Paint can take `n` as it is: a Live Paint group, a path or compound path, or a+/// group of those. Type, images, symbols, blends, meshes and the rest have to be converted to+/// paths first (<https://helpx.adobe.com/illustrator/desktop/paint-and-fill/learn-painting-basics/create-live-paint-groups.html>);+/// Make and Merge refuse them rather than hide them among the group's sources.+pub fn live_paint_takes(n: &Node) -> bool {+ is_live_paint(n)+ || match &n.kind {+ NodeKind::Path { .. } | NodeKind::Compound { .. } => true,+ NodeKind::Group { children, .. } => children.iter().all(|c| live_paint_takes(c)),+ _ => false,+ }+}++fn named(n: &Node, name: &str) -> bool {+ n.name.as_deref() == Some(name)+}++/// Face children of a Live Paint group (paint order).+pub fn faces(group: &Node) -> Vec<&Arc<Node>> {+ group.children().map(|c| c.iter().filter(|n| named(n, FACE_NAME)).collect()).unwrap_or_default()+}++/// Edge children of a Live Paint group.+pub fn edges(group: &Node) -> Vec<&Arc<Node>> {+ group.children().map(|c| c.iter().filter(|n| named(n, EDGE_NAME)).collect()).unwrap_or_default()+}++/// The hidden sources group of a Live Paint group.+pub fn sources(group: &Node) -> Option<&Arc<Node>> {+ group.children()?.iter().find(|n| named(n, SOURCES_NAME))+}++/// Does the path (filled) contain `p`?+pub fn path_contains(path: &PathData, rule: FillRule, p: Point) -> bool {+ if path.bounds().is_none_or(|b| !b.inflate(1e-6, 1e-6).contains(p)) {+ return false;+ }+ let w = path.to_bezpath().winding(p);+ match rule {+ FillRule::EvenOdd => w % 2 != 0,+ _ => w != 0,+ }+}++/// The face of `group` under `p` (front-most).+pub fn face_at(group: &Node, p: Point) -> Option<&Arc<Node>> {+ front_face(faces(group).into_iter(), p)+}++/// The face of `group` under `p` (front-most) among its faces that are not hidden.+pub fn visible_face_at(group: &Node, p: Point) -> Option<&Arc<Node>> {+ front_face(faces(group).into_iter().filter(|f| f.visible), p)+}++/// The face of `faces` (paint order) under `p` (front-most).+fn front_face<'a>(faces: impl DoubleEndedIterator<Item = &'a Arc<Node>>, p: Point) -> Option<&'a Arc<Node>> {+ faces.rev().find(|f| f.path_data().is_some_and(|pd| path_contains(pd, FillRule::NonZero, p)))+}++/// The edge of `group` nearest to `p` within `tol`.+pub fn edge_near(group: &Node, p: Point, tol: f64) -> Option<&Arc<Node>> {+ nearest_edge(edges(group), p, tol)+}++/// The edge of `group` nearest to `p` within `tol` among its edges that are not hidden.+pub fn visible_edge_near(group: &Node, p: Point, tol: f64) -> Option<&Arc<Node>> {+ nearest_edge(edges(group).into_iter().filter(|e| e.visible), p, tol)+}++/// The edge of `edges` nearest to `p` within `tol`.+fn nearest_edge<'a>(edges: impl IntoIterator<Item = &'a Arc<Node>>, p: Point, tol: f64) -> Option<&'a Arc<Node>> {+ let mut best: Option<(f64, &Arc<Node>)> = None;+ for e in edges {+ if let Some((.., d)) = e.path_data().and_then(|pd| pd.nearest(p))+ && d <= tol+ && best.is_none_or(|b| d < b.0)+ {+ best = Some((d, e));+ }+ }+ best.map(|b| b.1)+}++/// The visible Live Paint group with a face under `p` that is not hidden (front-most in paint order).+pub fn live_paint_at(doc: &Document, p: Point) -> Option<NodeId> {+ let mut hit = None;+ doc.walk(|n| {+ if is_live_paint(n) && doc.is_visible(n.id) && visible_face_at(n, p).is_some() {+ hit = Some(n.id);+ }+ });+ hit+}++/// Paths, compound paths (as one shape) of a subtree in paint order; guides, clipping paths and+/// hidden objects are skipped. Live Paint groups contribute their faces and edges.+pub fn leaf_shapes<'a>(n: &'a Node, out: &mut Vec<&'a Node>) {+ collect_leaves(n, false, out);+}++/// [`leaf_shapes`]; with `filled_faces`, a Live Paint group contributes only its filled faces and+/// its stroked edges.+fn collect_leaves<'a>(n: &'a Node, filled_faces: bool, out: &mut Vec<&'a Node>) {+ if !n.visible {+ return;+ }+ if n.extras().shaper.is_some() {+ for c in n.children().into_iter().flatten().skip(1) {+ collect_leaves(c, filled_faces, out);+ }+ return;+ }+ match &n.kind {+ NodeKind::Path { guide: true, .. } | NodeKind::Path { clipping: true, .. } => {}+ NodeKind::Path { .. } | NodeKind::Compound { .. } => out.push(n),+ NodeKind::Group { .. } if filled_faces && is_live_paint(n) => {+ out.extend(faces(n).into_iter().filter(|f| f.visible && !f.appearance.fill_paint().is_none()).map(|f| &**f));+ out.extend(edges(n).into_iter().filter(|e| e.visible && !e.appearance.stroke_paint().is_none()).map(|e| &**e));+ }+ NodeKind::Group { children, .. } | NodeKind::Layer { children, .. } => {+ for c in children {+ collect_leaves(c, filled_faces, out);+ }+ }+ _ => {}+ }+}++/// Filled outline of a path or compound path node.+pub fn node_outline(n: &Node) -> Option<(PathData, FillRule)> {+ match &n.kind {+ NodeKind::Path { path, rule, .. } => Some((path.clone(), *rule)),+ NodeKind::Compound { children, rule } => {+ let subs = children.iter().filter_map(|c| c.path_data()).flat_map(|p| p.subpaths.iter().cloned()).collect();+ Some((PathData::new(subs), *rule))+ }+ _ => None,+ }+}++/// How far (pt) a piece of the planar map may lie from `outline`, the outline it follows, to be+/// matched to it or cut out of it: a ten-thousandth of the outline's larger side, at least 0.05.+/// The map's pieces follow the outlines to within a few hundredths of a point.+pub fn outline_snap(outline: &PathData) -> f64 {+ outline.bounds().map_or(0.05, |b| (b.width().max(b.height()) / 2000.0).max(0.25) * 0.2)+}++/// The outlines of `leaves` as they are drawn ([`node_outline`]), in their order, for+/// [`BuilderMap::stroke_at`]. A leaf without an outline, and one inside a Live Paint group or a+/// Shaper Group (which make their own paths), gets an empty outline, so no stroke of it splits.+pub fn drawn_outlines(doc: &Document, leaves: &[&Node]) -> Vec<PathData> {+ let in_live_group = |id: NodeId| {+ let mut up = doc.parent_of(id);+ while let Some(p) = up {+ if doc.node(p).is_some_and(|n| is_live_paint(n) || n.extras().shaper.is_some()) {+ return true;+ }+ up = doc.parent_of(p);+ }+ false+ };+ leaves.iter().map(|l| if in_live_group(l.id) { None } else { node_outline(l) }.map_or_else(PathData::default, |o| o.0)).collect()+}++/// Pathfinder shapes for the given roots (back → front by the order given), keyed by leaf index,+/// with the leaves they came from.+pub fn shapes_for<'a>(doc: &'a Document, roots: &[NodeId]) -> (Vec<po::Shape>, Vec<&'a Node>) {+ shapes_of(doc, roots, false)+}++/// [`shapes_for`]; with `filled_faces`, a Live Paint group contributes only its filled faces and+/// its stroked edges.+fn shapes_of<'a>(doc: &'a Document, roots: &[NodeId], filled_faces: bool) -> (Vec<po::Shape>, Vec<&'a Node>) {+ let mut lv = vec![];+ for id in roots {+ if let Some(n) = doc.node(*id) {+ collect_leaves(n, filled_faces, &mut lv);+ }+ }+ let mut shapes = vec![];+ let mut used = vec![];+ for l in lv {+ if let Some((p, r)) = node_outline(l)+ && !p.is_empty()+ && p.subpaths.iter().all(|s| s.anchors.iter().all(|a| a.p.x.is_finite() && a.p.y.is_finite()))+ {+ shapes.push(po::Shape::new(p, r, used.len() as u64));+ used.push(l);+ }+ }+ (shapes, used)+}++/// Shape Builder inputs: [`shapes_for`], with the open subpaths of filled paths closed where that+/// encloses an area (the fill bounds a region, as if an invisible edge closed it) when+/// `open_filled_as_closed`. Unfilled open paths and straight lines stay open and cut the regions+/// they cross, and so do filled open paths without `open_filled_as_closed`. A Live Paint group+/// contributes its filled faces as shapes and its stroked edges as open lines; its unfilled faces+/// and its edges without a stroke are left out.+pub fn shape_builder_shapes<'a>(doc: &'a Document, roots: &[NodeId], open_filled_as_closed: bool) -> (Vec<po::Shape>, Vec<&'a Node>) {+ let (mut shapes, leaves) = shapes_of(doc, roots, true);+ for (s, l) in shapes.iter_mut().zip(&leaves) {+ if named(l, EDGE_NAME) && doc.parent_of(l.id).and_then(|p| doc.node(p)).is_some_and(is_live_paint) {+ // A closed edge opens at its first anchor and keeps its closing segment.+ let start = BTreeSet::from([0]);+ s.path.subpaths = s.path.subpaths.iter().flat_map(|sp| sp.cut_at(&start)).collect();+ continue;+ }+ if !open_filled_as_closed || l.appearance.fill_paint().is_none() {+ continue;+ }+ for sp in s.path.subpaths.iter_mut().filter(|sp| !sp.closed) {+ sp.closed = po::encloses_area(sp);+ }+ }+ (shapes, leaves)+}++/// A planar-map face with its outline and bounds, ready for hit tests.+pub type Face = (po::Region, BezPath, Rect);++pub(super) fn faces_of(regions: Vec<po::Region>) -> Vec<Face> {+ regions+ .into_iter()+ .filter_map(|r| {+ let bp = r.path.to_bezpath();+ let b = r.path.bounds()?;+ Some((r, bp, b))+ })+ .collect()+}++thread_local! {+ /// The Shape Builder maps built on this thread ([`maps_built`]).+ pub(super) static MAPS_BUILT: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };+}diff --git a/crates/tools/src/builder/map.rs b/crates/tools/src/builder/map.rsnew file mode 100644index 000000000..cf9327dd4--- /dev/null+++ b/crates/tools/src/builder/map.rs@@ -0,0 +1,462 @@+use super::lookup::{Face, MAPS_BUILT, faces_of, outline_snap, shape_builder_shapes};+use super::*;++/// Shape Builder hover hatch colour (neutral grey) and Live Paint highlight red.+pub const HATCH: [u8; 3] = [0x80, 0x80, 0x80];++pub const HIGHLIGHT_RED: [u8; 3] = [0xff, 0x2a, 0x2a];++/// How many Shape Builder maps ([`BuilderMap::of_shapes`]) this thread has built, for tests that+/// count them.+pub fn maps_built() -> usize {+ MAPS_BUILT.with(std::cell::Cell::get)+}++/// The Shape Builder's planar map of a selection.+#[derive(Default)]+pub struct BuilderMap {+ /// The inputs, back → front (see [`po::shape_builder`]).+ pub shapes: Vec<po::Shape>,+ pub regions: Vec<Face>,+ /// Pieces of the open paths that cut regions (see [`BuilderMap::new`]), keyed by input index,+ /// with their bounds.+ pub lines: Vec<(po::Shape, Rect)>,+ /// Pieces of the other inputs' outlines (cut wherever paths meet), keyed by input index, with+ /// their bounds: the edges erasing deletes. Only in a map made `with_edges`.+ pub edges: Vec<(po::Shape, Rect)>,+}++/// What a Shape Builder gesture touches at a point.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum Hit {+ Region(usize),+ Line(usize),+ Edge(usize),+}++/// The piece of `pieces` nearest `p` within `tol`, with its distance.+fn piece_near(pieces: &[(po::Shape, Rect)], p: Point, tol: f64) -> Option<(f64, usize)> {+ let mut best: Option<(f64, usize)> = None;+ for (i, (l, b)) in pieces.iter().enumerate() {+ if b.inflate(tol, tol).contains(p)+ && let Some((.., d)) = l.path.nearest(p)+ && d <= tol+ && best.is_none_or(|b| d < b.0)+ {+ best = Some((d, i));+ }+ }+ best+}++impl BuilderMap {+ /// The map of `roots` (sorted back → front), with the leaves the inputs came from; the outline+ /// edges only `with_edges`. With `open_filled_as_closed` (Consider Open Filled Paths as+ /// Closed), a filled open path bounds a region as if an invisible edge closed it; without it,+ /// the path cuts like a line.+ pub fn new<'a>(doc: &'a Document, roots: &[NodeId], with_edges: bool, open_filled_as_closed: bool) -> (Self, Vec<&'a Node>) {+ Self::with_gap(doc, roots, with_edges, open_filled_as_closed, 0.0)+ }++ /// The same arrangement with Gap Detection, using the shared Live Paint gap finder.+ pub fn with_gap<'a>(doc: &'a Document, roots: &[NodeId], with_edges: bool, open_filled_as_closed: bool, gap: f64) -> (Self, Vec<&'a Node>) {+ let (shapes, leaves) = shape_builder_shapes(doc, roots, open_filled_as_closed);+ (Self::of_shapes(shapes, with_edges, gap), leaves)+ }++ /// The map of `shapes` (the inputs, back → front, as [`shape_builder_shapes`] gives them), with+ /// the outline edges only `with_edges`, closing gaps up to `gap`.+ pub fn of_shapes(shapes: Vec<po::Shape>, with_edges: bool, gap: f64) -> Self {+ if shapes.is_empty() {+ return Self::default();+ }+ MAPS_BUILT.with(|n| n.set(n.get() + 1));+ let arr = po::shape_builder_with_gap(&shapes, with_edges, gap);+ let bounded = |pieces: Vec<po::Shape>| {+ pieces+ .into_iter()+ .filter_map(|l| {+ let b = l.path.bounds()?;+ Some((l, b))+ })+ .collect()+ };+ Self { shapes, regions: faces_of(arr.regions), lines: bounded(arr.lines), edges: bounded(arr.edges) }+ }++ /// The region containing `p`.+ pub fn region_at(&self, p: Point) -> Option<usize> {+ self.regions.iter().position(|(_, bp, b)| b.contains(p) && bp.winding(p) != 0)+ }++ /// The regions a rectangular marquee from `from` (where the drag started) to `to` touches: each+ /// region whose outline crosses the rectangle or has an anchor inside it, and the region the+ /// whole rectangle lies in. Of those, the region under `from` comes first, then the one under+ /// `to`, then the others in map order. A marquee of no size touches the region under `from`.+ pub fn regions_in_marquee(&self, from: Point, to: Point) -> Vec<usize> {+ let r = Rect::from_points(from, to);+ if r.width() <= 0.0 && r.height() <= 0.0 {+ return self.region_at(from).into_iter().collect();+ }+ let c = r.center();+ let touches = |(reg, bp, b): &Face| (b.contains(c) && bp.winding(c) != 0) || vectorcraft_geom::hit::intersects_rect(®.path, r);+ let mut out: Vec<usize> = self.regions.iter().enumerate().filter(|(_, f)| touches(f)).map(|(i, _)| i).collect();+ for p in [to, from] {+ if let Some(k) = self.region_at(p).and_then(|i| out.iter().position(|&j| j == i)) {+ let i = out.remove(k);+ out.insert(0, i);+ }+ }+ out+ }++ /// What a gesture at `p` touches: with `piece_tol` (erasing), the line piece or edge that+ /// close, else the region under it.+ pub fn hit(&self, p: Point, piece_tol: Option<f64>) -> Option<Hit> {+ self.piece_hit(p, piece_tol).or_else(|| self.region_at(p).map(Hit::Region))+ }++ /// The line piece or edge within `piece_tol` of `p` that [`Self::hit`] gives (None without+ /// `piece_tol`).+ fn piece_hit(&self, p: Point, piece_tol: Option<f64>) -> Option<Hit> {+ piece_tol.and_then(|t| match (piece_near(&self.lines, p, t), piece_near(&self.edges, p, t)) {+ (Some(l), Some(e)) if e.0 < l.0 => Some(Hit::Edge(e.1)),+ (Some(l), _) => Some(Hit::Line(l.1)),+ (None, e) => e.map(|e| Hit::Edge(e.1)),+ })+ }++ /// The stroke a click at `p` splits with In Merge Mode, Clicking Stroke Splits the Path: the+ /// line piece or edge nearest `p` within `tol` (as [`BuilderMap::hit`] finds it), from the+ /// anchor or crossing point before `p` to the one after it on the path it lies on. `outlines`+ /// are the inputs' outlines as they are drawn (a filled open path without the edge that closes+ /// it in the map). Returns the input's index and the run, going the way the path goes; None+ /// when no piece is that close, when the run is not on the outline as drawn, when it would be a+ /// whole closed subpath, when it is too short to cut out (see [`po::cut_out`]), or when it is+ /// all of the path (a lone line) or leaves no more of it than [`outline_snap`], which leaves+ /// nothing to split off.+ pub fn stroke_at(&self, outlines: &[PathData], p: Point, tol: f64) -> Option<(usize, SubPath)> {+ use kurbo::ParamCurve as _;+ let piece = match self.hit(p, Some(tol))? {+ Hit::Line(i) => self.lines.get(i),+ Hit::Edge(i) => self.edges.get(i),+ Hit::Region(_) => None,+ }?;+ let i = piece.0.key as usize;+ let drawn = outlines.get(i)?;+ let stops: Vec<Point> = drawn.anchors().map(|(.., a)| a.p).collect();+ let snap = outline_snap(drawn);+ let mut run = po::run_around(piece.0.path.subpaths.first()?, &stops, p, snap)?;+ let n = run.segment_count();+ if n == 0 {+ return None;+ }+ let mid = run.segment(n / 2).eval(0.5);+ drawn.nearest(mid).filter(|n| n.4 <= snap)?;+ // A run that cannot be cut out, or that is all of the path (such as a lone line) or all+ // but a speck of it, leaves nothing to split off.+ if !po::cut_out(drawn, &run, false, snap).is_some_and(|rest| rest.length() > snap) {+ return None;+ }+ // Reverse the run when the path's parameter goes down along it.+ let seg = run.segment(n / 2);+ if let (Some(a), Some(b)) = (drawn.nearest(seg.eval(0.25)), drawn.nearest(seg.eval(0.75)))+ && a.0 == b.0+ && (b.1 as f64 + b.2) < (a.1 as f64 + a.2)+ {+ run.reverse();+ }+ Some((i, run))+ }++ /// What a Shape Builder gesture at `p` touches: [`Self::hit`], except that while erasing, a+ /// point in a region that is no more than `2 * piece_tol` across there (see+ /// [`Self::narrow_at`]) touches the region and not the line piece or edge beside it.+ pub fn builder_hit(&self, p: Point, piece_tol: Option<f64>) -> Option<Hit> {+ match (piece_tol, self.piece_hit(p, piece_tol)) {+ (Some(tol), Some(piece)) => Some(match self.region_at(p) {+ Some(r) if self.narrow_at(r, p, tol) => Hit::Region(r),+ _ => piece,+ }),+ (_, piece) => piece.or_else(|| self.region_at(p).map(Hit::Region)),+ }+ }++ /// Is region `r` no more than `2 * tol` across at `p`, measured from a point of its outline+ /// within `tol` of `p`, through `p`, to its outline on the other side? Every point on that line+ /// is then within `tol` of the outline. The points tried are the point of the outline nearest+ /// `p` and each point of a segment where the segment is square to the line to `p`, so a+ /// point near the end of a thin bar measures across the bar from its sides as well as along it+ /// from the end, and splitting a segment in two does not change the answer. False when `p` is+ /// on the outline or more than `tol` from it.+ fn narrow_at(&self, r: usize, p: Point, tol: f64) -> bool {+ use kurbo::{ParamCurve as _, ParamCurveNearest as _};+ let Some((_, bp, _)) = self.regions.get(r) else { return false };+ // Each segment with the parameter, point and distance of its point nearest `p`.+ let near: Vec<(kurbo::PathSeg, f64, Point, f64)> = bp+ .segments()+ .map(|seg| {+ let n = seg.nearest(p, 1e-6);+ (seg, n.t, seg.eval(n.t), n.distance_sq.sqrt())+ })+ .collect();+ if !near.iter().all(|&(.., d)| d.is_finite() && d > 1e-9) {+ return false;+ }+ let closest = near.iter().map(|&(.., d)| d).fold(f64::INFINITY, f64::min);+ // A line from `p` no longer than `2 * tol` only meets segments that close to `p`.+ let reach: Vec<kurbo::PathSeg> = near.iter().filter(|&&(.., d)| d <= 2.0 * tol).map(|&(seg, ..)| seg).collect();+ // A segment's end is its nearest point when the segment turns away from `p` or stops+ // short of the point square to it; there, only the nearest point of all the outline and+ // an end where the segment is square to the line to `p` count.+ let square = |seg: kurbo::PathSeg, t: f64, n: Point| {+ use kurbo::ParamCurveDeriv as _;+ let dir = match seg {+ kurbo::PathSeg::Line(l) => l.p1 - l.p0,+ kurbo::PathSeg::Quad(q) => q.deriv().eval(t).to_vec2(),+ kurbo::PathSeg::Cubic(c) => c.deriv().eval(t).to_vec2(),+ };+ let v = p - n;+ dir.hypot() > 1e-12 && dir.dot(v).abs() <= 1e-6 * dir.hypot() * v.hypot()+ };+ let from =+ |&&(seg, t, n, d): &&(kurbo::PathSeg, f64, Point, f64)| d <= tol && (d == closest || (t > 1e-9 && t < 1.0 - 1e-9) || square(seg, t, n));+ near.iter().filter(from).any(|&(_, _, n, d)| {+ let line = kurbo::Line::new(p, p + (p - n) * ((2.0 * tol - d) / d));+ reach.iter().any(|seg| seg.intersect_line(line).iter().any(|x| x.line_t > 1e-9 && x.line_t <= 1.0))+ })+ }++ /// What a gesture along the polyline `pts` touches, in order: [`Self::hit`] at each vertex and+ /// at the points [`Self::probes`] picks between them, so it touches every region it crosses,+ /// however narrow.+ pub fn hits_along(&self, pts: &[Point], piece_tol: Option<f64>) -> Touched {+ self.along(pts, piece_tol, Self::hit)+ }++ /// What a Shape Builder gesture along the polyline `pts` touches: [`Self::hits_along`] with+ /// [`Self::builder_hit`], so an erasing gesture also touches each region it goes into where the+ /// region is no more than `2 * piece_tol` across.+ pub fn builder_hits_along(&self, pts: &[Point], piece_tol: Option<f64>) -> Touched {+ self.along(pts, piece_tol, Self::builder_hit)+ }++ fn along(&self, pts: &[Point], piece_tol: Option<f64>, hit: fn(&Self, Point, Option<f64>) -> Option<Hit>) -> Touched {+ let mut touched = Touched::default();+ let mut last: Option<Point> = None;+ for &p in pts {+ if let Some(a) = last {+ for q in self.probes(a, p, piece_tol) {+ touched.add(hit(self, q, piece_tol));+ }+ }+ touched.add(hit(self, p, piece_tol));+ last = Some(p);+ }+ touched+ }++ /// The points strictly between `a` and `b`, in order, that [`Self::hits_along`] tests: the+ /// middle of each stretch between two places where the segment crosses a region's outline, and+ /// with `piece_tol` (erasing) those crossings, the places where it crosses a line piece or an+ /// edge, and points `piece_tol / 2` apart (at most 4,000 per segment), so the line pieces and+ /// edges the segment crosses or passes close to are touched too.+ fn probes(&self, a: Point, b: Point, piece_tol: Option<f64>) -> Vec<Point> {+ let len = a.distance(b);+ if !(len.is_finite() && len > 0.0) {+ return vec![];+ }+ let line = kurbo::Line::new(a, b);+ let lb = Rect::from_points(a, b);+ let mut cross: Vec<f64> = vec![];+ for (_, bp, rb) in &self.regions {+ if rb.x0 > lb.x1 || rb.x1 < lb.x0 || rb.y0 > lb.y1 || rb.y1 < lb.y0 {+ continue;+ }+ for seg in bp.segments() {+ cross.extend(seg.intersect_line(line).iter().map(|x| x.line_t));+ }+ }+ cross.retain(|t| t.is_finite() && *t > 0.0 && *t < 1.0);+ cross.sort_by(f64::total_cmp);+ // Crossings closer than this along the segment are one place.+ let gap = 1e-9 / len;+ let mut ts: Vec<f64> = vec![];+ let mut from = 0.0;+ for &t in cross.iter().chain([1.0].iter()) {+ if t - from > gap {+ ts.push((from + t) / 2.0);+ from = t;+ }+ }+ if let Some(tol) = piece_tol {+ ts.extend(cross.iter().copied());+ for (piece, pb) in self.lines.iter().chain(&self.edges) {+ if pb.x0 > lb.x1 || pb.x1 < lb.x0 || pb.y0 > lb.y1 || pb.y1 < lb.y0 {+ continue;+ }+ for seg in piece.path.to_bezpath().segments() {+ ts.extend(seg.intersect_line(line).iter().map(|x| x.line_t).filter(|t| t.is_finite() && *t > 0.0 && *t < 1.0));+ }+ }+ let n = ((len / (tol / 2.0).max(1e-3)).ceil() as usize).min(4000);+ ts.extend((1..n).map(|k| k as f64 / n as f64));+ ts.sort_by(f64::total_cmp);+ }+ ts.into_iter().map(|t| a.lerp(b, t)).collect()+ }++ /// The regions just either side of the middle of `piece` (None: outside every region).+ pub fn sides(&self, piece: &po::Shape) -> [Option<usize>; 2] {+ let Some(sp) = piece.path.subpaths.first() else { return [None; 2] };+ let n = sp.segment_count();+ if n == 0 {+ return [None; 2];+ }+ let c = sp.segment(n / 2);+ use kurbo::{ParamCurve as _, ParamCurveDeriv as _};+ let (m, d) = (c.eval(0.5), c.deriv().eval(0.5).to_vec2());+ let len = d.hypot();+ if !(len.is_finite() && len > 0.0) {+ return [None; 2];+ }+ // A little to each side: inside the faces next to it, which share it exactly.+ let off = d.turn_90() * (0.05f64.min(0.05 * c.p0.distance(c.p3)).max(1e-6) / len);+ [m + off, m - off].map(|q| self.region_at(q))+ }++ /// Does line piece `i` run between two different regions of `regions` (an edge that merging or+ /// deleting them removes)? A piece with the same region on both sides, such as the end of a+ /// line inside a shape, bounds nothing and stays.+ pub fn line_between(&self, i: usize, regions: &[usize]) -> bool {+ self.lines.get(i).is_some_and(|(l, _)| matches!(self.sides(l), [Some(a), Some(b)] if a != b && regions.contains(&a) && regions.contains(&b)))+ }++ /// The edges `touched` deletes: those that bound none of its regions (deleting a region takes+ /// its edges with it, so an erase drag that crosses an edge into a region deletes the region).+ pub fn erased_edges(&self, touched: &Touched) -> Vec<usize> {+ let bounds_one = |(e, _): &(po::Shape, Rect)| self.sides(e).iter().any(|r| r.is_some_and(|r| touched.regions.contains(&r)));+ touched.edges.iter().copied().filter(|&k| self.edges.get(k).is_some_and(|e| !bounds_one(e))).collect()+ }+}++/// The regions, line pieces and edges a Shape Builder gesture has touched, in the order touched.+#[derive(Clone, Debug, Default, PartialEq)]+pub struct Touched {+ pub regions: Vec<usize>,+ pub lines: Vec<usize>,+ pub edges: Vec<usize>,+}++impl Touched {+ pub fn add(&mut self, hit: Option<Hit>) {+ let (list, i) = match hit {+ Some(Hit::Region(i)) => (&mut self.regions, i),+ Some(Hit::Line(i)) => (&mut self.lines, i),+ Some(Hit::Edge(i)) => (&mut self.edges, i),+ None => return,+ };+ if !list.contains(&i) {+ list.push(i);+ }+ }++ /// Adds what `other` touched, in its order.+ pub fn extend(&mut self, other: &Touched) {+ let regions = other.regions.iter().map(|&i| Hit::Region(i));+ for hit in regions.chain(other.lines.iter().map(|&i| Hit::Line(i))).chain(other.edges.iter().map(|&i| Hit::Edge(i))) {+ self.add(Some(hit));+ }+ }++ pub fn is_empty(&self) -> bool {+ self.regions.is_empty() && self.lines.is_empty() && self.edges.is_empty()+ }+}++/// Selected roots sorted back → front in document order.+pub fn sorted_roots(doc: &Document, ids: &[NodeId]) -> Vec<NodeId> {+ let mut v: Vec<(Vec<usize>, NodeId)> = ids.iter().filter_map(|id| doc.index_path(*id).map(|p| (p, *id))).collect();+ v.sort();+ v.dedup_by(|a, b| a.1 == b.1);+ v.into_iter().map(|(_, id)| id).collect()+}++/// Sample points along a polyline every `step` units (always including the vertices).+pub fn sample_polyline(pts: &[Point], step: f64) -> Vec<Point> {+ let mut out = vec![];+ let step = step.max(1e-3);+ for (i, &p) in pts.iter().enumerate() {+ if i > 0 {+ let a = pts[i - 1];+ let n = ((a.distance(p) / step).ceil() as usize).min(4000);+ for k in 1..n {+ out.push(a.lerp(p, k as f64 / n as f64));+ }+ }+ out.push(p);+ }+ out+}++/// Diagonal hatch lines filling `path` (the Shape Builder's grey mesh highlight), `gap` apart.+pub fn hatch(path: &BezPath, gap: f64) -> BezPath {+ let mut out = BezPath::new();+ let b = path.bounding_box();+ if b.width() <= 0.0 || b.height() <= 0.0 {+ return out;+ }+ // Rotate by -45° so the hatch lines become horizontal scanlines.+ let s = std::f64::consts::FRAC_1_SQRT_2;+ let rot = |p: Point| Point::new((p.x + p.y) * s, (p.y - p.x) * s);+ let unrot = |p: Point| Point::new((p.x - p.y) * s, (p.x + p.y) * s);+ let mut edges: Vec<(Point, Point)> = vec![];+ let mut first = Point::ZERO;+ let mut last = Point::ZERO;+ kurbo::flatten(path.iter(), gap.max(1e-3) * 0.1, |el| match el {+ kurbo::PathEl::MoveTo(p) => {+ if last != first {+ edges.push((rot(last), rot(first)));+ }+ first = p;+ last = p;+ }+ kurbo::PathEl::LineTo(p) => {+ edges.push((rot(last), rot(p)));+ last = p;+ }+ kurbo::PathEl::ClosePath => {+ if last != first {+ edges.push((rot(last), rot(first)));+ }+ last = first;+ }+ _ => {}+ });+ if last != first {+ edges.push((rot(last), rot(first)));+ }+ let (mut y0, mut y1) = (f64::INFINITY, f64::NEG_INFINITY);+ for (a, c) in &edges {+ y0 = y0.min(a.y.min(c.y));+ y1 = y1.max(a.y.max(c.y));+ }+ let gap = gap.max((y1 - y0) / 400.0).max(1e-6);+ let mut y = (y0 / gap).floor() * gap + gap * 0.5;+ let mut xs: Vec<f64> = vec![];+ while y < y1 {+ xs.clear();+ for (a, c) in &edges {+ if (a.y <= y) != (c.y <= y) {+ xs.push(a.x + (y - a.y) / (c.y - a.y) * (c.x - a.x));+ }+ }+ xs.sort_by(f64::total_cmp);+ for pair in xs.as_chunks::<2>().0 {+ out.move_to(unrot(Point::new(pair[0], y)));+ out.line_to(unrot(Point::new(pair[1], y)));+ }+ y += gap;+ }+ out+}