mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 08:52:45 +01:00
Merge main into feat/smooth-bridge-many
This commit is contained in:
commit
a0873e4bf1
527 files changed
+42009
-2675
No files matched your search
@@ -129,6 +129,7 @@ Generated-in-code art is original and has no file to list. This covers the defau
|
||||
| `assets/icons/dc-cap-square.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
|
||||
| `assets/icons/dc-center-hide.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
|
||||
| `assets/icons/dc-center-show.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
|
||||
| `assets/icons/dc-circle-points.svg` | VectorCraft contributors | Original work, drawn for VectorCraft (a circle with three dots on its edge) | MIT OR Apache-2.0 | |
|
||||
| `assets/icons/dc-clear.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
|
||||
| `assets/icons/dc-color-guide.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
|
||||
| `assets/icons/dc-contour.svg` | VectorCraft contributors | Original work, drawn for VectorCraft (a solid rounded square inside four corner arcs, its offset outline); not derived from any other application's icon | MIT OR Apache-2.0 | |
|
||||
|
||||
Generated
+16
@@ -1044,6 +1044,20 @@ name = "craft-eps"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=64b181977a0488e4d1e167bc5cc8cfededc2ed4b#64b181977a0488e4d1e167bc5cc8cfededc2ed4b"
|
||||
|
||||
[[package]]
|
||||
name = "craft-font-catalog"
|
||||
version = "0.1.0"
|
||||
source = "git+https://github.com/storytold/craft-libs?rev=23acc704933a9a5619a5cd1cddc9bb1fb5a9b2d3#23acc704933a9a5619a5cd1cddc9bb1fb5a9b2d3"
|
||||
dependencies = [
|
||||
"harfrust 0.13.3",
|
||||
"kurbo 0.13.1",
|
||||
"skrifa 0.47.0",
|
||||
"thiserror 2.0.21",
|
||||
"unicode-bidi",
|
||||
"unicode-segmentation",
|
||||
"windows-registry",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "craft-fonts-build"
|
||||
version = "0.1.0"
|
||||
@@ -6775,6 +6789,7 @@ dependencies = [
|
||||
"craft-stream-codecs",
|
||||
"craft-xml",
|
||||
"crc32fast",
|
||||
"encoding_rs",
|
||||
"flate2",
|
||||
"hayro-ccitt",
|
||||
"heic-rs",
|
||||
@@ -7108,6 +7123,7 @@ dependencies = [
|
||||
name = "vectorcraft-text"
|
||||
version = "0.24.1"
|
||||
dependencies = [
|
||||
"craft-font-catalog",
|
||||
"craft-proof",
|
||||
"harfrust 0.13.3",
|
||||
"icu_segmenter",
|
||||
|
||||
+5
-1
@@ -138,8 +138,10 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
|
||||
- 2026-11-04: New Document: the units chosen in Preset Details now belong to the chosen document, as the pane's options are listed for the selected preset; the chosen card shows them, every other Recent and Saved card keeps the units its document or preset was made in, and the built-in tabs still follow the chosen units, so switching between inches and millimetres no longer restyles every recent template. Scores and estimates unchanged.
|
||||
- 2026-11-14: Packaging Tools add-on (Object › Plug-ins › Packaging Tools): fold line roles for dielines (Cut, Crease, Partial Cut, Perforation), each carried by the swatch on a path's top stroke through a per-document role table that native files keep; PDF prints a role line on its swatch's separation when that swatch is a spot color, as the default role swatches are, and SVG, DXF and HP-GL keep the stroke's color. Make Cut Line, Make Crease Line, Make Partial Cut Line and Make Perforation Line give the selected paths a role, overprinting by default, and make a missing role swatch; the Fold Lines panel counts each role in the selection or the document, and its Role Swatches… picks another swatch for a role (`addon.packaging.setRole`, `addon.packaging.roles`, `addon.packaging.setRoleSwatch`). A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-11-16: Check Fold Lines in the Packaging Tools add-on (Object › Plug-ins › Packaging Tools, and the Fold Lines panel's Check button): the fold lines of the selection or the document are split into blanks, panels and hinges (cut lines bound the material, and creases, partial cuts and perforations divide it into panels), and 15 kinds of issue are listed, errors and warnings, each naming its lines: cut lines that enclose nothing or end loose, gaps closed within a tolerance, a cut on top of a crease, duplicate lines, creases that end inside a panel, divide nothing, lie outside the blank or are not straight, gaps too narrow to map, fold lines in a hole, panels joined by no crease, and fold lines on a non-printing layer. The panel lists the issues in the interface language; clicking one selects its lines (`addon.packaging.check`). A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-11-16: Fold Preview in the Packaging Tools add-on (Object › Plug-ins › Packaging Tools, and the Fold Lines panel's Fold Preview button): a window that folds the document's blank into its 3D shape about its largest panel, or the panel double-clicked, with the printed art on the outside of each panel (fold lines and non-printing layers left out, unless Show Fold Lines is on) and the board's inside color on the back. Creases and perforations fold 90° away from the print and partial cuts 90° toward it; a Fold slider goes from flat to folded, and the view turns by dragging and the arrow keys, zooms, moves and takes a perspective and seven view presets. The status line says when a joint does not close or two panels pass through each other (`addon.packaging.fold`, `ui.foldPreview`). A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-11-02: Mouse wheel over a closed font-family field in Character, Properties or Control changes selected text through the family list using saved font filters (excluding search text), one undo step per notch, stopping at the ends (#5253). Scores and estimates unchanged.
|
||||
- 2026-11-15: Circle through three points: three Shift-clicks with the Ellipse tool, or `shape.circleThroughPoints` with three points or three selected anchor points, draw the circle whose edge passes through them, with the current paint, in one undo step; after two points the tool previews the circle through the pointer, and two points that are the same or three on one line are refused with a message. Scores and estimates unchanged.
|
||||
- 2026-11-17: Circle tool (after the Ellipse tool in its group): two clicks or a drag draw the circle on that diameter, and a click followed by a drag from a second point to a third draws the circle through the three; Shift keeps the diameter at 45° steps, Alt rounds a two-point circle's diameter to the rulers' ticks at the current zoom, points snap to Smart Guides, and the tool shows the circle, its center, its radii and its diameter until the release, or "Circle too large" for points on one line or a circle past the canvas. `shape.circleThroughPoints` also takes two points or two selected anchor points as the ends of a diameter. One undo step per circle. A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-10-31: Pattern libraries: Window › Swatch Libraries › Patterns and the Swatches panel's library menu open Geometric Patterns, a built-in library of eleven pattern swatches (dots, stripes, checks, a grid and shapes); clicking one adds its pattern and swatch to the document, once, and applies it to the active fill or stroke (`swatch.library.add`).
|
||||
- 2026-11-11: Pattern libraries: Patterns › Grit Textures, a second built-in pattern library, holds eight seamless black textures (Fine Grain, Coarse Grit, Sand, Speckle, Stipple, Scratches, Sparse Flecks and Dense Flecks) on tiles of 18 to 36 pt, each drawn the same way every time; marks that reach past a tile edge continue on the next tile, so the tiles join without a seam (`swatch.library.add`). Scores and estimates unchanged.
|
||||
- 2026-11-11: Pattern libraries: Patterns › Optical Effects, a third built-in pattern library, of VectorCraft's own designs, holds eight black wave, moiré and op-art tiles (Sine Bands, Ripple Lines, Interference Rings, Offset Rings, Warped Checks, Pinched Stripes, Chevron Pulse and Radiating Lenses) of 32 to 48 pt, each drawn the same way every time; each tile is one period of its design, and art that reaches past a tile edge continues on the next tile, so the tiles join without a seam (`swatch.library.add`). Scores and estimates unchanged.
|
||||
@@ -152,8 +154,10 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
|
||||
- 2026-11-01: Document Tools, a built-in add-on (Object › Plug-ins › Document Tools), starts with Save a Timestamped Copy: a copy of the document named `<name>_YYYY-MM-DD_HH-MM` (UTC; `-2`, `-3`… when that name is taken) goes next to it, or into a folder picked for a document never saved, written as File › Save a Copy writes it, so the document keeps its path, title and modified state. Off on the web, which has no clock. A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-11-01: Divide into Dashes joins the Path Precision Tools add-on (Object › Plug-ins › Path Precision Tools): the selected paths, or only their direct-selected segments, are cut into separate open paths of a dash length measured along the curve, with an optional gap (left empty, or kept as pieces), each keeping the path's appearance; Fit to Corners and Ends stretches or squeezes the lengths so every run starts and ends on a dash. A dialog with Preview, one undo step, at most 100000 pieces. A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-11-15: Common Tangents in the Path Precision Tools add-on (Object › Plug-ins › Path Precision Tools): the straight lines that touch two selected convex closed paths (ellipses at any rotation and scale, or convex Bézier paths) without crossing either are added as open paths with the current stroke: external, internal or all, and the line joining the centers if asked; a path inside the other has none unless the two touch, and a message says why; a dialog with Preview, one undo step (`addon.pathtools.commonTangents`, #7845). A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-11-18: Common Tangents also takes a point (a path of one anchor) and a convex closed path: the lines from the point that touch the path, and the line from the point to the path's center if asked; a point on the outline gets the one tangent there, and a point inside gets none, with a message (#7846). A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-11-15: With Smart Guides and Snap to Tangent on, a Line Segment drag pressed on one convex curved path and dragged near another lands on a common tangent of the two: both ends move to where the line touches the paths, each labeled "tangent" (#7845). A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-11-15: Smooth Bridge joins the Path Precision Tools add-on (Object › Plug-ins › Path Precision Tools): two selected circles become one closed outline joined by two concave arcs that touch both circles, so every anchor is smooth; the arcs' radius is a percentage of the smaller circle's radius (1 to 1000%, 100% by default), or with Constant Gap the smaller circle's radius plus a gap, and Keep Originals adds the outline above the circles instead of replacing them. With three or more circles, every two whose outlines are within Reach (10 pt by default) are joined, the bridges that connect become one shape each, and a circle bridged to no other stays as it is (at most 2000 circles). A dialog with Preview, one undo step (`addon.pathtools.bridge`). A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-11-15: Smooth Bridge joins the Path Precision Tools add-on (Object › Plug-ins › Path Precision Tools): two selected circles become one closed outline joined by two concave arcs that touch both circles, so every anchor is smooth; the arcs' radius is a percentage of the smaller circle's radius (1 to 1000%, 100% by default), and Keep Originals adds the outline above the circles instead of replacing them. A dialog with Preview, one undo step (`addon.pathtools.bridge`). A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-11-18: Smooth Bridge also joins three or more circles: every two whose outlines are within Reach (10 pt by default) are joined, the bridges that connect become one shape each, and a circle bridged to no other stays as it is (at most 2000 circles); with Constant Gap the arcs' radius is the smaller circle's radius plus a gap (#8030). A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-11-03: Text Tweaker, the first tool of the Type Tools add-on (Object › Plug-ins › Type Tools): one character attribute (size, baseline shift, rotation, horizontal or vertical scale, tracking, leading or stroke weight) goes letter by letter from a start value to an end value along a straight ramp, an ease, a bow, a spike or at random with a seed, set as the Character panel sets it, while the text stays live; a dialog with Preview, one undo step (`addon.type.textTweaker`, #4924). A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-11-01: Group Overlapping Objects joins the Arrange Tools add-on (Object › Plug-ins › Arrange Tools): the selected objects whose visual bounds overlap or touch, chains included, go into one group each, within their own layer or group, at the stacking place of their frontmost member; objects that overlap nothing stay as they are. One undo step, a sweep along x so thousands of loose pieces group quickly (at most 20000 objects). A VectorCraft addition: headline numbers unchanged.
|
||||
- 2026-10-31: Export for Screens works as the reference app's dialog: Artboards and Assets tabs with a grid or list of thumbnails, Clear Selection and Prefix, Create Sub-folders by Scale or Format (on by default), Export PDFs As Single File (the chosen artboards as one PDF's pages, `pdfs: "single"`) or Multiple Files, iOS and Android rows, format presets in a ☰ menu, and a count of the files the export writes (#4895). About 55 community PRs and fixes landed the same day: Find Font, Replace Font, Outline Stroke and Expand leave hidden and locked art alone (with a warning); DXF export writes LINE and ELLIPSE entities and outlines only the strokes a CAD line can't draw; Blob Brush Angle and Roundness; Shift-constrained Perspective Selection; Grid Repeat Options Preview; a gradient mesh from a file budgeted at about a million quads; width-profile strokes keep their shape zoomed out; `.ai`/EPS import fidelity (area type, envelopes, transparency in dictionaries, character styles); PDF import finds hyphenated and CMap-suffixed font names; Windows renders follow the process's core affinity; Enter or Escape in a floating panel's field no longer reaches the canvas (#4803); Properties shows Blend Options for any selected blend (#4817); Artwork Cleanup finds doubled type (#4835) and joins stacked lines into one object (Join Point Text, #4826). Headline numbers unchanged.
|
||||
|
||||
@@ -142,7 +142,7 @@ fn send(method: &str, params: Value) -> Pin<Box<dyn Future<Output = Value>>> {
|
||||
})
|
||||
}
|
||||
|
||||
async fn sleep(ms: i32) {
|
||||
pub(crate) async fn sleep(ms: i32) {
|
||||
let promise = js_sys::Promise::new(&mut |resolve, _| {
|
||||
if let Some(window) = web_sys::window() {
|
||||
let _ = window.set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, ms);
|
||||
|
||||
@@ -0,0 +1,139 @@
|
||||
//! Which `demand` web faces (`crates/text/web-fonts.txt`) to fetch: each face is fetched at most
|
||||
//! once at a time and never again once it loaded. A face whose fetch failed is fetched again after
|
||||
//! a wait that doubles with each failure, and not after [`MAX_TRIES`] failures.
|
||||
|
||||
/// The wait after a face's first failed fetch before it is fetched again (ms).
|
||||
const RETRY_MS: i32 = 30_000;
|
||||
/// Failed fetches of a face after which it is not fetched again this session.
|
||||
pub(crate) const MAX_TRIES: u32 = 5;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
enum State {
|
||||
Idle,
|
||||
/// Being fetched, after `tries` failed fetches.
|
||||
Loading {
|
||||
tries: u32,
|
||||
},
|
||||
Loaded,
|
||||
/// `tries` fetches failed, the last at `failed_at` (ms); the next may start at `retry_at`, or
|
||||
/// at once when the clock reads earlier than `failed_at`.
|
||||
Failed {
|
||||
tries: u32,
|
||||
failed_at: f64,
|
||||
retry_at: f64,
|
||||
},
|
||||
}
|
||||
|
||||
/// The fetch state of each face of a web font list, by index.
|
||||
#[derive(Debug, Default)]
|
||||
pub(crate) struct Demand {
|
||||
states: Vec<State>,
|
||||
}
|
||||
|
||||
impl Demand {
|
||||
/// Of the faces `wanted` (indexes into the list), the ones to fetch at time `now` (ms): not
|
||||
/// loaded, not being fetched, and not waiting to be fetched again. They are marked as being
|
||||
/// fetched.
|
||||
pub(crate) fn start(&mut self, wanted: &[usize], now: f64) -> Vec<usize> {
|
||||
let mut out = Vec::new();
|
||||
for &i in wanted {
|
||||
if self.states.len() <= i {
|
||||
self.states.resize(i + 1, State::Idle);
|
||||
}
|
||||
let Some(state) = self.states.get_mut(i) else { continue };
|
||||
let tries = match *state {
|
||||
State::Idle => Some(0),
|
||||
State::Loading { .. } | State::Loaded => None,
|
||||
State::Failed { tries, failed_at, retry_at } => (tries < MAX_TRIES && (now >= retry_at || now < failed_at)).then_some(tries),
|
||||
};
|
||||
if let Some(tries) = tries {
|
||||
*state = State::Loading { tries };
|
||||
out.push(i);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The fetch of face `i` started by [`Demand::start`] ended at `now` (ms): loaded when `ok`.
|
||||
/// Returns the wait (ms) after which a failed face may be fetched again, or `None` when it
|
||||
/// loaded or has failed [`MAX_TRIES`] times.
|
||||
pub(crate) fn finished(&mut self, i: usize, ok: bool, now: f64) -> Option<i32> {
|
||||
let state = self.states.get_mut(i)?;
|
||||
let State::Loading { tries } = *state else { return None };
|
||||
if ok {
|
||||
*state = State::Loaded;
|
||||
return None;
|
||||
}
|
||||
let tries = tries + 1;
|
||||
let wait = RETRY_MS << (tries - 1).min(4);
|
||||
*state = State::Failed { tries, failed_at: now, retry_at: now + f64::from(wait) };
|
||||
(tries < MAX_TRIES).then_some(wait)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn a_face_is_fetched_once_and_kept() {
|
||||
let mut d = Demand::default();
|
||||
assert_eq!(d.start(&[2], 0.0), [2]);
|
||||
assert!(d.start(&[2], 1.0).is_empty(), "already being fetched");
|
||||
assert_eq!(d.finished(2, true, 2.0), None, "loaded: no retry");
|
||||
assert!(d.start(&[2], 1e9).is_empty(), "loaded: never fetched again");
|
||||
assert_eq!(d.start(&[0, 2, 1], 3.0), [0, 1], "other faces start on their own");
|
||||
assert_eq!(d.finished(7, false, 4.0), None, "a face never started");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failed_face_waits_longer_after_each_failure_and_then_stops() {
|
||||
let mut d = Demand::default();
|
||||
let mut now = 0.0;
|
||||
// The wait after the 1st, 2nd, ... failure: doubling, up to 16 times the first.
|
||||
for wait in [1, 2, 4, 8].map(|k| k * RETRY_MS) {
|
||||
assert_eq!(d.start(&[0], now), [0], "at {now}");
|
||||
assert_eq!(d.finished(0, false, now), Some(wait), "the wait after the failure at {now}");
|
||||
assert!(d.start(&[0], now + f64::from(wait) - 1.0).is_empty(), "waits {wait} ms after the failure at {now}");
|
||||
now += f64::from(wait);
|
||||
}
|
||||
// The fifth fetch, and after it fails, none.
|
||||
assert_eq!(d.start(&[0], now), [0]);
|
||||
assert_eq!(d.finished(0, false, now), None, "no retry after {MAX_TRIES} failures");
|
||||
assert!(d.start(&[0], now + 1e12).is_empty(), "no fetch after {MAX_TRIES} failures");
|
||||
// A later success after failures keeps the face.
|
||||
let mut d = Demand::default();
|
||||
d.start(&[1], 0.0);
|
||||
assert_eq!(d.finished(1, false, 0.0), Some(RETRY_MS));
|
||||
assert_eq!(d.start(&[1], f64::from(RETRY_MS)), [1]);
|
||||
assert_eq!(d.finished(1, true, f64::from(RETRY_MS)), None);
|
||||
assert!(d.start(&[1], 1e12).is_empty());
|
||||
}
|
||||
|
||||
/// While a face is fetched again after a failure, neither the interface asking for its script
|
||||
/// again nor the retry timer starts a second fetch of it.
|
||||
#[test]
|
||||
fn a_face_being_fetched_again_is_not_fetched_twice_at_once() {
|
||||
let mut d = Demand::default();
|
||||
d.start(&[0], 0.0);
|
||||
assert_eq!(d.finished(0, false, 0.0), Some(RETRY_MS));
|
||||
let retry = f64::from(RETRY_MS);
|
||||
assert_eq!(d.start(&[0, 0], retry), [0], "one fetch for a face wanted twice");
|
||||
assert!(d.start(&[0], retry + 1.0).is_empty(), "the interface asking again");
|
||||
assert!(d.start(&[0], retry + 1_000.0).is_empty(), "the retry timer");
|
||||
assert_eq!(d.finished(0, true, retry + 2_000.0), None);
|
||||
assert!(d.start(&[0], 1e12).is_empty(), "loaded");
|
||||
}
|
||||
|
||||
/// A clock that reads earlier than the failure (one set back meanwhile) does not hold the
|
||||
/// retry back: the timer that asks for it has waited already.
|
||||
#[test]
|
||||
fn a_clock_set_back_after_a_failure_does_not_stop_the_retry() {
|
||||
let mut d = Demand::default();
|
||||
let failed_at = 1e12;
|
||||
d.start(&[0], failed_at);
|
||||
assert_eq!(d.finished(0, false, failed_at), Some(RETRY_MS));
|
||||
assert!(d.start(&[0], failed_at + 1.0).is_empty(), "still waiting");
|
||||
assert_eq!(d.start(&[0], failed_at - 3_600_000.0), [0], "the clock went back an hour");
|
||||
}
|
||||
}
|
||||
@@ -1,17 +1,22 @@
|
||||
//! Craft-fonts faces served beside the wasm (`fonts/<sha16>/…`, copied by
|
||||
//! `cargo xtask web-fonts`) instead of embedded: [`load_startup_fonts`] fetches the `startup`
|
||||
//! ones before the app starts, [`spawn_background_fonts`] the rest once it runs. The browser checks
|
||||
//! each file against its SHA-256 (Subresource Integrity). A face that fails is logged and skipped:
|
||||
//! the app runs without it. With `WEB_FONTS` empty (built without craft-fonts) both do nothing.
|
||||
//! ones before the app starts, [`spawn_background_fonts`] the `background` ones once it runs, and
|
||||
//! [`want_chars`] a `demand` face (Korean, Devanagari) when the interface language or the
|
||||
//! interface's own text needs its script. The browser checks each file against its SHA-256
|
||||
//! (Subresource Integrity). A face that fails is logged and skipped: the app runs without it. With
|
||||
//! `WEB_FONTS` empty (built without craft-fonts) these do nothing.
|
||||
|
||||
use std::cell::Cell;
|
||||
use std::cell::{Cell, RefCell};
|
||||
use std::rc::Rc;
|
||||
|
||||
use vectorcraft_text::craft_fonts::demand_fonts;
|
||||
use vectorcraft_text::{FontDb, WEB_FONTS, WebFont};
|
||||
use wasm_bindgen::JsCast as _;
|
||||
use wasm_bindgen::closure::Closure;
|
||||
use wasm_bindgen_futures::JsFuture;
|
||||
|
||||
use crate::demand::Demand;
|
||||
|
||||
/// Per startup face: the page shows its loading text meanwhile.
|
||||
const STARTUP_TIMEOUT_MS: i32 = 20_000;
|
||||
/// Per background face.
|
||||
@@ -22,12 +27,49 @@ const BACKGROUND_PARALLEL: usize = 4;
|
||||
thread_local! {
|
||||
/// The background fetch runs once per page, though a graphics restart creates the app again.
|
||||
static BACKGROUND_STARTED: Cell<bool> = const { Cell::new(false) };
|
||||
/// The `demand` faces' fetches.
|
||||
static DEMAND: RefCell<Demand> = RefCell::new(Demand::default());
|
||||
/// The running app's context, asked for a frame when a `demand` face arrives (none before the
|
||||
/// app starts: its first frame looks through the faces loaded by then).
|
||||
static REPAINT: RefCell<Option<egui::Context>> = const { RefCell::new(None) };
|
||||
}
|
||||
|
||||
/// Fetch, in the background, the `demand` faces for the scripts of `chars` that are not loaded or
|
||||
/// being fetched. Each one that arrives asks the app for a frame, and the interface draws those
|
||||
/// characters with it from then on. Set as the interface's missing-glyph handler
|
||||
/// (`vectorcraft_ui_egui::on_missing_glyphs`), and called with the interface language's name
|
||||
/// before the app starts.
|
||||
pub fn want_chars(chars: &[char]) {
|
||||
let wanted = demand_fonts(WEB_FONTS, chars.iter().copied());
|
||||
if !wanted.is_empty() {
|
||||
fetch_demand(&wanted);
|
||||
}
|
||||
}
|
||||
|
||||
/// Fetch the `demand` faces `wanted` (indexes into `WEB_FONTS`) that [`Demand::start`] lets start.
|
||||
/// A face whose fetch fails is fetched again after the wait [`Demand::finished`] gives.
|
||||
fn fetch_demand(wanted: &[usize]) {
|
||||
for i in DEMAND.with(|d| d.borrow_mut().start(wanted, vectorcraft_ui_egui::now_ms())) {
|
||||
let Some(f) = WEB_FONTS.get(i) else { continue };
|
||||
wasm_bindgen_futures::spawn_local(async move {
|
||||
let ok = load(f, BACKGROUND_TIMEOUT_MS).await;
|
||||
let retry = DEMAND.with(|d| d.borrow_mut().finished(i, ok, vectorcraft_ui_egui::now_ms()));
|
||||
if ok && let Some(ctx) = REPAINT.with(|r| r.borrow().clone()) {
|
||||
ctx.request_repaint();
|
||||
}
|
||||
if let Some(wait) = retry {
|
||||
// A second longer, so a clock the browser coarsens still reads the wait as over.
|
||||
crate::api::sleep(wait.saturating_add(1_000)).await;
|
||||
fetch_demand(&[i]);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/// Fetch and register the `startup` faces (one after the other). Returns how many loaded.
|
||||
pub async fn load_startup_fonts() -> usize {
|
||||
let mut loaded = 0;
|
||||
for f in WEB_FONTS.iter().filter(|f| f.startup) {
|
||||
for f in WEB_FONTS.iter().filter(|f| f.startup && !f.demand) {
|
||||
if load(f, STARTUP_TIMEOUT_MS).await {
|
||||
loaded += 1;
|
||||
}
|
||||
@@ -36,13 +78,14 @@ pub async fn load_startup_fonts() -> usize {
|
||||
}
|
||||
|
||||
/// Fetch and register the `background` faces, [`BACKGROUND_PARALLEL`] at a time, asking `ctx` for
|
||||
/// a frame after each so the font menus and the canvas pick it up. Only the first call does
|
||||
/// anything.
|
||||
/// a frame after each so the font menus and the canvas pick it up. Only the first call fetches
|
||||
/// anything; each call makes `ctx` the context a `demand` face asks for a frame.
|
||||
pub fn spawn_background_fonts(ctx: egui::Context) {
|
||||
REPAINT.with(|r| *r.borrow_mut() = Some(ctx.clone()));
|
||||
if BACKGROUND_STARTED.with(|s| s.replace(true)) {
|
||||
return;
|
||||
}
|
||||
let queue: Rc<Vec<&'static WebFont>> = Rc::new(WEB_FONTS.iter().filter(|f| !f.startup).collect());
|
||||
let queue: Rc<Vec<&'static WebFont>> = Rc::new(WEB_FONTS.iter().filter(|f| !f.startup && !f.demand).collect());
|
||||
let next = Rc::new(Cell::new(0usize));
|
||||
for _ in 0..BACKGROUND_PARALLEL.min(queue.len()) {
|
||||
let (queue, next, ctx) = (queue.clone(), next.clone(), ctx.clone());
|
||||
|
||||
@@ -21,6 +21,8 @@
|
||||
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
mod api;
|
||||
#[cfg(any(target_arch = "wasm32", test))]
|
||||
mod demand;
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
mod fonts;
|
||||
#[cfg(any(target_arch = "wasm32", test))]
|
||||
|
||||
@@ -81,6 +81,11 @@ pub fn start() {
|
||||
return;
|
||||
};
|
||||
detect_language();
|
||||
// The face for a Korean or Hindi browser language (or `?lang=`) starts loading now, beside the
|
||||
// startup fonts, without holding up the start. Text in those scripts painted later (a saved
|
||||
// interface language, another one chosen, a layer or file name) has its face fetched then.
|
||||
vectorcraft_ui_egui::on_missing_glyphs(crate::fonts::want_chars);
|
||||
crate::fonts::want_chars(&i18n::system_lang().name().chars().collect::<Vec<_>>());
|
||||
wasm_bindgen_futures::spawn_local(async move {
|
||||
// Before the first frame, which looks for copies a crash left behind.
|
||||
let locks = WebLocks::start(RECOVERY_PREFIX).await;
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
//! - macOS: the window's layer is tagged sRGB and macOS converts it (`mac_color_space`).
|
||||
//!
|
||||
//! While the preference is on, a background thread reads the display every [`EVERY`] seconds,
|
||||
//! and at once when the window moves to another display.
|
||||
//! and at once when the window moves to another display or Edit › Refresh Monitor Profile asks.
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
@@ -31,6 +31,8 @@ pub(crate) struct Reader {
|
||||
looked: Option<f64>,
|
||||
/// A reading is running.
|
||||
busy: Arc<AtomicBool>,
|
||||
/// [`DisplayProfile::attach_reader`] was called.
|
||||
attached: bool,
|
||||
}
|
||||
|
||||
/// Clears [`Reader::busy`] when the reading thread ends, also by a panic.
|
||||
@@ -45,22 +47,22 @@ impl Drop for Done {
|
||||
impl Reader {
|
||||
/// Starts a reading when one is due and none is running. `now` is the frame's time in seconds.
|
||||
pub(crate) fn tick(&mut self, window: &winit::window::Window, now: f64, enabled: bool, profile: &DisplayProfile, ctx: &egui::Context) {
|
||||
if !enabled || self.busy.load(Ordering::Acquire) || self.looked.is_some_and(|at| (at..at + LOOK_EVERY).contains(&now)) {
|
||||
return;
|
||||
if !self.attached {
|
||||
profile.attach_reader();
|
||||
self.attached = true;
|
||||
}
|
||||
self.looked = Some(now);
|
||||
let display = window.current_monitor().and_then(|m| m.name());
|
||||
if !due(self.last.as_ref(), now, display.as_deref()) {
|
||||
let Some(display) = self.start(now, enabled, profile, || window.current_monitor().and_then(|m| m.name())) else {
|
||||
return;
|
||||
}
|
||||
self.last = Some((now, display.clone()));
|
||||
};
|
||||
profile.pending();
|
||||
self.busy.store(true, Ordering::Release);
|
||||
let done = Done(self.busy.clone());
|
||||
let (profile, ctx) = (profile.clone(), ctx.clone());
|
||||
let spawned = std::thread::Builder::new().name("display profile".into()).spawn(move || {
|
||||
let _done = done;
|
||||
if profile.report(read(display)) {
|
||||
let changed = profile.report(read(display));
|
||||
drop(done);
|
||||
// A request made while this reading ran starts on the next frame.
|
||||
if changed || profile.read_requested() {
|
||||
ctx.request_repaint();
|
||||
}
|
||||
});
|
||||
@@ -68,6 +70,32 @@ impl Reader {
|
||||
log::warn!("couldn't start reading the display profile: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The display to read at `now` when a reading is to start, looked up with `display`. A
|
||||
/// request from Refresh Monitor Profile ([`DisplayProfile::request_read`]) starts one at once,
|
||||
/// past [`EVERY`] and [`LOOK_EVERY`]; while a reading runs it waits, and a frame that finds the
|
||||
/// preference off drops it. A request made with the preference on is kept when the preference
|
||||
/// goes off and on again between two frames.
|
||||
fn start(&mut self, now: f64, enabled: bool, profile: &DisplayProfile, display: impl FnOnce() -> Option<String>) -> Option<Option<String>> {
|
||||
if !enabled {
|
||||
profile.take_request();
|
||||
return None;
|
||||
}
|
||||
if self.busy.load(Ordering::Acquire) {
|
||||
return None;
|
||||
}
|
||||
let asked = profile.take_request();
|
||||
if !asked && self.looked.is_some_and(|at| (at..at + LOOK_EVERY).contains(&now)) {
|
||||
return None;
|
||||
}
|
||||
self.looked = Some(now);
|
||||
let display = display();
|
||||
if !asked && !due(self.last.as_ref(), now, display.as_deref()) {
|
||||
return None;
|
||||
}
|
||||
self.last = Some((now, display.clone()));
|
||||
Some(display)
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether a reading of `display` is due at `now`, after the last one (`last`): none yet, another
|
||||
@@ -570,6 +598,56 @@ mod tests {
|
||||
assert!(due(Some(&last), 50.0, Some("DP-1")));
|
||||
}
|
||||
|
||||
fn attached() -> DisplayProfile {
|
||||
let profile = DisplayProfile::default();
|
||||
profile.attach_reader();
|
||||
profile
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_requested_reading_starts_on_the_next_frame_past_both_intervals() {
|
||||
let (mut r, profile) = (Reader::default(), attached());
|
||||
let dp1 = || Some("DP-1".to_string());
|
||||
assert_eq!(r.start(100.0, true, &profile, dp1), Some(Some("DP-1".into())));
|
||||
// Inside the display lookup interval and the reading interval: nothing starts.
|
||||
assert_eq!(r.start(100.5, true, &profile, || panic!("not looked up")), None);
|
||||
assert_eq!(r.start(102.0, true, &profile, dp1), None);
|
||||
profile.request_read(true).unwrap();
|
||||
assert_eq!(r.start(102.1, true, &profile, dp1), Some(Some("DP-1".into())));
|
||||
assert!(!profile.read_requested(), "the request is taken");
|
||||
// The intervals run again from the requested reading.
|
||||
assert_eq!(r.start(102.2, true, &profile, dp1), None);
|
||||
assert_eq!(r.start(111.0, true, &profile, dp1), None);
|
||||
assert_eq!(r.start(113.0, true, &profile, dp1), Some(Some("DP-1".into())));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_request_made_while_a_reading_runs_waits_for_it_to_end() {
|
||||
let (mut r, profile) = (Reader::default(), attached());
|
||||
let dp1 = || Some("DP-1".to_string());
|
||||
assert!(r.start(0.0, true, &profile, dp1).is_some());
|
||||
r.busy.store(true, Ordering::Release);
|
||||
profile.request_read(true).unwrap();
|
||||
assert_eq!(r.start(0.1, true, &profile, dp1), None);
|
||||
assert_eq!(r.start(5.0, true, &profile, dp1), None);
|
||||
assert!(profile.read_requested(), "kept while the reading runs");
|
||||
r.busy.store(false, Ordering::Release);
|
||||
assert_eq!(r.start(5.1, true, &profile, dp1), Some(Some("DP-1".into())));
|
||||
assert!(!profile.read_requested());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_request_is_dropped_when_the_preference_goes_off() {
|
||||
let (mut r, profile) = (Reader::default(), attached());
|
||||
let dp1 = || Some("DP-1".to_string());
|
||||
assert!(r.start(0.0, true, &profile, dp1).is_some());
|
||||
profile.request_read(true).unwrap();
|
||||
assert_eq!(r.start(0.1, false, &profile, dp1), None);
|
||||
assert!(!profile.read_requested());
|
||||
assert_eq!(r.start(0.2, true, &profile, dp1), None, "no reading starts later for it");
|
||||
assert!(profile.request_read(false).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wayland_sessions_are_told_apart_from_x11_by_the_environment() {
|
||||
let env = |pairs: &'static [(&'static str, &'static str)]| {
|
||||
|
||||
@@ -96,7 +96,24 @@ fn dialog_for<D: DialogSettings>(d: D, request: &PickRequest) -> D {
|
||||
Some(folder) => d.folder(folder),
|
||||
None => d,
|
||||
};
|
||||
if pick.name.is_empty() { d } else { d.file_name(&pick.name) }
|
||||
if pick.name.is_empty() {
|
||||
return d;
|
||||
}
|
||||
// Windows' save dialog changes the extension when a different file type is chosen only when
|
||||
// the suggested name has no explicit extension. rfd supplies the first filter's extension to
|
||||
// that dialog, so leave the suffix to Windows for saves that offer several formats (#5451).
|
||||
// A remaining dot in the stem would look like another explicit extension to Windows.
|
||||
#[cfg(windows)]
|
||||
if matches!(request, PickRequest::Save(_))
|
||||
&& pick.filters.len() > 1
|
||||
&& let Some(ext) = std::path::Path::new(&pick.name).extension().and_then(|e| e.to_str())
|
||||
&& pick.filters.iter().any(|(_, exts)| exts.iter().any(|e| e.eq_ignore_ascii_case(ext)))
|
||||
&& let Some(stem) = std::path::Path::new(&pick.name).file_stem().and_then(|s| s.to_str())
|
||||
&& !stem.contains('.')
|
||||
{
|
||||
return d.file_name(stem);
|
||||
}
|
||||
d.file_name(&pick.name)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -796,7 +813,7 @@ mod dialog_tests {
|
||||
|
||||
/// The file types a dialog was given, by label.
|
||||
#[derive(Default)]
|
||||
struct Filters(Vec<(String, Vec<String>)>);
|
||||
struct Filters(Vec<(String, Vec<String>)>, Option<String>);
|
||||
|
||||
impl DialogSettings for Filters {
|
||||
fn parent(self, _window: &winit::window::Window) -> Self {
|
||||
@@ -812,7 +829,8 @@ mod dialog_tests {
|
||||
fn folder(self, _folder: &str) -> Self {
|
||||
self
|
||||
}
|
||||
fn file_name(self, _name: &str) -> Self {
|
||||
fn file_name(mut self, name: &str) -> Self {
|
||||
self.1 = Some(name.to_string());
|
||||
self
|
||||
}
|
||||
}
|
||||
@@ -869,4 +887,24 @@ mod dialog_tests {
|
||||
let first = fileio::place_filters().next().map(|(_, exts)| open_extensions(exts, CASE_SENSITIVE_FILTERS));
|
||||
assert_eq!(placed.first().map(|(_, exts)| exts.clone()), first);
|
||||
}
|
||||
|
||||
/// A format selected after the Windows Save As dialog opens can replace the suffix of the
|
||||
/// suggested name. Single-format saves and open dialogs keep the supplied name verbatim.
|
||||
#[cfg(windows)]
|
||||
#[test]
|
||||
fn save_dialog_with_several_formats_leaves_the_extension_to_windows() {
|
||||
let filters = vec![FilePick::filter("VectorCraft", &["vectorcraft"]), FilePick::filter("PDF-compatible .ai", &["ai"])];
|
||||
let pick = FilePick { name: "Poster.vectorcraft".into(), filters: filters.clone(), ..Default::default() };
|
||||
assert_eq!(dialog_for(Filters::default(), &PickRequest::Save(pick.clone())).1.as_deref(), Some("Poster"));
|
||||
assert_eq!(dialog_for(Filters::default(), &PickRequest::Open(pick)).1.as_deref(), Some("Poster.vectorcraft"));
|
||||
|
||||
let pick = FilePick { name: "Poster.AI".into(), filters: filters.clone(), ..Default::default() };
|
||||
assert_eq!(dialog_for(Filters::default(), &PickRequest::Save(pick)).1.as_deref(), Some("Poster"));
|
||||
let pick = FilePick { name: "Poster.design".into(), filters: filters.clone(), ..Default::default() };
|
||||
assert_eq!(dialog_for(Filters::default(), &PickRequest::Save(pick)).1.as_deref(), Some("Poster.design"));
|
||||
let pick = FilePick { name: "draft.v1.vectorcraft".into(), filters: filters.clone(), ..Default::default() };
|
||||
assert_eq!(dialog_for(Filters::default(), &PickRequest::Save(pick)).1.as_deref(), Some("draft.v1.vectorcraft"));
|
||||
let pick = FilePick { name: "Poster.vectorcraft".into(), filters: vec![filters[0].clone()], ..Default::default() };
|
||||
assert_eq!(dialog_for(Filters::default(), &PickRequest::Save(pick)).1.as_deref(), Some("Poster.vectorcraft"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="7.5"/><circle cx="4.5" cy="12" r="1.6" fill="currentColor"/><circle cx="19.5" cy="12" r="1.6" fill="currentColor"/><circle cx="12" cy="4.5" r="1.6" fill="currentColor"/></svg>
|
||||
|
After Width: | Height: | Size: 386 B |
@@ -9,7 +9,6 @@
|
||||
//! the stroke with what the pen recorded on it (`StrokeLayer::pressure`, `tilt`, `bearing` and
|
||||
//! `rotation`): the sweep is sampled densely and each sample takes the nib for the pen there.
|
||||
|
||||
use vectorcraft_color::Paint;
|
||||
use vectorcraft_doc::{Node, StrokeLayer};
|
||||
use vectorcraft_geom::{BezPath, PathData, Point, SubPath, Vec2};
|
||||
|
||||
@@ -198,7 +197,70 @@ fn offset_track(t: &Track, d: f64, trim0: f64, trim1: f64) -> Option<BezPath> {
|
||||
Some(bp)
|
||||
}
|
||||
|
||||
pub(crate) fn bristle(b: &Bristle, bp: &BezPath, weight: f64, paint: &Paint, name: &str) -> Vec<Node> {
|
||||
/// A strand that follows the recorded pen pose. Pressure and tilt change its spread; bearing and
|
||||
/// barrel rotation turn that spread in the path's local frame. Original path corners are included
|
||||
/// in the samples so a turn is not rounded away by the pose sampling interval.
|
||||
fn posed_bristle_track(
|
||||
t: &Track,
|
||||
d: f64,
|
||||
trim0: f64,
|
||||
trim1: f64,
|
||||
size: f64,
|
||||
stroke: &StrokeLayer,
|
||||
varies: bool,
|
||||
) -> Option<(BezPath, Vec<(f64, f64)>)> {
|
||||
let l = t.len();
|
||||
let (s0, s1) = (trim0.clamp(0.0, l), (l - trim1).clamp(0.0, l));
|
||||
if s1 - s0 < 1e-6 {
|
||||
return None;
|
||||
}
|
||||
let steps = if varies { ((s1 - s0) / (size * 0.2).max(0.25)).ceil().clamp(1.0, MAX_STEPS) as usize } else { 1 };
|
||||
let mut positions: Vec<f64> = (0..=steps).map(|i| s0 + (s1 - s0) * i as f64 / steps as f64).collect();
|
||||
positions.extend(t.cum.iter().copied().filter(|&s| s > s0 && s < s1));
|
||||
positions.sort_by(f64::total_cmp);
|
||||
positions.dedup_by(|a, b| (*a - *b).abs() < 1e-6);
|
||||
let mut path = BezPath::new();
|
||||
// Distance along the posed strand -> fraction along the original, untrimmed path.
|
||||
let mut source = Vec::with_capacity(positions.len());
|
||||
let mut previous: Option<Point> = None;
|
||||
let mut distance = 0.0;
|
||||
for (i, s) in positions.into_iter().enumerate() {
|
||||
let pen = PenAt::of(stroke, s / l);
|
||||
let pressure = pen.control(Variation::Pressure).unwrap_or(0.5);
|
||||
let tilt = pen.control(Variation::Tilt).unwrap_or(0.5);
|
||||
let bearing = pen.control(Variation::Bearing).unwrap_or(0.5);
|
||||
let rotation = pen.control(Variation::Rotation).unwrap_or(0.5);
|
||||
let spread = d * (0.5 + pressure) * (1.25 - 0.5 * tilt);
|
||||
let angle = std::f64::consts::TAU * (bearing + rotation - 1.0);
|
||||
let p = t.map(s + spread * angle.sin(), spread * angle.cos());
|
||||
if i == 0 {
|
||||
path.move_to(p)
|
||||
} else {
|
||||
path.line_to(p)
|
||||
}
|
||||
if let Some(previous) = previous {
|
||||
distance += previous.distance(p);
|
||||
}
|
||||
source.push((distance, s / l));
|
||||
previous = Some(p);
|
||||
}
|
||||
Some((path, source))
|
||||
}
|
||||
|
||||
fn source_fraction(source: &[(f64, f64)], distance: f64) -> f64 {
|
||||
let next = source.partition_point(|(d, _)| *d < distance);
|
||||
if next == 0 {
|
||||
return source.first().map_or(0.0, |(_, f)| *f);
|
||||
}
|
||||
if next >= source.len() {
|
||||
return source.last().map_or(1.0, |(_, f)| *f);
|
||||
}
|
||||
let (d0, f0) = source[next - 1];
|
||||
let (d1, f1) = source[next];
|
||||
if d1 - d0 < 1e-9 { f1 } else { f0 + (f1 - f0) * ((distance - d0) / (d1 - d0)) }
|
||||
}
|
||||
|
||||
pub(crate) fn bristle(b: &Bristle, bp: &BezPath, weight: f64, stroke: &StrokeLayer, name: &str) -> Vec<Node> {
|
||||
let mut rng = Rng::new(seed_of(bp, name));
|
||||
let size = b.size.max(0.1) * weight;
|
||||
let strands = (3.0 + b.density.clamp(1.0, 100.0) / 100.0 * 13.0).round() as usize;
|
||||
@@ -210,6 +272,13 @@ pub(crate) fn bristle(b: &Bristle, bp: &BezPath, weight: f64, paint: &Paint, nam
|
||||
let wobble = (100.0 - b.stiffness.clamp(1.0, 100.0)) / 100.0;
|
||||
let ragged = b.length.clamp(25.0, 300.0) / 100.0;
|
||||
let opacity = (b.opacity.clamp(1.0, 100.0) / 100.0) as f32;
|
||||
let posed = stroke.pressure.is_some() || stroke.tilt.is_some() || stroke.bearing.is_some() || stroke.rotation.is_some();
|
||||
let varies = |points: &[(f64, f64)]| points.first().is_some_and(|(_, first)| points.iter().any(|(_, value)| (value - first).abs() > 1e-6));
|
||||
let pressure_varies = stroke.pressure.as_ref().is_some_and(|p| varies(&p.points));
|
||||
let pose_varies = pressure_varies
|
||||
|| stroke.tilt.as_ref().is_some_and(|p| varies(&p.points))
|
||||
|| stroke.bearing.as_ref().is_some_and(|p| varies(&p.points))
|
||||
|| stroke.rotation.as_ref().is_some_and(|p| varies(&p.points));
|
||||
let mut out = vec![];
|
||||
for t in tracks(bp, tolerance(size)) {
|
||||
let l = t.len();
|
||||
@@ -220,14 +289,37 @@ pub(crate) fn bristle(b: &Bristle, bp: &BezPath, weight: f64, paint: &Paint, nam
|
||||
let edge = 1.0 - lane.abs();
|
||||
let trim = |r: &mut Rng| r.unit() * ragged * size * (1.2 - edge) * 0.8;
|
||||
let (t0, t1) = (trim(&mut rng), trim(&mut rng));
|
||||
let Some(sp) = offset_track(&t, off, t0.min(l * 0.3), t1.min(l * 0.3)) else { continue };
|
||||
let (t0, t1) = (t0.min(l * 0.3), t1.min(l * 0.3));
|
||||
let sp = if posed {
|
||||
posed_bristle_track(&t, off, t0, t1, size, stroke, pose_varies)
|
||||
} else {
|
||||
offset_track(&t, off, t0, t1).map(|path| (path, Vec::new()))
|
||||
};
|
||||
let Some((sp, source)) = sp else { continue };
|
||||
let w = thick * (0.6 + 0.4 * edge) * rng.range(0.8, 1.2);
|
||||
let nib = Nib::new(0.0, 1.0, w);
|
||||
let subs: Vec<SubPath> = tracks(&sp, tolerance(w)).iter().flat_map(|tt| sweep(tt, &|_| nib, None)).collect();
|
||||
let subs: Vec<SubPath> = tracks(&sp, tolerance(w))
|
||||
.iter()
|
||||
.flat_map(|tt| {
|
||||
if posed {
|
||||
sweep(
|
||||
tt,
|
||||
&|f| {
|
||||
let original_fraction = source_fraction(&source, f * tt.len());
|
||||
let pressure = PenAt::of(stroke, original_fraction).control(Variation::Pressure).unwrap_or(0.5);
|
||||
Nib::new(0.0, 1.0, w * (0.5 + pressure))
|
||||
},
|
||||
pressure_varies.then_some((tt.len() / MAX_STEPS).max(0.25)),
|
||||
)
|
||||
} else {
|
||||
let nib = Nib::new(0.0, 1.0, w);
|
||||
sweep(tt, &|_| nib, None)
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
if subs.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let mut n = filled(PathData::new(subs), paint);
|
||||
let mut n = filled(PathData::new(subs), &stroke.paint);
|
||||
n.opacity = (opacity * rng.range(0.7, 1.0) as f32).clamp(0.0, 1.0);
|
||||
out.push(n);
|
||||
}
|
||||
|
||||
@@ -97,6 +97,75 @@ pub fn colorize(n: &mut Node, mode: Colorization, stroke: &Paint) {
|
||||
walk(n, mode, key);
|
||||
}
|
||||
|
||||
/// Mixed into a stroke's seed for its hue jitter, so the amounts come from a sequence of their own
|
||||
/// and a copy's size, spacing, scatter and rotation stay as they were without hue jitter.
|
||||
const HUE_JITTER_SALT: u64 = 0x6875_655f_6a69_7474;
|
||||
|
||||
/// Turn the hue of each of `copies` (a scatter brush's copies, in order along the path) by its
|
||||
/// own amount between −`amount` and `amount` degrees, drawn from `seed` (the stroke's
|
||||
/// [`crate::track::seed_of`]).
|
||||
pub(crate) fn jitter_hues(copies: &mut [Node], amount: f64, seed: u64) {
|
||||
let mut rng = crate::track::Rng::new(seed ^ HUE_JITTER_SALT);
|
||||
for n in copies {
|
||||
let turn = rng.range(-amount, amount) as f32;
|
||||
turn_hues(n, turn);
|
||||
}
|
||||
}
|
||||
|
||||
/// `c` with its hue turned by `degrees`, worked out on its own components so nothing else about it
|
||||
/// changes: RGB in HSB of its values, CMYK over C, M and Y with K kept (as
|
||||
/// [`Color::complement_keep_model`] does), Lab by turning a and b. `None` for a color without a hue:
|
||||
/// white, black and grays, in their own model (Gray, CMYK with no C, M or Y ink).
|
||||
fn turned(c: &Color, degrees: f32) -> Option<Color> {
|
||||
if !degrees.is_finite() || vectorcraft_color::recolor::Neutral::of(c).is_some() {
|
||||
return None;
|
||||
}
|
||||
let turn = |v: [f32; 3]| {
|
||||
let [h, s, b] = vectorcraft_color::rgb_to_hsb(v);
|
||||
(s > 0.0).then(|| vectorcraft_color::hsb_to_rgb([(h + degrees).rem_euclid(360.0), s, b]))
|
||||
};
|
||||
match *c {
|
||||
Color::Rgb { r, g, b } => turn([r, g, b]).map(|[r, g, b]| Color::rgb(r, g, b)),
|
||||
Color::Cmyk { c, m, y, k } => turn([1.0 - c, 1.0 - m, 1.0 - y]).map(|[r, g, b]| Color::cmyk(1.0 - r, 1.0 - g, 1.0 - b, k)),
|
||||
Color::Gray { .. } => None,
|
||||
Color::Lab { l, a, b } => {
|
||||
let (sin, cos) = f64::from(degrees).to_radians().sin_cos();
|
||||
let (a, b) = (f64::from(a), f64::from(b));
|
||||
Some(Color::lab(l, (a * cos - b * sin) as f32, (a * sin + b * cos) as f32))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn turn_paint(p: &mut Paint, degrees: f32) {
|
||||
if let Paint::Solid { color, .. } = p
|
||||
&& let Some(c) = turned(color, degrees)
|
||||
{
|
||||
*p = Paint::solid(c);
|
||||
}
|
||||
}
|
||||
|
||||
/// Turn the hue of the solid fills and strokes under `n`, its type's characters included. A
|
||||
/// mask's colors are its values, so they stay.
|
||||
fn turn_hues(n: &mut Node, degrees: f32) {
|
||||
for it in &mut n.appearance.items {
|
||||
match it {
|
||||
AppearanceItem::Fill(f) => turn_paint(&mut f.paint, degrees),
|
||||
AppearanceItem::Stroke(s) => turn_paint(&mut s.paint, degrees),
|
||||
}
|
||||
}
|
||||
if let NodeKind::Text(t) = &mut n.kind {
|
||||
for r in &mut t.runs {
|
||||
turn_paint(&mut r.style.fill, degrees);
|
||||
turn_paint(&mut r.style.stroke, degrees);
|
||||
}
|
||||
}
|
||||
if let Some(ch) = n.children_mut() {
|
||||
for c in ch.iter_mut() {
|
||||
turn_hues(Arc::make_mut(c), degrees);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Strip the brushes from every stroke under `n`, its masks' art included.
|
||||
fn strip_brushes(n: &mut Node) {
|
||||
for it in &mut n.appearance.items {
|
||||
|
||||
@@ -172,6 +172,7 @@ pub fn defaults() -> &'static [Brush] {
|
||||
rotation: (-180.0, 180.0),
|
||||
rotation_relative_to_path: false,
|
||||
colorization: Colorization::Tints,
|
||||
hue_jitter: 0.0,
|
||||
modes: None,
|
||||
}),
|
||||
},
|
||||
@@ -185,6 +186,7 @@ pub fn defaults() -> &'static [Brush] {
|
||||
rotation: (-35.0, 35.0),
|
||||
rotation_relative_to_path: true,
|
||||
colorization: Colorization::None,
|
||||
hue_jitter: 0.0,
|
||||
modes: None,
|
||||
}),
|
||||
},
|
||||
|
||||
+29
-1
@@ -298,6 +298,12 @@ pub struct Scatter {
|
||||
/// Rotation relative to the path direction (else to the page).
|
||||
pub rotation_relative_to_path: bool,
|
||||
pub colorization: Colorization,
|
||||
/// Hue jitter in degrees, 0 to 180: each copy turns the hue of the solid colors it draws, after
|
||||
/// the colorization, by its own amount between −`hue_jitter` and `hue_jitter`. The stroke's
|
||||
/// path and the brush name fix the amounts, so a stroke draws the same colors every time.
|
||||
/// 0 (brushes saved before there was hue jitter) leaves the colors as they are.
|
||||
#[serde(skip_serializing_if = "is_zero")]
|
||||
pub hue_jitter: f64,
|
||||
/// How size, spacing, scatter and rotation vary between their two values: Fixed takes the
|
||||
/// first, Random any value between them, Pressure the first at the lightest pen pressure and
|
||||
/// the second at the heaviest, Tilt the first with the pen lying flat and the second upright,
|
||||
@@ -318,6 +324,7 @@ impl Default for Scatter {
|
||||
rotation: (0.0, 0.0),
|
||||
rotation_relative_to_path: false,
|
||||
colorization: Colorization::None,
|
||||
hue_jitter: 0.0,
|
||||
modes: None,
|
||||
}
|
||||
}
|
||||
@@ -326,6 +333,8 @@ impl Default for Scatter {
|
||||
impl Scatter {
|
||||
/// The ranges of size (%), spacing (%), scatter (%) and rotation (°).
|
||||
pub const RANGES: [(f64, f64); 4] = [(1.0, 10000.0), (1.0, 10000.0), (-1000.0, 1000.0), (-180.0, 180.0)];
|
||||
/// The range of [`Scatter::hue_jitter`] (°).
|
||||
pub const HUE_JITTER_RANGE: (f64, f64) = (0.0, 180.0);
|
||||
|
||||
/// Size, spacing, scatter and rotation, each as its (first, second) values.
|
||||
pub fn values(&self) -> [(f64, f64); 4] {
|
||||
@@ -624,6 +633,10 @@ fn within_pair((a, b): (f64, f64), range: (f64, f64), fallback: f64) -> (f64, f6
|
||||
(within(a, range, fallback), within(b, range, fallback))
|
||||
}
|
||||
|
||||
fn is_zero(v: &f64) -> bool {
|
||||
*v == 0.0
|
||||
}
|
||||
|
||||
fn valid_tile_frame(frame: Rect) -> bool {
|
||||
[frame.x0, frame.y0, frame.x1, frame.y1].into_iter().all(f64::is_finite)
|
||||
&& frame.width().is_finite()
|
||||
@@ -714,6 +727,7 @@ impl Brush {
|
||||
s.spacing = within_pair(s.spacing, spacing, d.spacing.0);
|
||||
s.scatter = within_pair(s.scatter, scatter, 0.0);
|
||||
s.rotation = within_pair(s.rotation, rotation, 0.0);
|
||||
s.hue_jitter = within(s.hue_jitter, Scatter::HUE_JITTER_RANGE, 0.0);
|
||||
s.colorization.sanitize();
|
||||
}
|
||||
BrushKind::Art(a) => {
|
||||
@@ -1084,7 +1098,7 @@ pub fn stroke_pieces(doc: &Document, brush: &Brush, bp: &BezPath, stroke: &Strok
|
||||
let w = if stroke.width > 0.0 { stroke.width } else { 1.0 };
|
||||
let mut out = match &brush.kind {
|
||||
BrushKind::Calligraphic(c) => calli::calligraphic(c, bp, w, stroke, &brush.name),
|
||||
BrushKind::Bristle(b) => calli::bristle(b, bp, w, &stroke.paint, &brush.name),
|
||||
BrushKind::Bristle(b) => calli::bristle(b, bp, w, stroke, &brush.name),
|
||||
BrushKind::Art(a) => warp::art(a, bp, w, stroke),
|
||||
BrushKind::Scatter(s) => warp::scatter(s, bp, w, stroke, &brush.name),
|
||||
BrushKind::Pattern(p) => warp::pattern(p, bp, w),
|
||||
@@ -1093,6 +1107,12 @@ pub fn stroke_pieces(doc: &Document, brush: &Brush, bp: &BezPath, stroke: &Strok
|
||||
for n in &mut out {
|
||||
colorize(n, colorization, &stroke.paint);
|
||||
}
|
||||
// One piece per copy, in the order the copies run along the path.
|
||||
if let BrushKind::Scatter(s) = &brush.kind
|
||||
&& s.hue_jitter > 0.0
|
||||
{
|
||||
colorize::jitter_hues(&mut out, s.hue_jitter, track::seed_of(bp, &brush.name));
|
||||
}
|
||||
leave_out_brushed(doc, &mut out, &mut Known::new());
|
||||
out
|
||||
}
|
||||
@@ -1245,6 +1265,14 @@ pub fn has_brush(n: &Node) -> bool {
|
||||
n.appearance.items.iter().any(|i| matches!(i, AppearanceItem::Stroke(s) if s.brush.is_some() && s.visible))
|
||||
}
|
||||
|
||||
/// Does `stroke` draw with a brush of `lib` (the document's [`library`])? [`stroke_pieces`] sizes
|
||||
/// brush art from the brush and the stroke weight and does not read the stroke's width profile, so
|
||||
/// the profile does not change what such a stroke draws. A stroke without a brush, or one that
|
||||
/// names a brush `lib` lacks, draws a plain stroke, which follows the profile.
|
||||
pub fn keeps_brush_size(lib: &[Brush], stroke: &StrokeLayer) -> bool {
|
||||
stroke.brush.as_deref().is_some_and(|name| lib.iter().any(|b| b.name == name))
|
||||
}
|
||||
|
||||
/// How far brush art can paint past the visual box of `n`: `16 × w + 8`, where `w` is the widest
|
||||
/// stroke of `n` (at least 1), when `n` has a visible brushed stroke with a paint; 0 when it has
|
||||
/// none, as a brushed stroke without a paint draws no brush art. This is the room the renderer and
|
||||
|
||||
@@ -827,6 +827,86 @@ fn bristle_makes_translucent_strands() {
|
||||
assert!(bb.height() <= 6.0 * 1.3 && bb.height() >= 3.0, "{bb:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bristle_pen_pressure_changes_its_footprint() {
|
||||
let b = Brush { name: "b".into(), kind: BrushKind::Bristle(Bristle::default()) };
|
||||
let render = |pressure| {
|
||||
let s = StrokeLayer { pressure: Some(vectorcraft_doc::PressureProfile { points: vec![(0.0, pressure), (1.0, pressure)] }), ..stroke(1.0) };
|
||||
stroke_pieces(&Document::new(1.0, 1.0), &b, &line(0.0, 0.0, 200.0, 0.0), &s)
|
||||
};
|
||||
let light = render(0.0);
|
||||
let heavy = render(1.0);
|
||||
assert_eq!(light.len(), heavy.len());
|
||||
assert!(bounds(&heavy).height() > bounds(&light).height() * 1.8);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bristle_pen_pressure_is_sampled_along_the_stroke() {
|
||||
let b = Brush { name: "b".into(), kind: BrushKind::Bristle(Bristle::default()) };
|
||||
let s = StrokeLayer { pressure: Some(vectorcraft_doc::PressureProfile { points: vec![(0.0, 0.0), (1.0, 1.0)] }), ..stroke(1.0) };
|
||||
let out = stroke_pieces(&Document::new(1.0, 1.0), &b, &line(0.0, 0.0, 200.0, 0.0), &s);
|
||||
let mut points = Vec::new();
|
||||
for n in &out {
|
||||
all_points(n, &mut points);
|
||||
}
|
||||
let early = points.iter().filter(|p| p.x > 20.0 && p.x < 60.0).map(|p| p.y.abs()).fold(0.0_f64, f64::max);
|
||||
let late = points.iter().filter(|p| p.x > 140.0 && p.x < 180.0).map(|p| p.y.abs()).fold(0.0_f64, f64::max);
|
||||
assert!(late > early * 1.4, "spread along stroke: {early} -> {late}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn trimmed_bristle_strands_read_pressure_where_they_begin() {
|
||||
let b = Brush { name: "b".into(), kind: BrushKind::Bristle(Bristle { size: 20.0, length: 300.0, ..Default::default() }) };
|
||||
let render = |points| {
|
||||
let s = StrokeLayer { pressure: Some(vectorcraft_doc::PressureProfile { points }), ..stroke(1.0) };
|
||||
stroke_pieces(&Document::new(1.0, 1.0), &b, &line(0.0, 0.0, 80.0, 0.0), &s)
|
||||
};
|
||||
let ramp = render(vec![(0.0, 0.0), (1.0, 1.0)]);
|
||||
let neutral = render(vec![(0.0, 0.5), (1.0, 0.5)]);
|
||||
assert_eq!(ramp.len(), neutral.len());
|
||||
let start = |n: &Node| {
|
||||
let anchors = &n.path_data().unwrap().subpaths[0].anchors;
|
||||
let first = anchors[0].p;
|
||||
let opposite = anchors[anchors.len() - 16].p;
|
||||
(first.x, (first.y - opposite.y).abs())
|
||||
};
|
||||
let mut checked = false;
|
||||
for (ramp, neutral) in ramp.iter().zip(&neutral) {
|
||||
let (x, width) = start(ramp);
|
||||
if x < 12.0 {
|
||||
continue;
|
||||
}
|
||||
let (_, neutral_width) = start(neutral);
|
||||
let expected = 0.5 + x / 80.0;
|
||||
assert!(width / neutral_width > expected - 0.08, "strand at {x}: {width} vs {neutral_width}, expected ratio {expected}");
|
||||
checked = true;
|
||||
}
|
||||
assert!(checked, "at least one strand begins past the pressure ramp's first eighth");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bristle_pen_orientation_changes_its_footprint() {
|
||||
let b = Brush { name: "b".into(), kind: BrushKind::Bristle(Bristle::default()) };
|
||||
let render = |tilt, bearing, rotation| {
|
||||
let flat = |x| vec![(0.0, x), (1.0, x)];
|
||||
let s = StrokeLayer {
|
||||
tilt: Some(vectorcraft_doc::PressureProfile { points: flat(tilt) }),
|
||||
bearing: Some(vectorcraft_doc::AngleProfile { points: flat(bearing) }),
|
||||
rotation: Some(vectorcraft_doc::AngleProfile { points: flat(rotation) }),
|
||||
..stroke(1.0)
|
||||
};
|
||||
stroke_pieces(&Document::new(1.0, 1.0), &b, &line(0.0, 0.0, 200.0, 0.0), &s)
|
||||
};
|
||||
let neutral = bounds(&render(0.5, 0.0, 0.0)).height();
|
||||
let flat = bounds(&render(1.0, 0.0, 0.0)).height();
|
||||
let upright = bounds(&render(0.0, 0.0, 0.0)).height();
|
||||
let bearing = bounds(&render(0.5, 90.0, 0.0)).height();
|
||||
let rotation = bounds(&render(0.5, 0.0, 90.0)).height();
|
||||
assert!(flat > neutral && neutral > upright, "tilt: {flat} > {neutral} > {upright}");
|
||||
assert!(bearing < neutral * 0.7, "bearing: {bearing} vs {neutral}");
|
||||
assert!(rotation < neutral * 0.7, "rotation: {rotation} vs {neutral}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tints_colorization_uses_stroke_colour() {
|
||||
let b = art_brush(rect_art(10.0, 4.0), ArtScale::Stretch);
|
||||
@@ -953,6 +1033,165 @@ fn stain_mixes_type_strokes_too() {
|
||||
assert_eq!(run_paints(&[art]), [(Paint::solid(blue), Paint::solid(blue))]);
|
||||
}
|
||||
|
||||
/// A scatter brush of rectangles filled `fill`, with `colorization` and `hue_jitter`.
|
||||
fn jittered(fill: Color, colorization: Colorization, hue_jitter: f64) -> Brush {
|
||||
let mut art = rect_art(10.0, 4.0);
|
||||
art.appearance.set_fill(Paint::solid(fill));
|
||||
Brush { name: "s".into(), kind: BrushKind::Scatter(Scatter { art, colorization, hue_jitter, ..Default::default() }) }
|
||||
}
|
||||
|
||||
/// The fill color of each copy.
|
||||
fn fill_colors(out: &[Node]) -> Vec<Color> {
|
||||
out.iter().map(|n| n.appearance.fill_paint().color().unwrap()).collect()
|
||||
}
|
||||
|
||||
/// How far hue `h` is from `from`, in degrees, either way round.
|
||||
fn hue_gap(h: f32, from: f32) -> f32 {
|
||||
let d = (h - from).rem_euclid(360.0);
|
||||
d.min(360.0 - d)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hue_jitter_turns_each_copy_the_same_every_time() {
|
||||
let doc = Document::new(1.0, 1.0);
|
||||
let path = line(0.0, 0.0, 200.0, 0.0);
|
||||
let b = jittered(Color::rgb(1.0, 0.0, 0.0), Colorization::None, 90.0);
|
||||
let out = stroke_pieces(&doc, &b, &path, &stroke(1.0));
|
||||
assert_eq!(out.len(), 20);
|
||||
assert_eq!(stroke_pieces(&doc, &b, &path, &stroke(1.0)), out, "the same stroke draws the same colors");
|
||||
let colors = fill_colors(&out);
|
||||
let hues: Vec<f32> = colors.iter().map(|c| c.to_hsb()[0]).collect();
|
||||
assert!(hues.iter().all(|h| hue_gap(*h, 0.0) <= 90.01), "{hues:?}");
|
||||
assert!(hues.iter().any(|h| hue_gap(*h, 0.0) > 10.0), "the copies turn: {hues:?}");
|
||||
let distinct: std::collections::HashSet<String> = colors.iter().map(Color::to_hex).collect();
|
||||
assert!(distinct.len() > 10, "each copy turns by its own amount: {distinct:?}");
|
||||
// Saturation and brightness stay; the copies stay where they were, at their size and angle.
|
||||
assert!(colors.iter().all(|c| near(f64::from(c.to_hsb()[1]), 1.0, 1e-3) && near(f64::from(c.to_hsb()[2]), 1.0, 1e-3)), "{colors:?}");
|
||||
let plain = stroke_pieces(&doc, &jittered(Color::rgb(1.0, 0.0, 0.0), Colorization::None, 0.0), &path, &stroke(1.0));
|
||||
let boxes = |o: &[Node]| o.iter().map(|n| n.geometric_bounds().unwrap()).collect::<Vec<_>>();
|
||||
assert_eq!(boxes(&out), boxes(&plain));
|
||||
// Another path draws other amounts.
|
||||
let other = fill_colors(&stroke_pieces(&doc, &b, &line(0.0, 10.0, 200.0, 10.0), &stroke(1.0)));
|
||||
assert_ne!(other, colors);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hue_jitter_of_zero_changes_nothing() {
|
||||
let red = Color::rgb(1.0, 0.0, 0.0);
|
||||
let out = stroke_pieces(&Document::new(1.0, 1.0), &jittered(red, Colorization::None, 0.0), &line(0.0, 0.0, 200.0, 0.0), &stroke(1.0));
|
||||
assert!(!out.is_empty() && fill_colors(&out).iter().all(|c| *c == red));
|
||||
// A brush without hue jitter is saved as before, and one saved before reads as 0.
|
||||
let v = serde_json::to_value(jittered(red, Colorization::None, 0.0)).unwrap();
|
||||
assert!(v.get("hue_jitter").is_none(), "{v}");
|
||||
let mut old = serde_json::to_value(jittered(red, Colorization::None, 45.0)).unwrap();
|
||||
assert_eq!(old.as_object_mut().unwrap().remove("hue_jitter"), Some(serde_json::json!(45.0)));
|
||||
let BrushKind::Scatter(s) = Brush::from_json(old).unwrap().kind else { panic!("not a scatter brush") };
|
||||
assert_eq!(s.hue_jitter, 0.0, "a brush saved without the key reads as 0");
|
||||
let mut with = v.clone();
|
||||
with["hue_jitter"] = serde_json::json!(45.0);
|
||||
let BrushKind::Scatter(s) = Brush::from_json(with).unwrap().kind else { panic!("not a scatter brush") };
|
||||
assert_eq!(s.hue_jitter, 45.0);
|
||||
// Values outside 0..180 are clamped.
|
||||
for (given, kept) in [(500.0, 180.0), (-20.0, 0.0)] {
|
||||
let mut v = v.clone();
|
||||
v["hue_jitter"] = serde_json::json!(given);
|
||||
let BrushKind::Scatter(s) = Brush::from_json(v).unwrap().kind else { panic!("not a scatter brush") };
|
||||
assert_eq!(s.hue_jitter, kept, "{given}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hue_jitter_turns_after_the_colorization() {
|
||||
let doc = Document::new(1.0, 1.0);
|
||||
let path = line(0.0, 0.0, 200.0, 0.0);
|
||||
// Tints: black art takes the blue stroke color, which then turns.
|
||||
let blue = StrokeLayer::new(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), 1.0);
|
||||
let hues: Vec<f32> =
|
||||
fill_colors(&stroke_pieces(&doc, &jittered(Color::BLACK, Colorization::Tints, 30.0), &path, &blue)).iter().map(|c| c.to_hsb()[0]).collect();
|
||||
assert!(!hues.is_empty() && hues.iter().all(|h| hue_gap(*h, 240.0) <= 30.01), "{hues:?}");
|
||||
assert!(hues.iter().any(|h| hue_gap(*h, 240.0) > 3.0), "{hues:?}");
|
||||
// A gray stroke color has no hue: its tints stay as they are.
|
||||
let gray = StrokeLayer::new(Paint::solid(Color::rgb(0.5, 0.5, 0.5)), 1.0);
|
||||
let turned = stroke_pieces(&doc, &jittered(Color::BLACK, Colorization::Tints, 180.0), &path, &gray);
|
||||
let still = stroke_pieces(&doc, &jittered(Color::BLACK, Colorization::Tints, 0.0), &path, &gray);
|
||||
assert_eq!(fill_colors(&turned), fill_colors(&still));
|
||||
// Nor does black ink alone, nor a gray, as a process stroke color.
|
||||
for key in [Color::cmyk(0.0, 0.0, 0.0, 1.0), Color::cmyk(0.0, 0.0, 0.0, 0.5), Color::gray(0.4)] {
|
||||
let key = StrokeLayer::new(Paint::solid(key), 1.0);
|
||||
let turned = stroke_pieces(&doc, &jittered(Color::BLACK, Colorization::Tints, 180.0), &path, &key);
|
||||
let still = stroke_pieces(&doc, &jittered(Color::BLACK, Colorization::Tints, 0.0), &path, &key);
|
||||
assert_eq!(fill_colors(&turned), fill_colors(&still), "{key:?}");
|
||||
}
|
||||
// A turned process color stays a process color, turned over its C, M and Y with its K kept.
|
||||
let cmyk = fill_colors(&stroke_pieces(&doc, &jittered(Color::cmyk(0.0, 1.0, 1.0, 0.25), Colorization::None, 60.0), &path, &stroke(1.0)));
|
||||
assert!(cmyk.iter().any(|c| *c != Color::cmyk(0.0, 1.0, 1.0, 0.25)), "{cmyk:?}");
|
||||
for c in &cmyk {
|
||||
let Color::Cmyk { c, m, y, k } = *c else { panic!("not CMYK: {c:?}") };
|
||||
assert_eq!(k, 0.25);
|
||||
// Full ink in one channel and none in another, as the color before it.
|
||||
assert!(near(f64::from(c.max(m).max(y)), 1.0, 1e-4) && near(f64::from(c.min(m).min(y)), 0.0, 1e-4), "{c} {m} {y}");
|
||||
}
|
||||
// An RGB color keeps its saturation and brightness in its own values.
|
||||
let rgb = fill_colors(&stroke_pieces(&doc, &jittered(Color::rgb(0.8, 0.2, 0.4), Colorization::None, 90.0), &path, &stroke(1.0)));
|
||||
for c in &rgb {
|
||||
let Color::Rgb { r, g, b } = *c else { panic!("not RGB: {c:?}") };
|
||||
assert!(near(f64::from(r.max(g).max(b)), 0.8, 1e-4) && near(f64::from(r.min(g).min(b)), 0.2, 1e-4), "{c:?}");
|
||||
}
|
||||
// A Lab color keeps its lightness and chroma.
|
||||
let lab = fill_colors(&stroke_pieces(&doc, &jittered(Color::lab(50.0, 40.0, 30.0), Colorization::None, 90.0), &path, &stroke(1.0)));
|
||||
assert!(lab.iter().any(|c| *c != Color::lab(50.0, 40.0, 30.0)), "{lab:?}");
|
||||
for c in &lab {
|
||||
let Color::Lab { l, a, b } = *c else { panic!("not Lab: {c:?}") };
|
||||
assert!(l == 50.0 && near(f64::from(a.hypot(b)), 50.0, 1e-3), "{c:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Hue jitter turns type's characters, the colors Tints and Shades and Hue Shift give, and a color
|
||||
/// linked to a swatch (which loses the link); a pattern paint stays.
|
||||
#[test]
|
||||
fn hue_jitter_turns_type_every_colorization_and_linked_colors() {
|
||||
let doc = Document::new(1.0, 1.0);
|
||||
let path = line(0.0, 0.0, 200.0, 0.0);
|
||||
let red = Paint::solid(Color::rgb(1.0, 0.0, 0.0));
|
||||
let typed = |hue_jitter| Brush {
|
||||
name: "s".into(),
|
||||
kind: BrushKind::Scatter(Scatter { art: type_art(red.clone(), red.clone()), hue_jitter, ..Default::default() }),
|
||||
};
|
||||
let still = run_paints(&stroke_pieces(&doc, &typed(0.0), &path, &stroke(1.0)));
|
||||
let turned = run_paints(&stroke_pieces(&doc, &typed(90.0), &path, &stroke(1.0)));
|
||||
assert!(!still.is_empty() && still.iter().all(|p| *p == (red.clone(), red.clone())), "{still:?}");
|
||||
assert_eq!(turned.len(), still.len());
|
||||
assert!(turned.iter().any(|p| *p != (red.clone(), red.clone())), "the characters turn: {turned:?}");
|
||||
assert!(turned.iter().all(|(f, s)| f == s), "a copy's character fill and stroke turn by the same amount: {turned:?}");
|
||||
// Tints and Shades and Hue Shift: the colors they give turn.
|
||||
let blue = StrokeLayer::new(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), 1.0);
|
||||
for colorization in [Colorization::TintsAndShades, Colorization::HueShift { key: Color::rgb(1.0, 0.0, 0.0) }] {
|
||||
let art = Color::rgb(1.0, 0.0, 0.0);
|
||||
let still = fill_colors(&stroke_pieces(&doc, &jittered(art, colorization, 0.0), &path, &blue));
|
||||
let turned = fill_colors(&stroke_pieces(&doc, &jittered(art, colorization, 45.0), &path, &blue));
|
||||
assert_eq!(turned.len(), still.len());
|
||||
assert_ne!(turned, still, "{colorization:?}");
|
||||
for (t, s) in turned.iter().zip(&still) {
|
||||
assert!(hue_gap(t.to_hsb()[0], s.to_hsb()[0]) <= 45.01, "{colorization:?}: {t:?} from {s:?}");
|
||||
}
|
||||
}
|
||||
// A color linked to a swatch turns and loses the link; a pattern paint stays.
|
||||
let linked = Paint::Solid { color: Color::rgb(1.0, 0.0, 0.0), swatch: Some("Red".into()), tint: 1.0 };
|
||||
let pattern = Paint::Pattern { pattern: "Dots".into(), xf: Affine::IDENTITY };
|
||||
let mut art = rect_art(10.0, 4.0);
|
||||
art.appearance.set_fill(linked.clone());
|
||||
art.appearance.set_stroke(pattern.clone());
|
||||
let b = |hue_jitter| Brush { name: "s".into(), kind: BrushKind::Scatter(Scatter { art: art.clone(), hue_jitter, ..Default::default() }) };
|
||||
let still = stroke_pieces(&doc, &b(0.0), &path, &stroke(1.0));
|
||||
let turned = stroke_pieces(&doc, &b(90.0), &path, &stroke(1.0));
|
||||
assert!(!still.is_empty() && still.iter().all(|n| n.appearance.fill_paint() == linked));
|
||||
assert_eq!(turned.len(), still.len());
|
||||
for n in &turned {
|
||||
assert!(matches!(n.appearance.fill_paint(), Paint::Solid { swatch: None, .. }), "{:?}", n.appearance.fill_paint());
|
||||
assert_eq!(n.appearance.stroke().map(|s| &s.paint), Some(&pattern));
|
||||
}
|
||||
}
|
||||
|
||||
/// An instance whose fill has an opacity of 0 does not stain its symbol's art, so the art keeps its
|
||||
/// swatch links.
|
||||
#[test]
|
||||
|
||||
+33
-6
@@ -7,6 +7,8 @@
|
||||
//! hatches, type text entities or glyph outlines, and placed images image entities linked to PNG
|
||||
//! or JPEG files the caller writes next to the drawing. Coordinates are y-up, in drawing units: `scale` units per
|
||||
//! `unit` of the art, with the origin at the bottom-left corner of [`DxfOptions::region`].
|
||||
//! [`export_drawings`] writes one such drawing for each of several regions, applying the live
|
||||
//! effects once for all of them.
|
||||
//!
|
||||
//! What DXF can't hold (blending modes, opacity masks, raster effects, gradients, patterns,
|
||||
//! clipping) is approximated or left out, and each such loss comes back as a warning.
|
||||
@@ -436,18 +438,43 @@ pub const SCALE_RANGE: std::ops::RangeInclusive<f64> = 1e-6..=1e6;
|
||||
/// Write `doc` as a DXF drawing with `opts`. Live geometry effects are applied first; template
|
||||
/// layers, guides and hidden objects are left out.
|
||||
pub fn export(doc: &Document, opts: &DxfOptions) -> Result<DxfOutput, String> {
|
||||
Ok(export_drawings(doc, opts, &[(opts.region, opts.crop)])?.pop().unwrap_or_default())
|
||||
}
|
||||
|
||||
/// Write `doc` as one DXF drawing for each `(region, crop)` of `drawings`, in order, each as
|
||||
/// [`export`] writes it with `opts` and that region and crop. Live geometry effects are applied
|
||||
/// once for all the drawings.
|
||||
pub fn export_drawings(doc: &Document, opts: &DxfOptions, drawings: &[(Rect, bool)]) -> Result<Vec<DxfOutput>, String> {
|
||||
export_drawings_with(doc, opts, drawings, bake_for_drawings)
|
||||
}
|
||||
|
||||
/// `doc` with its live geometry effects applied and its symbols' art placed, or `None` when
|
||||
/// nothing changes.
|
||||
fn bake_for_drawings(doc: &Document) -> Option<Document> {
|
||||
// Symbols' art is placed without clipping, as the scene places it.
|
||||
let layers = vectorcraft_effects::WrittenLayers { hidden: true, non_printing: true, hidden_objects: false };
|
||||
vectorcraft_effects::bake_document_placing_symbols(doc, false, layers)
|
||||
}
|
||||
|
||||
/// [`export_drawings`] with `bake` applying the live effects.
|
||||
fn export_drawings_with(
|
||||
doc: &Document,
|
||||
opts: &DxfOptions,
|
||||
drawings: &[(Rect, bool)],
|
||||
bake: impl Fn(&Document) -> Option<Document>,
|
||||
) -> Result<Vec<DxfOutput>, String> {
|
||||
if !(opts.scale.is_finite() && SCALE_RANGE.contains(&opts.scale)) {
|
||||
return Err(format!("scale must be a number from {} to {}, not {}", SCALE_RANGE.start(), SCALE_RANGE.end(), opts.scale));
|
||||
}
|
||||
let r = opts.region;
|
||||
if ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite()) {
|
||||
if drawings.iter().any(|(r, _)| ![r.x0, r.y0, r.x1, r.y1].iter().all(|v| v.is_finite())) {
|
||||
return Err("the export region is not finite".into());
|
||||
}
|
||||
// Symbols' art is placed without clipping, as the scene places it.
|
||||
let layers = vectorcraft_effects::WrittenLayers { hidden: true, non_printing: true, hidden_objects: false };
|
||||
let baked = vectorcraft_effects::bake_document_placing_symbols(doc, false, layers);
|
||||
if drawings.is_empty() {
|
||||
return Ok(vec![]);
|
||||
}
|
||||
let baked = bake(doc);
|
||||
let doc = baked.as_ref().unwrap_or(doc);
|
||||
Ok(scene::Scene::new(doc, opts).run())
|
||||
Ok(drawings.iter().map(|&(region, crop)| scene::Scene::new(doc, &DxfOptions { region, crop, ..opts.clone() }).run()).collect())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -1493,3 +1493,201 @@ fn export_bytes_match_shared_writer_goldens() {
|
||||
assert_eq!(got, expected, "DXF bytes changed versus {}", path.display());
|
||||
}
|
||||
}
|
||||
|
||||
/// One drawing written by applying the live effects for it alone and walking the result, as each
|
||||
/// drawing of a multi-drawing export was written before [`export_drawings`].
|
||||
fn export_baking_alone(doc: &Document, opts: &DxfOptions) -> DxfOutput {
|
||||
let baked = crate::bake_for_drawings(doc);
|
||||
crate::scene::Scene::new(baked.as_ref().unwrap_or(doc), opts).run()
|
||||
}
|
||||
|
||||
/// A written drawing's bytes, linked images (name and bytes), warnings and setting notes.
|
||||
type Written = (Vec<u8>, Vec<(String, Vec<u8>)>, Vec<String>, Vec<String>);
|
||||
|
||||
/// Every field of a written drawing, for comparing two.
|
||||
fn written(out: &DxfOutput) -> Written {
|
||||
let images = out.images.iter().map(|i| (i.name.clone(), i.bytes.clone())).collect();
|
||||
(out.bytes.clone(), images, out.warnings.clone(), out.setting_notes.clone())
|
||||
}
|
||||
|
||||
/// A Transform effect that moves its object `x` pt right.
|
||||
fn moved_by(mut n: Node, x: f64) -> Node {
|
||||
n.appearance.effects.push(vectorcraft_doc::Effect { id: "distort.transform".into(), params: serde_json::json!({"moveH": x}), visible: true });
|
||||
n
|
||||
}
|
||||
|
||||
/// A line moved by a Transform effect, an instance of a symbol whose art carries the same effect
|
||||
/// stained by its fill, a semi-transparent line in a blending mode, and a placed PNG image.
|
||||
fn drawings_doc() -> Document {
|
||||
let png = craft_image_codecs::encode(
|
||||
&craft_image_codecs::Image::from_raw(
|
||||
2,
|
||||
2,
|
||||
craft_image_codecs::ChannelLayout::Rgba,
|
||||
craft_image_codecs::SampleType::U8,
|
||||
[0u8, 128, 255, 255].repeat(4),
|
||||
)
|
||||
.unwrap(),
|
||||
craft_image_codecs::Format::Png,
|
||||
&craft_image_codecs::EncodeOptions::default(),
|
||||
)
|
||||
.unwrap();
|
||||
let mut d = doc_with(|d| {
|
||||
let line = path(d, shapes::line((10.0, 10.0).into(), (20.0, 10.0).into()), Paint::None, Paint::solid(Color::BLACK), 1.0);
|
||||
let mut instance = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "Moved".into(), xf: Affine::IDENTITY });
|
||||
instance.appearance = Appearance::basic(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), Paint::None, 0.0).into();
|
||||
let mut faint = path(d, shapes::line((10.0, 90.0).into(), (190.0, 90.0).into()), Paint::None, Paint::solid(Color::BLACK), 1.0);
|
||||
faint.opacity = 0.5;
|
||||
faint.blend = vectorcraft_color::BlendMode::Multiply;
|
||||
let im = ImageObject {
|
||||
key: "raster-1".into(),
|
||||
width: 2,
|
||||
height: 2,
|
||||
xf: Affine::translate((150.0, 20.0)) * Affine::scale(10.0),
|
||||
link: None,
|
||||
placement: Default::default(),
|
||||
pixels: None,
|
||||
};
|
||||
vec![moved_by(line, 100.0), instance, faint, Node::new(d.alloc_id(), NodeKind::Image(Box::new(im)))]
|
||||
});
|
||||
let art = path(&mut d, shapes::rectangle(Rect::new(10.0, 40.0, 30.0, 60.0)), Paint::solid(Color::rgb(1.0, 0.0, 0.0)), Paint::None, 0.0);
|
||||
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Moved".into(), art: Arc::new(moved_by(art, 20.0)) });
|
||||
d.images.insert("raster-1".into(), ImageBlob { mime: "image/png".into(), bytes: Arc::new(png), proxy: None });
|
||||
d
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn drawings_apply_the_live_effects_once_and_match_drawings_written_alone() {
|
||||
let d = drawings_doc();
|
||||
assert!(crate::bake_for_drawings(&d).is_some(), "the document has live effects to apply");
|
||||
// The left and right halves cropped, the whole page uncropped, and a region off the page.
|
||||
let drawings = [
|
||||
(Rect::new(0.0, 0.0, 100.0, 100.0), true),
|
||||
(Rect::new(100.0, 0.0, 200.0, 100.0), true),
|
||||
(Rect::new(0.0, 0.0, 200.0, 100.0), false),
|
||||
(Rect::new(300.0, 0.0, 400.0, 100.0), true),
|
||||
];
|
||||
// With every option, and with images and hatches left out (which adds setting notes).
|
||||
let all_in = opts(&d);
|
||||
for o in [all_in.clone(), DxfOptions { include_images: false, include_hatches: false, ..all_in }] {
|
||||
let bakes = std::cell::Cell::new(0);
|
||||
let outs = crate::export_drawings_with(&d, &o, &drawings, |doc| {
|
||||
bakes.set(bakes.get() + 1);
|
||||
crate::bake_for_drawings(doc)
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(bakes.get(), 1, "the live effects are applied once for every drawing");
|
||||
assert_eq!(outs.len(), drawings.len());
|
||||
for ((region, crop), out) in drawings.iter().zip(&outs) {
|
||||
let alone = export_baking_alone(&d, &DxfOptions { region: *region, crop: *crop, ..o.clone() });
|
||||
assert_eq!(written(out), written(&alone), "the drawing over {region:?}, crop {crop}");
|
||||
let one = export(&d, &DxfOptions { region: *region, crop: *crop, ..o.clone() }).unwrap();
|
||||
assert_eq!(written(&one), written(&alone), "export over {region:?}, crop {crop}");
|
||||
}
|
||||
let public: Vec<_> = export_drawings(&d, &o, &drawings).unwrap().iter().map(written).collect();
|
||||
assert_eq!(public, outs.iter().map(written).collect::<Vec<_>>());
|
||||
// The halves hold different art, the left half a line with losses, and the region off the
|
||||
// page nothing.
|
||||
assert!(!entities(&outs[0]).is_empty() && !entities(&outs[1]).is_empty() && !outs[0].warnings.is_empty());
|
||||
assert_ne!(outs[0].bytes, outs[1].bytes);
|
||||
assert!(entities(&outs[3]).is_empty() && outs[3].images.is_empty());
|
||||
if o.include_images {
|
||||
assert_eq!(outs[2].images.len(), 1);
|
||||
} else {
|
||||
assert!(!outs[2].setting_notes.is_empty() && outs[2].images.is_empty());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn drawings_are_checked_before_the_live_effects_are_applied() {
|
||||
let d = drawings_doc();
|
||||
let o = opts(&d);
|
||||
let bakes = std::cell::Cell::new(0);
|
||||
let count = |doc: &Document| {
|
||||
bakes.set(bakes.get() + 1);
|
||||
crate::bake_for_drawings(doc)
|
||||
};
|
||||
let page = (d.artboards[0].rect, false);
|
||||
let off = (Rect::new(0.0, 0.0, f64::NAN, 100.0), false);
|
||||
assert_eq!(crate::export_drawings_with(&d, &o, &[page, off], count).unwrap_err(), "the export region is not finite");
|
||||
let e = crate::export_drawings_with(&d, &DxfOptions { scale: 0.0, ..o.clone() }, &[page], count).unwrap_err();
|
||||
assert!(e.starts_with("scale must be a number"), "{e}");
|
||||
assert!(crate::export_drawings_with(&d, &o, &[], count).unwrap().is_empty());
|
||||
assert_eq!(bakes.get(), 0, "nothing is applied for drawings that are refused or for none");
|
||||
}
|
||||
|
||||
/// The thread's time on the CPU in nanoseconds where Linux reports it, otherwise `None`.
|
||||
fn thread_cpu_ns() -> Option<u64> {
|
||||
std::fs::read_to_string("/proc/thread-self/schedstat").ok()?.split_whitespace().next()?.parse().ok()
|
||||
}
|
||||
|
||||
/// Time a Use Artboards export of eight artboards whose art has live effects, written drawing by
|
||||
/// drawing with the effects applied for each (as before [`export_drawings`]) and with
|
||||
/// [`export_drawings`], alternating, seven times each, and check that both write the same
|
||||
/// drawings. Prints the median of each in milliseconds of the thread's CPU time (on Linux) and of
|
||||
/// wall-clock time.
|
||||
/// Run with `cargo test --release -p vectorcraft-cad --lib dxf_artboards_bake_perf -- --ignored --nocapture`.
|
||||
#[test]
|
||||
#[ignore = "manual timing probe; wall-clock performance depends on machine load"]
|
||||
fn dxf_artboards_bake_perf() {
|
||||
const BOARDS: usize = 8;
|
||||
let mut d = Document::new(200.0 * BOARDS as f64, 200.0);
|
||||
let layer = d.layers[0].id;
|
||||
let effect = |id: &str, params: serde_json::Value| vectorcraft_doc::Effect { id: id.into(), params, visible: true };
|
||||
let mut art = vec![];
|
||||
for i in 0..50 {
|
||||
let (x, y) = (f64::from(i % 10) * 5.0, f64::from(i / 10) * 5.0);
|
||||
art.push(Arc::new(path(&mut d, shapes::rectangle(Rect::new(x, y, x + 4.0, y + 4.0)), Paint::None, Paint::solid(Color::BLACK), 0.5)));
|
||||
}
|
||||
let mut cell = Node::group(d.alloc_id(), art);
|
||||
cell.appearance.effects.push(effect("distort.zigZag", serde_json::json!({"size": 1.0, "relative": false, "ridges": 4, "points": "smooth"})));
|
||||
d.symbols.push(vectorcraft_doc::Symbol { dynamic: false, name: "Cell".into(), art: Arc::new(cell) });
|
||||
for b in 0..BOARDS {
|
||||
let x0 = 200.0 * b as f64;
|
||||
for i in 0..250 {
|
||||
let (x, y) = (x0 + f64::from(i % 25) * 8.0, f64::from(i / 25) * 8.0);
|
||||
let mut n = path(&mut d, shapes::ellipse(Rect::new(x, y, x + 6.0, y + 6.0)), Paint::None, Paint::solid(Color::BLACK), 0.5);
|
||||
let params = serde_json::json!({"size": 1.0, "relative": false, "detail": 10.0, "points": "smooth", "seed": i});
|
||||
n.appearance.effects.push(effect("distort.roughen", params));
|
||||
d.insert(Some(layer), usize::MAX, n).unwrap();
|
||||
}
|
||||
for i in 0..20 {
|
||||
let xf = Affine::translate((x0 + f64::from(i % 5) * 40.0, 100.0 + f64::from(i / 5) * 25.0));
|
||||
let instance = Node::new(d.alloc_id(), NodeKind::SymbolInstance { symbol: "Cell".into(), xf });
|
||||
d.insert(Some(layer), usize::MAX, instance).unwrap();
|
||||
}
|
||||
}
|
||||
let o = DxfOptions { unit: Unit::Points, ..DxfOptions::default() };
|
||||
let drawings: Vec<(Rect, bool)> = (0..BOARDS).map(|b| (Rect::new(200.0 * b as f64, 0.0, 200.0 * (b + 1) as f64, 200.0), true)).collect();
|
||||
let before = || drawings.iter().map(|&(region, crop)| export_baking_alone(&d, &DxfOptions { region, crop, ..o.clone() })).collect::<Vec<_>>();
|
||||
let after = || export_drawings(&d, &o, &drawings).unwrap();
|
||||
let time = |f: &dyn Fn() -> Vec<DxfOutput>| {
|
||||
let (cpu, wall) = (thread_cpu_ns(), std::time::Instant::now());
|
||||
let outs = f();
|
||||
let wall = wall.elapsed().as_secs_f64() * 1000.0;
|
||||
let cpu = cpu.zip(thread_cpu_ns()).map(|(a, b)| (b - a) as f64 / 1e6);
|
||||
(outs, cpu, wall)
|
||||
};
|
||||
let (mut runs_before, mut runs_after) = (vec![], vec![]);
|
||||
for _ in 0..7 {
|
||||
let (a, cpu_a, wall_a) = time(&before);
|
||||
let (b, cpu_b, wall_b) = time(&after);
|
||||
assert_eq!(a.len(), BOARDS);
|
||||
assert_eq!(a.iter().map(written).collect::<Vec<_>>(), b.iter().map(written).collect::<Vec<_>>(), "both write the same drawings");
|
||||
runs_before.push((cpu_a, wall_a));
|
||||
runs_after.push((cpu_b, wall_b));
|
||||
}
|
||||
let median = |runs: &[(Option<f64>, f64)], cpu: bool| {
|
||||
let mut v: Vec<f64> = runs.iter().filter_map(|r| if cpu { r.0 } else { Some(r.1) }).collect();
|
||||
v.sort_by(f64::total_cmp);
|
||||
v.get(v.len() / 2).copied()
|
||||
};
|
||||
for (name, runs) in [("drawing by drawing", &runs_before), ("export_drawings", &runs_after)] {
|
||||
println!(
|
||||
"{name}: {BOARDS} artboards, median CPU {:?} ms, median wall {:?} ms; runs (CPU ms, wall ms) {runs:?}",
|
||||
median(runs, true),
|
||||
median(runs, false)
|
||||
);
|
||||
}
|
||||
}
|
||||
+14
-3
@@ -347,7 +347,9 @@ pub fn profiles_generation() -> u64 {
|
||||
/// Profile `name` as an ICC file to embed in an export: any RGB or CMYK profile of [`profiles`]
|
||||
/// (by its current or legacy name), or [`GRAY`]. Built-in profiles are written in code from the
|
||||
/// CMS: the RGB spaces from their primaries, the CMYK spaces as lookup tables sampled from their
|
||||
/// model (both directions, perceptual and relative colorimetric, Lab PCS); a profile the user
|
||||
/// model (both directions, perceptual and relative colorimetric, Lab PCS, with the model's paper
|
||||
/// as the media white point; the colorimetric Lab → CMYK table without black-point
|
||||
/// compensation, the perceptual and saturation ones with it); a profile the user
|
||||
/// loaded is the file it came from. Cached.
|
||||
pub fn icc_bytes(name: &str) -> Result<Arc<[u8]>, CmsError> {
|
||||
static CACHE: Mutex<Vec<(String, Arc<[u8]>)>> = Mutex::new(Vec::new());
|
||||
@@ -361,8 +363,17 @@ pub fn icc_bytes(name: &str) -> Result<Arc<[u8]>, CmsError> {
|
||||
let bytes: Arc<[u8]> = if name == GRAY {
|
||||
icc::encode(&icc::gray_profile(name))?
|
||||
} else if BUILTIN_CMYK.contains(&name) {
|
||||
let cms = Cms::new(&ColorSettings { cmyk: name.into(), ..ColorSettings::default() })?;
|
||||
icc::encode(&icc::cmyk_profile(name, |c| cms.cmyk_to_lab(c), |l| cms.lab_to_cmyk(l, Intent::RelativeColorimetric)))?
|
||||
// The perceptual and saturation tables map the shadows with black-point compensation; the
|
||||
// colorimetric table is the inverse of the CMYK → Lab table, without it.
|
||||
let mapped = Cms::new(&ColorSettings { cmyk: name.into(), bpc: true, ..ColorSettings::default() })?;
|
||||
let cms = Cms::new(&ColorSettings { cmyk: name.into(), bpc: false, ..ColorSettings::default() })?;
|
||||
let paper = match &cms.cmyk {
|
||||
CmykSpace::Generic(g) => g.paper_xyz(),
|
||||
CmykSpace::Device | CmykSpace::Icc(_) => lab::D50,
|
||||
};
|
||||
let to_lab = |c| cms.cmyk_to_lab(c);
|
||||
let shadows = |l| mapped.lab_to_cmyk(l, Intent::RelativeColorimetric);
|
||||
icc::encode(&icc::cmyk_profile(name, paper, to_lab, shadows, |l| cms.lab_to_cmyk(l, Intent::RelativeColorimetric)))?
|
||||
} else {
|
||||
icc::builtin_rgb_bytes(name)?
|
||||
}
|
||||
|
||||
@@ -133,6 +133,11 @@ pub struct GenericCmyk {
|
||||
}
|
||||
|
||||
impl GenericCmyk {
|
||||
/// Absolute XYZ (D50) of the paper.
|
||||
pub fn paper_xyz(&self) -> [f32; 3] {
|
||||
self.paper_xyz
|
||||
}
|
||||
|
||||
pub fn new(params: GenericCmykParams) -> Self {
|
||||
let paper_xyz = lab_to_xyz(params.paper);
|
||||
let mut prim = [D50; 16];
|
||||
|
||||
+26
-12
@@ -446,11 +446,20 @@ const B2A_GRID: usize = 17;
|
||||
const GAMUT_GRID: usize = 9;
|
||||
|
||||
/// A CMYK output profile sampled from a conversion: `to_lab` (CMYK → media-relative Lab) in a
|
||||
/// 9⁴ table, `from_lab` (Lab → CMYK, gamut-mapped) in a 17³ table, Lab PCS (ICC v4 encoding).
|
||||
/// 9⁴ table, and Lab → CMYK in 17³ tables, Lab PCS (ICC v4 encoding): `mapped` (gamut-mapped,
|
||||
/// with black-point compensation) for the perceptual and saturation intents, `colorimetric` (the
|
||||
/// colorimetric inverse of `to_lab`) for the colorimetric intents and the gamut tag.
|
||||
/// It carries every tag ICC.1 requires of an output profile: the tables for all three intents
|
||||
/// and the gamut tag (Windows rejects a CMYK profile without them, so Photos couldn't show a CMYK
|
||||
/// TIFF that embedded one, #2707).
|
||||
pub(super) fn cmyk_profile(name: &str, to_lab: impl Fn([f32; 4]) -> lab::Lab, from_lab: impl Fn(lab::Lab) -> [f32; 4]) -> ColorProfile {
|
||||
/// TIFF that embedded one, #2707). The media white point is `paper` (absolute XYZ, D50), which
|
||||
/// the ICC-absolute colorimetric intent reproduces.
|
||||
pub(super) fn cmyk_profile(
|
||||
name: &str,
|
||||
paper: [f32; 3],
|
||||
to_lab: impl Fn([f32; 4]) -> lab::Lab,
|
||||
mapped: impl Fn(lab::Lab) -> [f32; 4],
|
||||
colorimetric: impl Fn(lab::Lab) -> [f32; 4],
|
||||
) -> ColorProfile {
|
||||
let unit = |i: usize, n: usize| i as f32 / (n - 1) as f32;
|
||||
let q = |v: f32| (v.clamp(0.0, 1.0) * 65535.0).round() as u16;
|
||||
let mut a2b = Vec::with_capacity(A2B_GRID.pow(4) * 3);
|
||||
@@ -459,17 +468,21 @@ pub(super) fn cmyk_profile(name: &str, to_lab: impl Fn([f32; 4]) -> lab::Lab, fr
|
||||
let l = to_lab(cmyk);
|
||||
a2b.extend([l.l / 100.0, (l.a + 128.0) / 255.0, (l.b + 128.0) / 255.0].map(q));
|
||||
}
|
||||
let mut b2a = Vec::with_capacity(B2A_GRID.pow(3) * 4);
|
||||
for i in 0..B2A_GRID.pow(3) {
|
||||
let [l, a, b] = [2, 1, 0].map(|d| unit(i / B2A_GRID.pow(d) % B2A_GRID, B2A_GRID));
|
||||
b2a.extend(from_lab(lab::Lab::new(l * 100.0, a * 255.0 - 128.0, b * 255.0 - 128.0)).map(q));
|
||||
}
|
||||
let b2a_of = |from_lab: &dyn Fn(lab::Lab) -> [f32; 4]| {
|
||||
let mut b2a = Vec::with_capacity(B2A_GRID.pow(3) * 4);
|
||||
for i in 0..B2A_GRID.pow(3) {
|
||||
let [l, a, b] = [2, 1, 0].map(|d| unit(i / B2A_GRID.pow(d) % B2A_GRID, B2A_GRID));
|
||||
b2a.extend(from_lab(lab::Lab::new(l * 100.0, a * 255.0 - 128.0, b * 255.0 - 128.0)).map(q));
|
||||
}
|
||||
b2a
|
||||
};
|
||||
let (b2a_mapped, b2a) = (b2a_of(&mapped), b2a_of(&colorimetric));
|
||||
// Gamut: 0 where a colour separates and comes back within a ΔE of 3, else out of gamut.
|
||||
let mut gamut = Vec::with_capacity(GAMUT_GRID.pow(3));
|
||||
for i in 0..GAMUT_GRID.pow(3) {
|
||||
let [l, a, b] = [2, 1, 0].map(|d| unit(i / GAMUT_GRID.pow(d) % GAMUT_GRID, GAMUT_GRID));
|
||||
let want = lab::Lab::new(l * 100.0, a * 255.0 - 128.0, b * 255.0 - 128.0);
|
||||
gamut.push(if lab::delta_e2000(want, to_lab(from_lab(want))) <= 3.0 { 0 } else { u16::MAX });
|
||||
gamut.push(if lab::delta_e2000(want, to_lab(colorimetric(want))) <= 3.0 { 0 } else { u16::MAX });
|
||||
}
|
||||
let identity = |n: usize| vec![ToneReprCurve::Parametric(vec![1.0]); n];
|
||||
let table = |inputs: usize, outputs: usize, grid: usize, clut: Vec<u16>| {
|
||||
@@ -490,6 +503,7 @@ pub(super) fn cmyk_profile(name: &str, to_lab: impl Fn([f32; 4]) -> lab::Lab, fr
|
||||
})
|
||||
};
|
||||
let a2b = table(4, 3, A2B_GRID, a2b);
|
||||
let b2a_mapped = table(3, 4, B2A_GRID, b2a_mapped);
|
||||
let b2a = table(3, 4, B2A_GRID, b2a);
|
||||
let gamut = table(3, 1, GAMUT_GRID, gamut);
|
||||
let mut p = ColorProfile::default();
|
||||
@@ -498,12 +512,12 @@ pub(super) fn cmyk_profile(name: &str, to_lab: impl Fn([f32; 4]) -> lab::Lab, fr
|
||||
p.pcs = DataColorSpace::Lab;
|
||||
p.rendering_intent = RenderingIntent::RelativeColorimetric;
|
||||
p.white_point = moxcms::WHITE_POINT_D50.to_xyzd();
|
||||
p.media_white_point = Some(p.white_point);
|
||||
p.media_white_point = Some(moxcms::Xyzd::new(f64::from(paper[0]), f64::from(paper[1]), f64::from(paper[2])));
|
||||
p.lut_a_to_b_perceptual = Some(a2b.clone());
|
||||
p.lut_a_to_b_saturation = Some(a2b.clone());
|
||||
p.lut_a_to_b_colorimetric = Some(a2b);
|
||||
p.lut_b_to_a_perceptual = Some(b2a.clone());
|
||||
p.lut_b_to_a_saturation = Some(b2a.clone());
|
||||
p.lut_b_to_a_perceptual = Some(b2a_mapped.clone());
|
||||
p.lut_b_to_a_saturation = Some(b2a_mapped);
|
||||
p.lut_b_to_a_colorimetric = Some(b2a);
|
||||
p.gamut = Some(gamut);
|
||||
labelled(p, name)
|
||||
|
||||
@@ -30,11 +30,62 @@ fn cmyk_profiles_convert_like_the_cms() {
|
||||
let de = delta_e2000(lab::srgb_to_lab(want), lab::srgb_to_lab(got));
|
||||
assert!(de < 2.5, "{name} {cmyk:?}: {want:?} vs {got:?} (ΔE {de})");
|
||||
}
|
||||
// And back: an in-gamut colour separates to about the same inks.
|
||||
let srgb = cms.cmyk_to_srgb([0.1, 0.6, 0.8, 0.0], false);
|
||||
let back = p.from_srgb(srgb, Intent::RelativeColorimetric).unwrap();
|
||||
let again = cms.cmyk_to_srgb([back[0], back[1], back[2], back[3]], false);
|
||||
assert!(delta_e2000(lab::srgb_to_lab(srgb), lab::srgb_to_lab(again)) < 3.0, "{back:?}");
|
||||
// And back: in-gamut colours separate to inks that print them. The Lab → CMYK table is
|
||||
// the colorimetric inverse of the CMYK → Lab table, with no black-point compensation.
|
||||
for inks in [
|
||||
[0.1, 0.6, 0.8, 0.0],
|
||||
[0.5, 0.1, 0.3, 0.1],
|
||||
[0.3, 0.3, 0.3, 0.2],
|
||||
[0.05, 0.05, 0.4, 0.0],
|
||||
[0.4, 0.3, 0.3, 0.6],
|
||||
[0.6, 0.5, 0.5, 0.4],
|
||||
[0.2, 0.2, 0.2, 0.8],
|
||||
[0.0, 0.0, 0.0, 0.5],
|
||||
] {
|
||||
let srgb = cms.cmyk_to_srgb(inks, false);
|
||||
let back = p.from_srgb(srgb, Intent::RelativeColorimetric).unwrap();
|
||||
let again = cms.cmyk_to_srgb([back[0], back[1], back[2], back[3]], false);
|
||||
let de = delta_e2000(lab::srgb_to_lab(srgb), lab::srgb_to_lab(again));
|
||||
assert!(de < 1.5, "{name} {inks:?}: {srgb:?} -> {back:?} -> {again:?} (ΔE {de})");
|
||||
}
|
||||
// The perceptual table keeps black-point compensation: source black separates to inks
|
||||
// that print the press's black point, as the CMS separates it with compensation.
|
||||
let compensated = Cms::new(&ColorSettings { cmyk: name.into(), bpc: true, ..Default::default() }).unwrap();
|
||||
let want = compensated.srgb_to_cmyk([0.0; 3], Intent::RelativeColorimetric);
|
||||
let got = p.from_srgb([0.0; 3], Intent::Perceptual).unwrap();
|
||||
let printed = |inks: &[f32]| cms.cmyk_to_lab([inks[0], inks[1], inks[2], inks[3]]);
|
||||
let de = delta_e2000(printed(&want), printed(&got));
|
||||
assert!(de < 1.5, "{name}: perceptual black {got:?} prints {:?}, want {want:?} ({:?})", printed(&got), printed(&want));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cmyk_profiles_separate_saturated_inks_back_without_clipping_to_srgb() {
|
||||
// CMYK → PCS → CMYK through the profile's own colorimetric tables, by way of linear ProPhoto
|
||||
// RGB, which holds every color these profiles print, so no display gamut clips the inks.
|
||||
// Inks that print outside sRGB come back to inks that print the same color.
|
||||
for name in BUILTIN_CMYK {
|
||||
let p = IccProfile::from_bytes(None, &icc_bytes(name).unwrap()).unwrap();
|
||||
let cms = Cms::new(&ColorSettings { cmyk: name.into(), bpc: false, ..Default::default() }).unwrap();
|
||||
for inks in
|
||||
[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [1.0, 1.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0], [1.0, 0.0, 1.0, 0.0]]
|
||||
{
|
||||
let back = p.to_same_model_of(&p, &inks, Intent::RelativeColorimetric, false).unwrap();
|
||||
let de = delta_e2000(cms.cmyk_to_lab(inks), cms.cmyk_to_lab([back[0], back[1], back[2], back[3]]));
|
||||
// Within the ΔE of 3 that the gamut tag counts as reproduced.
|
||||
assert!(de <= 3.0, "{name} {inks:?} -> {back:?} (ΔE {de})");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cmyk_profiles_carry_their_paper_as_the_media_white() {
|
||||
let generic = generic::swop_like();
|
||||
let p = parse(&icc_bytes(GENERIC_CMYK).unwrap());
|
||||
let white = p.media_white_point.unwrap();
|
||||
let paper = lab::lab_to_xyz(generic.paper);
|
||||
for (got, want) in [white.x, white.y, white.z].iter().zip(paper) {
|
||||
assert!((*got - f64::from(want)).abs() < 2e-3, "{white:?} vs {paper:?}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -116,9 +167,10 @@ fn black_point_compensation_maps_the_darkest_ink_to_rgb_black() {
|
||||
let rich = [0.75, 0.68, 0.67, 0.9];
|
||||
let (on, off) = (icc_cmyk(true).cmyk_to_rgb(rich, Intent::RelativeColorimetric), icc_cmyk(false).cmyk_to_rgb(rich, Intent::RelativeColorimetric));
|
||||
// Without compensation the profile's black is a dark grey; with it, rich black goes most of
|
||||
// the way to RGB black (not all: it isn't quite the darkest ink the profile prints).
|
||||
// the way to RGB black (not all: it isn't quite the darkest ink the profile prints, and the
|
||||
// profile's Lab → CMYK table carries no compensation of its own).
|
||||
assert!(off.iter().all(|v| *v > 0.1), "without: {off:?}");
|
||||
assert!(on.iter().zip(off).all(|(a, b)| *a < 0.08 && *a < b * 0.5), "with: {on:?}, without: {off:?}");
|
||||
assert!(on.iter().zip(off).all(|(a, b)| *a < 0.09 && *a < b * 0.55), "with: {on:?}, without: {off:?}");
|
||||
// The screen shows what an sRGB conversion writes, compensated alike.
|
||||
let srgb = |bpc| {
|
||||
let c = icc_cmyk(bpc);
|
||||
|
||||
@@ -143,6 +143,11 @@ impl Appearance {
|
||||
pub fn fill_paint(&self) -> Paint {
|
||||
self.fill().map(|f| f.paint.clone()).unwrap_or(Paint::None)
|
||||
}
|
||||
/// Whether any visible fill has non-None paint. Unlike [`Self::fill`], this
|
||||
/// includes lower fills in the stack; zero opacity still counts for selecting its geometry.
|
||||
pub fn has_visible_fill(&self) -> bool {
|
||||
self.items.iter().any(|item| matches!(item, AppearanceItem::Fill(fill) if fill.visible && !fill.paint.is_none()))
|
||||
}
|
||||
pub fn stroke_paint(&self) -> Paint {
|
||||
self.stroke().map(|s| s.paint.clone()).unwrap_or(Paint::None)
|
||||
}
|
||||
|
||||
@@ -112,6 +112,18 @@ pub enum ArrowStyle {
|
||||
None,
|
||||
}
|
||||
|
||||
impl ArrowStyle {
|
||||
/// The stroke arrowhead drawn at each end of the dimension line, or None for no head.
|
||||
pub fn arrowhead(self) -> Option<crate::Arrowhead> {
|
||||
match self {
|
||||
Self::Filled => Some(crate::Arrowhead::Triangle),
|
||||
Self::Open => Some(crate::Arrowhead::TriangleOpen),
|
||||
Self::Tick => Some(crate::Arrowhead::Slash),
|
||||
Self::None => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Where the label sits across the dimension line.
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
|
||||
@@ -339,6 +339,7 @@ impl Document {
|
||||
/// Index path from the top-level layer list to `id` (e.g. `[0, 3, 1]`): the first place in
|
||||
/// tree order where `id` appears.
|
||||
pub fn index_path(&self, id: NodeId) -> Option<Vec<usize>> {
|
||||
crate::id_index::note_path_lookup();
|
||||
// The cached path, while the node there still has the id ([`id_index`]).
|
||||
let cached = self.index.get();
|
||||
match cached.as_ref().and_then(|m| m.get(&id)) {
|
||||
@@ -423,6 +424,44 @@ impl Document {
|
||||
out
|
||||
}
|
||||
|
||||
/// Every node whose id is in `ids`, in tree order (the order of [`Document::walk`]): unlike
|
||||
/// [`Document::index_paths`], an id that appears more than once (a damaged file) gives every
|
||||
/// node that has it. When the cache ([`id_index`]) holds each id once, at a path that still
|
||||
/// checks out, the nodes are found along those paths; otherwise one walk of the tree finds
|
||||
/// them. As for every cached lookup, a second node given an existing id after the cache was
|
||||
/// built is not found while the first one's cached path checks out (see [`id_index`]).
|
||||
pub fn nodes_in_order(&self, ids: impl IntoIterator<Item = NodeId>) -> Vec<&Node> {
|
||||
let want: std::collections::HashSet<NodeId, std::hash::BuildHasherDefault<crate::id_index::IdHasher>> = ids.into_iter().collect();
|
||||
// As in `index_paths`, one walk is quicker than checking the cached paths of a good share
|
||||
// of the document.
|
||||
if let Some(cache) = self.index.get().filter(|c| want.len().saturating_mul(8) < c.len()) {
|
||||
let mut paths = Vec::with_capacity(want.len());
|
||||
let cached = want.iter().all(|id| match cache.get(id) {
|
||||
Some(Some(p)) if self.node_at(&p).is_some_and(|n| n.id == *id) => {
|
||||
paths.push(p);
|
||||
true
|
||||
}
|
||||
_ => false,
|
||||
});
|
||||
if cached {
|
||||
// A node's path sorts after the paths of the nodes before it in tree order, its
|
||||
// ancestors included.
|
||||
paths.sort_unstable();
|
||||
return paths.iter().filter_map(|p| self.node_at(p)).collect();
|
||||
}
|
||||
}
|
||||
let mut out = Vec::new();
|
||||
if !want.is_empty() {
|
||||
crate::id_index::note_tree_walk();
|
||||
self.walk(|n| {
|
||||
if want.contains(&n.id) {
|
||||
out.push(n);
|
||||
}
|
||||
});
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The node at index path `path` (as [`Document::index_path`] gives it).
|
||||
pub fn node_at(&self, path: &[usize]) -> Option<&Node> {
|
||||
let (first, rest) = path.split_first()?;
|
||||
|
||||
+245
-125
@@ -82,8 +82,9 @@ impl Default for HitOptions {
|
||||
}
|
||||
}
|
||||
|
||||
/// The shapes that an image's own fills and strokes paint, each with its fill rule and the fill or
|
||||
/// stroke that paints it (none for fills and strokes that paint nothing). Effects are evaluated
|
||||
/// The shapes that an image's own fills and strokes paint, or the fills and strokes of the art of a
|
||||
/// symbol instance whose own fill or stroke has a geometry effect, each with its fill rule and the
|
||||
/// fill or stroke that paints it (none for fills and strokes that paint nothing). Effects are evaluated
|
||||
/// above this crate, so the engine registers one with [`set_image_paint`]. It looks up swatches and
|
||||
/// patterns in the document it is given.
|
||||
pub type ImagePaint = fn(Option<&Document>, &Node) -> Vec<(BezPath, FillRule, AppearanceItem)>;
|
||||
@@ -97,10 +98,58 @@ pub fn set_image_paint(f: ImagePaint) {
|
||||
let _ = IMAGE_PAINT.set(f);
|
||||
}
|
||||
|
||||
/// The shapes that the image `n`'s own fills and strokes paint ([`set_image_paint`]), none while
|
||||
/// nothing is registered.
|
||||
pub(crate) fn image_paint(doc: Option<&Document>, n: &Node) -> Vec<(BezPath, FillRule, AppearanceItem)> {
|
||||
IMAGE_PAINT.get().map_or_else(Vec::new, |f| f(doc, n))
|
||||
/// The shapes that [`ImagePaint`] gives for one object.
|
||||
type Painted = Vec<(BezPath, FillRule, AppearanceItem)>;
|
||||
|
||||
/// The shapes that the image or symbol instance `n` paints with its geometry effects
|
||||
/// ([`set_image_paint`]), none while nothing is registered. The shapes of a symbol instance of
|
||||
/// `doc` with an effect on a fill or stroke are kept on this thread ([`PAINT_KEPT`]) and measured
|
||||
/// again when `n`, a symbol of `doc` or its 9-slice guides or natural size, a pattern of `doc`,
|
||||
/// its swatches or color groups, or the
|
||||
/// [`LiveInputs`] have changed since, and on every call while `n` or the document's symbols or
|
||||
/// patterns hold a placed document or the symbols hold an image ([`symbols_hold_images`]).
|
||||
pub(crate) fn image_paint(doc: Option<&Document>, n: &Node) -> Rc<Painted> {
|
||||
let Some(f) = IMAGE_PAINT.get() else { return Rc::default() };
|
||||
let row_effects = || n.appearance.items.iter().any(|i| !i.effects().is_empty());
|
||||
let Some(d) = doc.filter(|_| matches!(n.kind, NodeKind::SymbolInstance { .. }) && row_effects()) else {
|
||||
return Rc::new(f(doc, n));
|
||||
};
|
||||
let inputs = live_inputs();
|
||||
if let Some(painted) = kept(&PAINTED, d, n, inputs) {
|
||||
return painted;
|
||||
}
|
||||
#[cfg(test)]
|
||||
PAINT_EVALUATED.with(|c| c.set(c.get() + 1));
|
||||
let painted = Rc::new(f(doc, n));
|
||||
if !symbols_hold_images(d) {
|
||||
let size = painted.iter().fold(0usize, |s, (bp, _, _)| s.saturating_add(1 + bp.elements().len()));
|
||||
keep(&PAINTED, d, n, inputs, &painted, size, PAINT_KEPT);
|
||||
}
|
||||
painted
|
||||
}
|
||||
|
||||
/// Does the art of a symbol of `doc` hold an image? The shapes its fills and strokes paint can
|
||||
/// follow its pixels, which change when its file is read again, so [`image_paint`] does not keep
|
||||
/// the shapes of an instance then.
|
||||
fn symbols_hold_images(doc: &Document) -> bool {
|
||||
let mut image = false;
|
||||
doc.symbols.iter().for_each(|s| s.art.walk(&mut |c| image |= matches!(c.kind, NodeKind::Image(_))));
|
||||
image
|
||||
}
|
||||
|
||||
/// How many symbol instances' shapes [`image_paint`] keeps on each thread: every click and every
|
||||
/// hover measures each instance whose fill or stroke has a geometry effect.
|
||||
const PAINT_KEPT: usize = 64;
|
||||
|
||||
thread_local! {
|
||||
/// The shapes [`image_paint`] keeps, the latest first.
|
||||
static PAINTED: RefCell<Vec<Evaluated<Painted>>> = const { RefCell::new(Vec::new()) };
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
thread_local! {
|
||||
/// How many symbol instances [`image_paint`] measured on this thread.
|
||||
static PAINT_EVALUATED: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
||||
}
|
||||
|
||||
/// One level of evaluation of a live object in a document, as the canvas draws it: type in an
|
||||
@@ -127,21 +176,72 @@ fn live_inputs() -> u64 {
|
||||
LIVE_ART.get().map_or(0, |(_, inputs)| inputs())
|
||||
}
|
||||
|
||||
/// A live object evaluated by [`live_art`] on this thread: the object, its document's symbols (by
|
||||
/// name and art), patterns, swatches and color groups and the [`LiveInputs`] as they were, the art
|
||||
/// and its [`art_size`].
|
||||
struct EvaluatedLive {
|
||||
/// An object evaluated by [`live_art`] or [`image_paint`] on this thread: the object, its
|
||||
/// document's symbols (by name and art), patterns, swatches and color groups, the document data
|
||||
/// that symbols' 9-slice guides and natural sizes are kept in, and the [`LiveInputs`] as they
|
||||
/// were, the result and its size.
|
||||
struct Evaluated<T> {
|
||||
node: Node,
|
||||
symbols: Vec<(String, Arc<Node>)>,
|
||||
patterns: Vec<crate::PatternDef>,
|
||||
swatches: crate::Shared<Vec<vectorcraft_color::Swatch>>,
|
||||
swatch_groups: crate::Shared<Vec<vectorcraft_color::SwatchGroup>>,
|
||||
unknown: crate::Shared<serde_json::Map<String, serde_json::Value>>,
|
||||
inputs: u64,
|
||||
art: Rc<Vec<Node>>,
|
||||
art: Rc<T>,
|
||||
size: usize,
|
||||
}
|
||||
|
||||
impl EvaluatedLive {
|
||||
/// The evaluations kept on this thread in one store, the latest first.
|
||||
type Store<T> = std::thread::LocalKey<RefCell<Vec<Evaluated<T>>>>;
|
||||
|
||||
/// The evaluation of `n` in `doc` with inputs `inputs` that `store` keeps, moved to the front.
|
||||
fn kept<T>(store: &'static Store<T>, doc: &Document, n: &Node, inputs: u64) -> Option<Rc<T>> {
|
||||
store.with_borrow_mut(|kept| {
|
||||
let i = kept.iter().position(|e| e.is_of(doc, n, inputs))?;
|
||||
let e = kept.remove(i);
|
||||
let art = e.art.clone();
|
||||
kept.insert(0, e);
|
||||
Some(art)
|
||||
})
|
||||
}
|
||||
|
||||
/// Keep `art`, of size `size`, the evaluation of `n` in `doc` with inputs `inputs`, at the front
|
||||
/// of `store`, which keeps `most` evaluations whose sizes add up to [`LIVE_KEPT_SIZE`] at most.
|
||||
/// Nothing is kept when `art` alone is larger, or when `n` or the document's symbols or patterns
|
||||
/// hold a placed document ([`holds_placed`]).
|
||||
fn keep<T>(store: &'static Store<T>, doc: &Document, n: &Node, inputs: u64, art: &Rc<T>, size: usize, most: usize) {
|
||||
if size > LIVE_KEPT_SIZE || holds_placed(doc, n) {
|
||||
return;
|
||||
}
|
||||
let e = Evaluated::new(doc, n, inputs, art, size);
|
||||
store.with_borrow_mut(|kept| {
|
||||
kept.insert(0, e);
|
||||
kept.truncate(most);
|
||||
let mut total = 0usize;
|
||||
kept.retain(|e| {
|
||||
total = total.saturating_add(e.size);
|
||||
total <= LIVE_KEPT_SIZE
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
impl<T> Evaluated<T> {
|
||||
/// `art`, of size `size`, the evaluation of `n` in `doc` with inputs `inputs`, as they are now.
|
||||
fn new(doc: &Document, n: &Node, inputs: u64, art: &Rc<T>, size: usize) -> Self {
|
||||
Self {
|
||||
node: n.clone(),
|
||||
symbols: doc.symbols.iter().map(|s| (s.name.clone(), s.art.clone())).collect(),
|
||||
patterns: doc.patterns.clone(),
|
||||
swatches: doc.swatches.clone(),
|
||||
swatch_groups: doc.swatch_groups.clone(),
|
||||
unknown: doc.unknown.clone(),
|
||||
inputs,
|
||||
art: art.clone(),
|
||||
size,
|
||||
}
|
||||
}
|
||||
|
||||
/// Is this the evaluation of `n` in `doc`, with inputs `inputs`, as they are now?
|
||||
fn is_of(&self, doc: &Document, n: &Node, inputs: u64) -> bool {
|
||||
self.inputs == inputs
|
||||
@@ -151,6 +251,7 @@ impl EvaluatedLive {
|
||||
&& self.patterns == doc.patterns
|
||||
&& self.swatches == doc.swatches
|
||||
&& self.swatch_groups == doc.swatch_groups
|
||||
&& self.unknown == doc.unknown
|
||||
}
|
||||
}
|
||||
|
||||
@@ -158,8 +259,9 @@ impl EvaluatedLive {
|
||||
/// envelope's stroke band hits it again and again, and an envelope can hold a blend.
|
||||
const LIVE_KEPT: usize = 4;
|
||||
|
||||
/// Most [`art_size`] the evaluations [`live_art`] keeps on one thread add up to. Art larger than
|
||||
/// this is not kept.
|
||||
/// Most size the evaluations [`live_art`] keeps on one thread add up to ([`art_size`]), and the
|
||||
/// shapes [`image_paint`] keeps (each shape and its path elements). Art larger than this is not
|
||||
/// kept.
|
||||
const LIVE_KEPT_SIZE: usize = 250_000;
|
||||
|
||||
/// The size of `art` for [`LIVE_KEPT_SIZE`]: its objects and the anchors of their paths.
|
||||
@@ -184,52 +286,23 @@ fn holds_placed(doc: &Document, n: &Node) -> bool {
|
||||
|
||||
thread_local! {
|
||||
/// The evaluations [`live_art`] keeps, the latest first.
|
||||
static EVALUATED: RefCell<Vec<EvaluatedLive>> = const { RefCell::new(Vec::new()) };
|
||||
static EVALUATED: RefCell<Vec<Evaluated<Vec<Node>>>> = const { RefCell::new(Vec::new()) };
|
||||
}
|
||||
|
||||
/// The art live object `n` of `doc` draws ([`set_live_art`]); [`crate::live::expand_live`] while
|
||||
/// nothing is registered. The art is evaluated again when `n`, a symbol of `doc`, a pattern of
|
||||
/// `doc`, its swatches or color groups, or the [`LiveInputs`] have changed since, and on every
|
||||
/// nothing is registered. The art is evaluated again when `n`, a symbol of `doc` or its 9-slice
|
||||
/// guides or natural size, a pattern of `doc`, its swatches or color groups, or the
|
||||
/// [`LiveInputs`] have changed since, and on every
|
||||
/// click while it or the document's symbols or patterns hold a placed document ([`holds_placed`]).
|
||||
fn live_art(doc: &Document, n: &Node) -> Rc<Vec<Node>> {
|
||||
let inputs = live_inputs();
|
||||
let kept = EVALUATED.with_borrow_mut(|kept| {
|
||||
let i = kept.iter().position(|e| e.is_of(doc, n, inputs))?;
|
||||
let e = kept.remove(i);
|
||||
let art = e.art.clone();
|
||||
kept.insert(0, e);
|
||||
Some(art)
|
||||
});
|
||||
if let Some(art) = kept {
|
||||
if let Some(art) = kept(&EVALUATED, doc, n, inputs) {
|
||||
return art;
|
||||
}
|
||||
#[cfg(test)]
|
||||
LIVE_EVALUATED.with(|c| c.set(c.get() + 1));
|
||||
let art = Rc::new(LIVE_ART.get().map_or_else(|| crate::live::expand_live(n), |(f, _)| f(Some(doc), n)));
|
||||
let size = art_size(&art);
|
||||
if size > LIVE_KEPT_SIZE || holds_placed(doc, n) {
|
||||
return art;
|
||||
}
|
||||
let symbols = doc.symbols.iter().map(|s| (s.name.clone(), s.art.clone())).collect();
|
||||
let e = EvaluatedLive {
|
||||
node: n.clone(),
|
||||
symbols,
|
||||
patterns: doc.patterns.clone(),
|
||||
swatches: doc.swatches.clone(),
|
||||
swatch_groups: doc.swatch_groups.clone(),
|
||||
inputs,
|
||||
art: art.clone(),
|
||||
size,
|
||||
};
|
||||
EVALUATED.with_borrow_mut(|kept| {
|
||||
kept.insert(0, e);
|
||||
kept.truncate(LIVE_KEPT);
|
||||
let mut total = 0usize;
|
||||
kept.retain(|e| {
|
||||
total = total.saturating_add(e.size);
|
||||
total <= LIVE_KEPT_SIZE
|
||||
});
|
||||
});
|
||||
keep(&EVALUATED, doc, n, inputs, &art, art_size(&art), LIVE_KEPT);
|
||||
art
|
||||
}
|
||||
|
||||
@@ -257,7 +330,7 @@ pub fn set_drawn_art(f: DrawnArt) {
|
||||
/// The art of an object found by [`drawn`] (none, or one object), with what it was found from, and
|
||||
/// the box round everything that art can paint.
|
||||
struct EvaluatedDrawn {
|
||||
of: EvaluatedLive,
|
||||
of: Evaluated<Vec<Node>>,
|
||||
reach: Option<Rect>,
|
||||
}
|
||||
|
||||
@@ -310,7 +383,8 @@ fn plain<T>(mask: bool, f: impl FnOnce() -> T) -> T {
|
||||
/// nothing is registered, while a [`DrawnOff`] guard lives, for objects whose art is not evaluated
|
||||
/// ([`evaluates`]), and when nothing in `n`, nor the art of a symbol an instance in it shows, has a
|
||||
/// visible effect ([`draws_effects`]). The art is evaluated again when `n`, a symbol of the
|
||||
/// document, its patterns, swatches or color groups, or the [`LiveInputs`] have changed since, and
|
||||
/// document or its 9-slice guides or natural size, its patterns, swatches or color groups, or the
|
||||
/// [`LiveInputs`] have changed since, and
|
||||
/// on every call while it holds a placed document ([`holds_placed`]). When the art kept is full, new
|
||||
/// art replaces as much other art as it needs room for, and art larger than [`LIVE_KEPT_SIZE`] is
|
||||
/// kept alone.
|
||||
@@ -332,16 +406,7 @@ fn drawn(symbols: &SymbolBoxes, n: &Node) -> Option<(Rc<Vec<Node>>, Option<Rect>
|
||||
let art = Rc::new(art.into_iter().collect::<Vec<_>>());
|
||||
let size = art_size(&art).saturating_add(art_size(std::slice::from_ref(n)));
|
||||
if !holds_placed(doc, n) {
|
||||
let of = EvaluatedLive {
|
||||
node: n.clone(),
|
||||
symbols: doc.symbols.iter().map(|s| (s.name.clone(), s.art.clone())).collect(),
|
||||
patterns: doc.patterns.clone(),
|
||||
swatches: doc.swatches.clone(),
|
||||
swatch_groups: doc.swatch_groups.clone(),
|
||||
inputs,
|
||||
art: art.clone(),
|
||||
size,
|
||||
};
|
||||
let of = Evaluated::new(doc, n, inputs, &art, size);
|
||||
DRAWN.with_borrow_mut(|(kept, total)| {
|
||||
if let Some(old) = kept.remove(&n.id) {
|
||||
*total = total.saturating_sub(old.of.size);
|
||||
@@ -607,9 +672,11 @@ fn objects_at_repeated(doc: &Document, p: Point, opt: HitOptions, scope: Option<
|
||||
|
||||
/// [`objects_at_repeated`] after `tops`, the topmost objects under `p` already found.
|
||||
fn objects_at_repeated_after(doc: &Document, p: Point, opt: HitOptions, scope: Option<NodeId>, mut tops: Vec<NodeId>) -> Vec<NodeId> {
|
||||
// Each round leaves out the objects found so far (and everything inside them).
|
||||
while let Some(top) = hit_test_skipping(doc, p, opt, &|id| tops.contains(&id), true).map(|h| h.top_object(scope)) {
|
||||
if tops.contains(&top) {
|
||||
// Each round leaves out the objects found so far (and everything inside them). `found` holds
|
||||
// the same ids as `tops`, which keeps their order.
|
||||
let mut found: HashSet<NodeId> = tops.iter().copied().collect();
|
||||
while let Some(top) = hit_test_skipping(doc, p, opt, &|id| found.contains(&id), true).map(|h| h.top_object(scope)) {
|
||||
if !found.insert(top) {
|
||||
break;
|
||||
}
|
||||
tops.push(top);
|
||||
@@ -1290,8 +1357,9 @@ fn hit_stroke(n: &Node, bp: &vectorcraft_geom::BezPath, rule: vectorcraft_geom::
|
||||
stroke_contains(bp, 0.0, opt.tol, p).then_some(HitKind::Outline)
|
||||
}
|
||||
|
||||
/// Check the body without assembling a `BezPath`. A miss near a joint or cap may still hit a
|
||||
/// miter or square cap, so the caller falls back to the full stroke check there.
|
||||
/// Check the body without assembling a `BezPath`. Near an end or joint, the caller uses the
|
||||
/// full stroke check for non-round caps or joins: Butt and Bevel can reject a radial body hit,
|
||||
/// while Miter and Square can extend beyond it.
|
||||
fn near_path_body(path: &PathData, p: Point, radius: f64, decoration_reach: f64) -> Option<(bool, bool)> {
|
||||
if !radius.is_finite() || radius < 0.0 || !decoration_reach.is_finite() || decoration_reach < 0.0 {
|
||||
return None;
|
||||
@@ -1349,6 +1417,7 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
|
||||
}
|
||||
match &n.kind {
|
||||
NodeKind::Path { path, rule, .. } => {
|
||||
let has_fill = n.appearance.has_visible_fill();
|
||||
if opt.outline
|
||||
&& let Some((hit, needs_full_check)) = near_path_body(path, p, opt.tol, 0.0)
|
||||
{
|
||||
@@ -1361,7 +1430,7 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
|
||||
}
|
||||
let mut strokes = n.appearance.painted_strokes();
|
||||
if !opt.outline
|
||||
&& n.appearance.fill().is_none_or(|f| f.paint.is_none())
|
||||
&& !has_fill
|
||||
&& let Some(s) = strokes.next()
|
||||
&& strokes.next().is_none()
|
||||
&& s.align == StrokeAlign::Center
|
||||
@@ -1376,10 +1445,10 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
|
||||
path,
|
||||
p,
|
||||
s.width / 2.0 + opt.tol,
|
||||
if s.join == crate::LineJoin::Miter || s.cap == crate::LineCap::Square { s.reach() + opt.tol } else { 0.0 },
|
||||
if s.join != crate::LineJoin::Round || s.cap != crate::LineCap::Round { s.reach() + opt.tol } else { 0.0 },
|
||||
)
|
||||
{
|
||||
if hit {
|
||||
if hit && !near_decoration {
|
||||
return Some(HitKind::Stroke);
|
||||
}
|
||||
if !near_decoration {
|
||||
@@ -1390,8 +1459,7 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
|
||||
if let Some(k) = hit_stroke(n, &bp, *rule, p, opt) {
|
||||
return Some(k);
|
||||
}
|
||||
let filled = !n.appearance.fill_paint().is_none();
|
||||
if !opt.outline && !opt.path_only && filled && fill_contains(&bp, *rule, p) {
|
||||
if !opt.outline && !opt.path_only && has_fill && fill_contains(&bp, *rule, p) {
|
||||
return Some(HitKind::Fill);
|
||||
}
|
||||
None
|
||||
@@ -1412,7 +1480,7 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
|
||||
if vectorcraft_geom::hit::distance_to_outline(&near, p) <= opt.tol {
|
||||
return Some(HitKind::Outline);
|
||||
}
|
||||
(!opt.outline && !opt.path_only && fill_contains(&near, *rule, p)).then_some(HitKind::Fill)
|
||||
(!opt.outline && !opt.path_only && n.appearance.has_visible_fill() && fill_contains(&near, *rule, p)).then_some(HitKind::Fill)
|
||||
}
|
||||
// The type path lies within the bounds: they rule out the rest before it is measured.
|
||||
NodeKind::Text(t) if opt.type_path_only => {
|
||||
@@ -1436,22 +1504,21 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
|
||||
if opt.outline {
|
||||
return None;
|
||||
}
|
||||
image_paint(Some(symbols.document()), n).iter().rev().find_map(|(bp, rule, item)| match item {
|
||||
AppearanceItem::Stroke(s) => s.hits(bp, *rule, p, opt.tol).then_some(HitKind::Stroke),
|
||||
AppearanceItem::Fill(_) => (!opt.path_only && fill_contains(bp, *rule, p)).then_some(HitKind::Fill),
|
||||
})
|
||||
hit_painted(n, p, opt, symbols)
|
||||
}
|
||||
NodeKind::Text(_) | NodeKind::PlacedDocument(_) => {
|
||||
n.geometric_bounds_with(symbols).filter(|b| b.inflate(opt.tol, opt.tol).contains(p)).map(|_| HitKind::Bounds)
|
||||
}
|
||||
// A symbol instance is hit within its bounds, and outside them where its art paints
|
||||
// ([`instance_art_hit`]). In the art of another instance walked outside that instance's
|
||||
// bounds, it is hit only where its own art paints ([`ArtOnly`]).
|
||||
// ([`instance_art_hit`]) or where the geometry effects of its active fill or stroke reshape
|
||||
// the art it draws ([`image_paint`]) except in outline mode. In the art of another instance
|
||||
// walked outside that instance's bounds, it is hit only where its own art paints
|
||||
// ([`ArtOnly`]).
|
||||
NodeKind::SymbolInstance { .. } => {
|
||||
if !ArtOnly::on() && n.geometric_bounds_with(symbols).is_some_and(|b| b.inflate(opt.tol, opt.tol).contains(p)) {
|
||||
return Some(HitKind::Bounds);
|
||||
}
|
||||
instance_art_hit(n, p, opt, symbols)
|
||||
instance_art_hit(n, p, opt, symbols).or_else(|| if opt.outline { None } else { hit_painted(n, p, opt, symbols) })
|
||||
}
|
||||
// A blend or an envelope is hit within its bounds, and outside them where its evaluated
|
||||
// art paints: a blend's keys and steps on a spine can reach past the keys and the spine,
|
||||
@@ -1478,6 +1545,16 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
|
||||
}
|
||||
}
|
||||
|
||||
/// What a click at `p` hits among the shapes that the fills and strokes of `n` (an image or a
|
||||
/// symbol instance) paint with their geometry effects ([`image_paint`]), the frontmost first: a
|
||||
/// stroke along its shape, a fill inside it except with Selection by Path Only.
|
||||
fn hit_painted(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Option<HitKind> {
|
||||
image_paint(Some(symbols.document()), n).iter().rev().find_map(|(bp, rule, item)| match item {
|
||||
AppearanceItem::Stroke(s) => s.hits(bp, *rule, p, opt.tol).then_some(HitKind::Stroke),
|
||||
AppearanceItem::Fill(_) => (!opt.path_only && fill_contains(bp, *rule, p)).then_some(HitKind::Fill),
|
||||
})
|
||||
}
|
||||
|
||||
/// Is `p` within `tol` of the type path of `t` (in `n`), what "Type Object Selection by Path
|
||||
/// Only" picks type by: its baselines ([`crate::TextObject::baselines`]), area type's frame and
|
||||
/// type on a path's path, drawn through `n`'s perspective projection if it has one.
|
||||
@@ -2019,7 +2096,9 @@ pub fn compound_part_at(n: &Node, p: Point, tol: f64) -> Option<NodeId> {
|
||||
/// Objects (children of layers, or of `scope` in isolation mode) touched by a marquee rect, leaving
|
||||
/// out those on a locked artboard ([`crate::LockedArtboards::holds_id`]). Symbol instances are measured
|
||||
/// by their art ([`Node::geometric_bounds_with`]), and outside that box, except in outline, they are
|
||||
/// touched where the live geometry effects of a clipping path in their art show it. The art of a clip group or of a layer with a
|
||||
/// touched where the live geometry effects of a clipping path in their art show it, or where the
|
||||
/// geometry effects of their active fill or stroke reshape the art. Images are also touched, except
|
||||
/// in outline, where their own fills and strokes paint outside their box. The art of a clip group or of a layer with a
|
||||
/// clipping mask counts only when the marquee meets the region its clipping path clips to, and then
|
||||
/// only within that region's bounds. In isolation mode the clipping mask of the isolated container,
|
||||
/// or of the parent of the single object isolated, does not limit the marquee, as it does not limit
|
||||
@@ -2027,20 +2106,39 @@ pub fn compound_part_at(n: &Node, p: Point, tol: f64) -> Option<NodeId> {
|
||||
/// the members of a group or layer with geometry effects of its own, are touched where the art those
|
||||
/// effects draw lies ([`set_drawn_art`]), as clicks hit them.
|
||||
pub fn marquee(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool) -> Vec<NodeId> {
|
||||
marquee_with(doc, r, scope, leaves, false, false)
|
||||
marquee_with(doc, r, scope, leaves, false, false, false)
|
||||
}
|
||||
|
||||
/// [`marquee`] in the view the canvas shows: with `outline` (Outline view), and below a layer
|
||||
/// whose Preview is off, a clipping path counts by its plain shapes, without its live effects, as
|
||||
/// the clicks of [`HitOptions::outline`] do.
|
||||
pub fn marquee_in_view(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, outline: bool) -> Vec<NodeId> {
|
||||
marquee_with(doc, r, scope, leaves, false, outline)
|
||||
/// the clicks of [`HitOptions::outline`] do. With `skip_guides` (Lock Guides is on or the guides
|
||||
/// are hidden, as [`HitOptions::skip_guides`]), the paths made into guides are not touched, at the
|
||||
/// top or inside a group, so a group is not taken for a guide in it (#8538).
|
||||
pub fn marquee_in_view(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, outline: bool, skip_guides: bool) -> Vec<NodeId> {
|
||||
marquee_with(doc, r, scope, leaves, false, outline, skip_guides)
|
||||
}
|
||||
|
||||
/// Candidates for whole-object enclosure by a loop bounded by `r`. Eligibility and group
|
||||
/// traversal follow [`marquee_in_view`]; compounds contribute the complete path they paint.
|
||||
pub fn enclosure_candidates(doc: &Document, r: Rect, scope: Option<NodeId>, outline: bool) -> Vec<NodeId> {
|
||||
marquee_with(doc, r, scope, true, true, outline)
|
||||
pub fn enclosure_candidates(doc: &Document, r: Rect, scope: Option<NodeId>, outline: bool, skip_guides: bool) -> Vec<NodeId> {
|
||||
marquee_with(doc, r, scope, true, true, outline, skip_guides)
|
||||
}
|
||||
|
||||
/// What a marquee ([`marquee_with`]) takes, besides where it is: whether a compound path is
|
||||
/// touched by every path it paints (`whole_compounds`, for an enclosing loop's candidates), and
|
||||
/// whether the paths made into guides are left out (`skip_guides`: Lock Guides is on or the
|
||||
/// guides are hidden, [`HitOptions::skip_guides`] for the marquee).
|
||||
#[derive(Clone, Copy)]
|
||||
struct Rules {
|
||||
whole_compounds: bool,
|
||||
skip_guides: bool,
|
||||
}
|
||||
|
||||
impl Rules {
|
||||
/// Is `n` a path made into a guide that the marquee leaves out?
|
||||
fn skips(self, n: &Node) -> bool {
|
||||
self.skip_guides && matches!(n.kind, NodeKind::Path { guide: true, .. })
|
||||
}
|
||||
}
|
||||
|
||||
/// Is `n` a layer whose Preview is off (its art is drawn and clicked in outline)?
|
||||
@@ -2048,8 +2146,17 @@ fn previews_off(n: &Node) -> bool {
|
||||
matches!(n.kind, NodeKind::Layer { preview: false, .. })
|
||||
}
|
||||
|
||||
fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, whole_compounds: bool, outline: bool) -> Vec<NodeId> {
|
||||
fn marquee_with(
|
||||
doc: &Document,
|
||||
r: Rect,
|
||||
scope: Option<NodeId>,
|
||||
leaves: bool,
|
||||
whole_compounds: bool,
|
||||
outline: bool,
|
||||
skip_guides: bool,
|
||||
) -> Vec<NodeId> {
|
||||
let _walk = ArtWalk::open();
|
||||
let rules = Rules { whole_compounds, skip_guides };
|
||||
let mut out = Vec::new();
|
||||
// The locks first: they copy the kept art boxes that `symbols` takes, and `symbols` keeps theirs.
|
||||
let locks = doc.locked_artboards_kept();
|
||||
@@ -2063,7 +2170,7 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
|
||||
Some(c) => {
|
||||
// In an isolated clip group, its members by their own geometry, as clicks take
|
||||
// them ([`edits_inside`]).
|
||||
let drawn = if s.clips() { None } else { touched_in_art(s, &symbols, r, whole_compounds, outline || previews_off(s)) };
|
||||
let drawn = if s.clips() { None } else { touched_in_art(s, &symbols, r, rules, outline || previews_off(s)) };
|
||||
c.iter()
|
||||
.enumerate()
|
||||
.filter(|(i, c)| !c.is_ruler_guide() && !shaper_hides(s, *i, scope))
|
||||
@@ -2085,7 +2192,7 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
|
||||
.layers
|
||||
.iter()
|
||||
.filter(|l| l.visible && !l.locked && !l.is_template() && doc.pattern_edit.as_ref().is_none_or(|e| e.layer == l.id))
|
||||
.flat_map(|l| layer_objects(l, &symbols, r, outline, whole_compounds, None))
|
||||
.flat_map(|l| layer_objects(l, &symbols, r, outline, rules, None))
|
||||
.collect(),
|
||||
};
|
||||
/// The objects of layer `l`, each with the part of `r` that the clipping masks of `l` and of
|
||||
@@ -2094,17 +2201,10 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
|
||||
/// shapes ([`mask_marquee`]). In a layer whose own geometry effects reshape its art, each object
|
||||
/// comes with the objects that art touches ([`touched_in_art`]), `drawn` when a layer around
|
||||
/// `l` has such effects.
|
||||
fn layer_objects<'a>(
|
||||
l: &'a Node,
|
||||
s: &SymbolBoxes,
|
||||
r: Rect,
|
||||
outline: bool,
|
||||
whole_compounds: bool,
|
||||
drawn: Option<Rc<HashSet<NodeId>>>,
|
||||
) -> Vec<Top<'a>> {
|
||||
fn layer_objects<'a>(l: &'a Node, s: &SymbolBoxes, r: Rect, outline: bool, rules: Rules, drawn: Option<Rc<HashSet<NodeId>>>) -> Vec<Top<'a>> {
|
||||
let mut out = vec![];
|
||||
let outline = outline || previews_off(l);
|
||||
let drawn = drawn.or_else(|| touched_in_art(l, s, r, whole_compounds, outline));
|
||||
let drawn = drawn.or_else(|| touched_in_art(l, s, r, rules, outline));
|
||||
let inner = marquee_in_parent(l, r, outline);
|
||||
for (i, c) in l.children().into_iter().flatten().enumerate() {
|
||||
if c.is_layer() {
|
||||
@@ -2113,7 +2213,7 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
|
||||
&& !c.locked
|
||||
&& !c.is_template()
|
||||
{
|
||||
out.extend(layer_objects(c, s, inner, outline, whole_compounds, drawn.clone()));
|
||||
out.extend(layer_objects(c, s, inner, outline, rules, drawn.clone()));
|
||||
}
|
||||
} else if !c.is_ruler_guide() {
|
||||
if drawn.is_some() {
|
||||
@@ -2130,12 +2230,12 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
|
||||
/// The ids of the objects of the art that group or layer `n` draws with its own geometry
|
||||
/// effects ([`drawn_art`]) that the marquee `r` touches, as [`collect_leaves`] collects them.
|
||||
/// `None` in outline and when it has no such effects.
|
||||
fn touched_in_art(n: &Node, s: &SymbolBoxes, r: Rect, whole_compounds: bool, outline: bool) -> Option<Rc<HashSet<NodeId>>> {
|
||||
fn touched_in_art(n: &Node, s: &SymbolBoxes, r: Rect, rules: Rules, outline: bool) -> Option<Rc<HashSet<NodeId>>> {
|
||||
let art = drawn_art(s, n, outline)?;
|
||||
let _off = DrawnOff::set();
|
||||
let mut ids = vec![];
|
||||
for a in art.iter().filter(|a| a.visible) {
|
||||
collect_leaves(a, s, r, None, whole_compounds, false, &mut ids);
|
||||
collect_leaves(a, s, r, None, rules, false, &mut ids);
|
||||
}
|
||||
Some(Rc::new(ids.into_iter().collect()))
|
||||
}
|
||||
@@ -2188,14 +2288,20 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
|
||||
/// Does the marquee `r` touch `n`? It skips the children of a Shaper Group that clicks skip
|
||||
/// ([`shaper_hides`]). An Intertwine group is touched by its members, and a repeat is touched
|
||||
/// by the copies it draws, as clicks hit them. Objects of every other kind except paths,
|
||||
/// compound paths, layers and groups are touched by their box. A clipping path is touched by
|
||||
/// its own geometry ([`mask_marquee`]) and on the edge of its region ([`clip_edge_touches`]).
|
||||
fn touches(n: &Node, s: &SymbolBoxes, r: Rect, scope: Option<NodeId>, whole_compounds: bool, outline: bool) -> bool {
|
||||
/// compound paths, layers and groups are touched by their box, and an image or a symbol
|
||||
/// instance also where its fills and strokes paint outside it ([`painted_touches`]). A clipping
|
||||
/// path is touched by its own geometry ([`mask_marquee`]) and on the edge of its region
|
||||
/// ([`clip_edge_touches`]).
|
||||
fn touches(n: &Node, s: &SymbolBoxes, r: Rect, scope: Option<NodeId>, rules: Rules, outline: bool) -> bool {
|
||||
// Locked or hidden guides are not touched ([`Rules::skips`]).
|
||||
if rules.skips(n) {
|
||||
return false;
|
||||
}
|
||||
// A path or compound path whose geometry effects reshape it, or a group or layer whose own
|
||||
// geometry effects reshape its members, is touched where that art is drawn ([`drawn_art`]).
|
||||
if let Some(art) = drawn_art(s, n, outline || previews_off(n)) {
|
||||
let _off = DrawnOff::set();
|
||||
return art.iter().any(|a| a.visible && touches(a, s, r, None, whole_compounds, false));
|
||||
return art.iter().any(|a| a.visible && touches(a, s, r, None, rules, false));
|
||||
}
|
||||
match &n.kind {
|
||||
NodeKind::Path { path, .. } => vectorcraft_geom::hit::intersects_rect(path, r),
|
||||
@@ -2206,25 +2312,41 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
|
||||
c.visible
|
||||
&& !shaper_hides(n, i, scope)
|
||||
&& if i == 0 && n.clips() {
|
||||
plain(true, || mask_marquee(n, r).is_some_and(|r| touches(c, s, r, scope, whole_compounds, outline)))
|
||||
plain(true, || mask_marquee(n, r).is_some_and(|r| touches(c, s, r, scope, rules, outline)))
|
||||
|| clip_edge_touches(c, r, outline)
|
||||
} else {
|
||||
inner.is_some_and(|r| touches(c, s, r, scope, whole_compounds, outline))
|
||||
inner.is_some_and(|r| touches(c, s, r, scope, rules, outline))
|
||||
}
|
||||
})
|
||||
}
|
||||
NodeKind::Compound { children, .. } if whole_compounds => {
|
||||
children.iter().filter_map(|c| c.path_data()).any(|path| vectorcraft_geom::hit::intersects_rect(path, r))
|
||||
NodeKind::Compound { children, .. } if rules.whole_compounds => {
|
||||
// Guide contours left out ([`Rules::skips`]) don't make the compound a candidate.
|
||||
children.iter().filter(|c| !rules.skips(c)).filter_map(|c| c.path_data()).any(|path| vectorcraft_geom::hit::intersects_rect(path, r))
|
||||
}
|
||||
NodeKind::Compound { children, .. } => children.iter().any(|c| c.visible && touches(c, s, r, scope, whole_compounds, outline)),
|
||||
NodeKind::Repeat(spec) => spec.expand(Some(s.document())).iter().any(|copy| touches(copy, s, r, scope, whole_compounds, outline)),
|
||||
NodeKind::Compound { children, .. } => children.iter().any(|c| c.visible && touches(c, s, r, scope, rules, outline)),
|
||||
NodeKind::Repeat(spec) => spec.expand(Some(s.document())).iter().any(|copy| touches(copy, s, r, scope, rules, outline)),
|
||||
// A symbol instance is touched by its box, and outside it where the live geometry
|
||||
// effects of a clipping path in its art show the art. In the art of another instance
|
||||
// walked outside that instance's box, it is touched only by its own art ([`ArtOnly`]).
|
||||
NodeKind::SymbolInstance { .. } => !ArtOnly::on() && box_touches(n, s, r) || !outline && instance_art_touches(n, s, r, whole_compounds),
|
||||
// effects of a clipping path in its art show the art, or where the geometry effects of
|
||||
// its active fill or stroke reshape the art ([`painted_touches`]). In the art of another
|
||||
// instance walked outside that instance's box, it is touched only by its own art
|
||||
// ([`ArtOnly`]) and those shapes.
|
||||
NodeKind::SymbolInstance { .. } => {
|
||||
!ArtOnly::on() && box_touches(n, s, r) || !outline && (instance_art_touches(n, s, r, rules) || painted_touches(n, s, r))
|
||||
}
|
||||
// An image is touched by its box, and outside it where its own fills and strokes paint.
|
||||
NodeKind::Image(_) => box_touches(n, s, r) || !outline && painted_touches(n, s, r),
|
||||
_ => box_touches(n, s, r),
|
||||
}
|
||||
}
|
||||
/// Does the marquee `r` touch the shapes that the fills and strokes of image or symbol
|
||||
/// instance `n` paint ([`image_paint`]), where clicks hit them ([`hit_painted`])? Each shape is
|
||||
/// touched by its path, as a path is ([`vectorcraft_geom::hit::intersects_rect`]). Only when
|
||||
/// `r` meets the reach of `n` ([`Node::reach_bounds_with`]).
|
||||
fn painted_touches(n: &Node, s: &SymbolBoxes, r: Rect) -> bool {
|
||||
let meets = |b: Rect| b.x0 <= r.x1 && r.x0 <= b.x1 && b.y0 <= r.y1 && r.y0 <= b.y1;
|
||||
n.reach_bounds_with(s).is_some_and(meets)
|
||||
&& image_paint(Some(s.document()), n).iter().any(|(bp, _, _)| vectorcraft_geom::hit::intersects_rect(&PathData::from_bezpath(bp), r))
|
||||
}
|
||||
/// Does the marquee `r` touch the box of `n`? A box with no width or no height (an instance of
|
||||
/// a symbol that draws a straight line) is touched where the marquee crosses it.
|
||||
fn box_touches(n: &Node, s: &SymbolBoxes, r: Rect) -> bool {
|
||||
@@ -2238,7 +2360,7 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
|
||||
/// ([`SymbolBoxes::art`]), or for any art while [`ArtOnly`] is on, and only when `r` meets the
|
||||
/// instance's reach ([`Node::reach_bounds_with`]): elsewhere the art lies within the instance's
|
||||
/// box. Not once the marquee has placed as many objects of symbol art as [`ArtWalk`] allows.
|
||||
fn instance_art_touches(n: &Node, s: &SymbolBoxes, r: Rect, whole_compounds: bool) -> bool {
|
||||
fn instance_art_touches(n: &Node, s: &SymbolBoxes, r: Rect, rules: Rules) -> bool {
|
||||
let NodeKind::SymbolInstance { symbol, .. } = &n.kind else { return false };
|
||||
let meets = |b: Rect| b.x0 <= r.x1 && r.x0 <= b.x1 && b.y0 <= r.y1 && r.y0 <= b.y1;
|
||||
if s.art(symbol).is_none_or(|a| a.reshaped.is_none() && !ArtOnly::on()) || !n.reach_bounds_with(s).is_some_and(meets) {
|
||||
@@ -2255,15 +2377,15 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
|
||||
#[cfg(test)]
|
||||
ARTS_WALKED.with(|c| c.set(c.get() + 1));
|
||||
let _art_only = ArtOnly::set();
|
||||
art.place(&art.art, None).is_some_and(|placed| placed.visible && touches(&placed, s, r, None, whole_compounds, false))
|
||||
art.place(&art.art, None).is_some_and(|placed| placed.visible && touches(&placed, s, r, None, rules, false))
|
||||
}
|
||||
fn collect_leaves(n: &Node, s: &SymbolBoxes, r: Rect, scope: Option<NodeId>, whole_compounds: bool, outline: bool, out: &mut Vec<NodeId>) {
|
||||
fn collect_leaves(n: &Node, s: &SymbolBoxes, r: Rect, scope: Option<NodeId>, rules: Rules, outline: bool, out: &mut Vec<NodeId>) {
|
||||
match &n.kind {
|
||||
NodeKind::Layer { children, .. } | NodeKind::Group { children, .. } | NodeKind::Intertwine { children } => {
|
||||
let outline = outline || previews_off(n);
|
||||
// The members that the art its own geometry effects draw touches, and a group whose
|
||||
// own fills and strokes that art paints, as clicks hit it ([`member_chain`]).
|
||||
if let Some(drawn) = touched_in_art(n, s, r, whole_compounds, outline) {
|
||||
if let Some(drawn) = touched_in_art(n, s, r, rules, outline) {
|
||||
if drawn.contains(&n.id) && !n.is_layer() {
|
||||
out.push(n.id);
|
||||
}
|
||||
@@ -2278,18 +2400,18 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
|
||||
if i == 0 && n.clips() {
|
||||
let before = out.len();
|
||||
if let Some(r) = mask_marquee(n, r) {
|
||||
plain(true, || collect_leaves(c, s, r, scope, whole_compounds, outline, out));
|
||||
plain(true, || collect_leaves(c, s, r, scope, rules, outline, out));
|
||||
}
|
||||
if out.len() == before && is_leaf(c) && clip_edge_touches(c, r, outline) {
|
||||
out.push(c.id);
|
||||
}
|
||||
} else if let Some(r) = inner {
|
||||
collect_leaves(c, s, r, scope, whole_compounds, outline, out);
|
||||
collect_leaves(c, s, r, scope, rules, outline, out);
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
if touches(n, s, r, scope, whole_compounds, outline) {
|
||||
if touches(n, s, r, scope, rules, outline) {
|
||||
out.push(n.id);
|
||||
}
|
||||
}
|
||||
@@ -2324,14 +2446,12 @@ fn marquee_with(doc: &Document, r: Rect, scope: Option<NodeId>, leaves: bool, wh
|
||||
if leaves {
|
||||
let before = out.len();
|
||||
if let Some(r) = r {
|
||||
collect_leaves(t, &symbols, r, scope, whole_compounds, outline, &mut out);
|
||||
collect_leaves(t, &symbols, r, scope, rules, outline, &mut out);
|
||||
}
|
||||
if edge.is_some_and(|e| out.len() == before && is_leaf(t) && clip_edge_touches(t, e, outline)) {
|
||||
out.push(t.id);
|
||||
}
|
||||
} else if r.is_some_and(|r| touches(t, &symbols, r, scope, whole_compounds, outline))
|
||||
|| edge.is_some_and(|e| clip_edge_touches(t, e, outline))
|
||||
{
|
||||
} else if r.is_some_and(|r| touches(t, &symbols, r, scope, rules, outline)) || edge.is_some_and(|e| clip_edge_touches(t, e, outline)) {
|
||||
out.push(t.id);
|
||||
}
|
||||
}
|
||||
|
||||
+346
-7
@@ -164,8 +164,8 @@ fn clicks_in_a_clip_group_evaluate_its_clipping_paths_region_once_until_it_chang
|
||||
// So with a marquee across the art's left edge: in the view, only in Outline view. The
|
||||
// clipping path's own left edge lies there too, and counts in both.
|
||||
let edge = Rect::new(-5.0, 40.0, 5.0, 60.0);
|
||||
assert_eq!(marquee_in_view(&d, edge, None, true, false), [mask_id]);
|
||||
assert_eq!(marquee_in_view(&d, edge, None, true, true), [mask_id, art_id]);
|
||||
assert_eq!(marquee_in_view(&d, edge, None, true, false, false), [mask_id]);
|
||||
assert_eq!(marquee_in_view(&d, edge, None, true, true, false), [mask_id, art_id]);
|
||||
// `marquee_in` measures by the plain shapes, as its callers clip by them.
|
||||
assert!(marquee_in(d.node(g).unwrap(), edge).is_some());
|
||||
// Hidden, the effect no longer moves the region.
|
||||
@@ -489,8 +489,8 @@ fn a_marquee_touches_a_paths_shifted_art_not_its_source() {
|
||||
for leaves in [false, true] {
|
||||
assert_eq!(marquee(&d, drawn, None, leaves), [a], "where it is drawn");
|
||||
assert!(marquee(&d, own, None, leaves).is_empty(), "its own place");
|
||||
assert!(marquee_in_view(&d, drawn, None, leaves, true).is_empty(), "outline: no drawn art");
|
||||
assert_eq!(marquee_in_view(&d, own, None, leaves, true), [a], "outline: its own place");
|
||||
assert!(marquee_in_view(&d, drawn, None, leaves, true, false).is_empty(), "outline: no drawn art");
|
||||
assert_eq!(marquee_in_view(&d, own, None, leaves, true, false), [a], "outline: its own place");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -870,6 +870,68 @@ fn a_selected_guide_hidden_by_a_mask_counts_only_while_guides_can_be_clicked() {
|
||||
assert_eq!(selected_hidden_at(&d, hidden, HitOptions { skip_guides: true, ..opt }, &[guide_id]), None);
|
||||
}
|
||||
|
||||
/// #8538: while guides are locked or hidden (`skip_guides`), a marquee touches no guide path, at
|
||||
/// the top of a layer or in a group (the group is not taken for it), nor in a group in a group,
|
||||
/// with leaves or without. The group's other members still take it, and with the guides unlocked
|
||||
/// the guide does.
|
||||
#[test]
|
||||
fn a_marquee_skips_guide_paths_in_groups_while_guides_are_locked() {
|
||||
let mut d = Document::new(300.0, 200.0);
|
||||
let l = d.layers[0].id;
|
||||
let guide = |d: &mut Document, r: Rect| {
|
||||
let mut n = Node::path(d.alloc_id(), shapes::rectangle(r), Appearance::default_art());
|
||||
if let NodeKind::Path { guide, .. } = &mut n.kind {
|
||||
*guide = true;
|
||||
}
|
||||
n
|
||||
};
|
||||
let top = guide(&mut d, Rect::new(0.0, 0.0, 20.0, 20.0));
|
||||
let inner = guide(&mut d, Rect::new(100.0, 0.0, 120.0, 20.0));
|
||||
let art = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(200.0, 0.0, 220.0, 20.0)), Appearance::default_art());
|
||||
let (top_id, inner_id, art_id) = (top.id, inner.id, art.id);
|
||||
let (outer_id, nested_id) = (d.alloc_id(), d.alloc_id());
|
||||
let nested = Node::group(nested_id, vec![Arc::new(inner)]);
|
||||
d.insert(Some(l), 0, top).unwrap();
|
||||
d.insert(Some(l), 1, Node::group(outer_id, vec![Arc::new(nested), Arc::new(art)])).unwrap();
|
||||
let (on_top, on_inner, on_art) = (Rect::new(-5.0, 5.0, 5.0, 10.0), Rect::new(95.0, 5.0, 105.0, 10.0), Rect::new(195.0, 5.0, 205.0, 10.0));
|
||||
for leaves in [false, true] {
|
||||
let m = |r: Rect, skip: bool| marquee_in_view(&d, r, None, leaves, false, skip);
|
||||
assert!(m(on_top, true).is_empty(), "a guide at the top, leaves {leaves}");
|
||||
assert!(m(on_inner, true).is_empty(), "a guide in a group in a group, leaves {leaves}");
|
||||
assert!(m(Rect::new(0.0, 0.0, 300.0, 200.0), true).iter().all(|id| ![top_id, inner_id].contains(id)), "all, leaves {leaves}");
|
||||
assert_eq!(m(on_art, true), [if leaves { art_id } else { outer_id }], "the group's art, leaves {leaves}");
|
||||
// Unlocked: the guides are touched.
|
||||
assert_eq!(m(on_top, false), [top_id], "unlocked, leaves {leaves}");
|
||||
assert_eq!(m(on_inner, false), [if leaves { inner_id } else { outer_id }], "unlocked, leaves {leaves}");
|
||||
}
|
||||
// An enclosing loop's candidates leave them out alike.
|
||||
assert!(enclosure_candidates(&d, on_inner, None, false, true).is_empty());
|
||||
assert_eq!(enclosure_candidates(&d, on_inner, None, false, false), [inner_id]);
|
||||
}
|
||||
|
||||
/// #8538: an enclosing loop's candidates leave out a compound path whose touched contours are all
|
||||
/// locked or hidden guides, as the marquee does.
|
||||
#[test]
|
||||
fn guide_contours_do_not_make_a_compound_an_enclosure_candidate() {
|
||||
let mut d = Document::new(300.0, 200.0);
|
||||
let l = d.layers[0].id;
|
||||
let part = |d: &mut Document, r: Rect| {
|
||||
let mut n = Node::path(d.alloc_id(), shapes::rectangle(r), Appearance::default_art());
|
||||
if let NodeKind::Path { guide, .. } = &mut n.kind {
|
||||
*guide = true;
|
||||
}
|
||||
Arc::new(n)
|
||||
};
|
||||
let (a, b) = (part(&mut d, Rect::new(10.0, 10.0, 50.0, 50.0)), part(&mut d, Rect::new(20.0, 20.0, 40.0, 40.0)));
|
||||
let id = d.alloc_id();
|
||||
let mut compound = Node::group(id, vec![]);
|
||||
compound.kind = NodeKind::Compound { children: vec![a, b], rule: Default::default() };
|
||||
d.insert(Some(l), 0, compound).unwrap();
|
||||
let r = Rect::new(0.0, 0.0, 60.0, 60.0);
|
||||
assert!(enclosure_candidates(&d, r, None, false, true).is_empty(), "locked or hidden");
|
||||
assert_eq!(enclosure_candidates(&d, r, None, false, false), [id], "shown and unlocked");
|
||||
}
|
||||
|
||||
/// A selected path in a Shaper group's original shapes, where an outer mask hides it, counts only
|
||||
/// while those shapes can be clicked (Construction mode, with them isolated), however deep it
|
||||
/// lies in them.
|
||||
@@ -1262,6 +1324,60 @@ fn evaluated_art_is_not_kept_while_a_placed_document_may_show_in_it() {
|
||||
assert_eq!(evaluated(), before + 2);
|
||||
}
|
||||
|
||||
/// For instances of the symbol "Painted", a fill that paints the square from (300, 0) to
|
||||
/// (320, 20); nothing for anything else.
|
||||
fn painted_far_away(_: Option<&Document>, n: &Node) -> Vec<(BezPath, FillRule, AppearanceItem)> {
|
||||
match &n.kind {
|
||||
NodeKind::SymbolInstance { symbol, .. } if symbol == "Painted" => {
|
||||
let square = shapes::rectangle(Rect::new(300.0, 0.0, 320.0, 20.0)).to_bezpath();
|
||||
vec![(square, FillRule::NonZero, AppearanceItem::Fill(crate::FillLayer::new(Paint::solid(Color::rgb(1.0, 0.0, 0.0)))))]
|
||||
}
|
||||
_ => vec![],
|
||||
}
|
||||
}
|
||||
|
||||
/// Clicks and hovers measure the shapes a symbol instance's fill and stroke effects paint once,
|
||||
/// and again only after the instance or the symbols change.
|
||||
#[test]
|
||||
fn clicks_measure_a_symbol_instances_painted_shapes_once_until_it_changes() {
|
||||
set_image_paint(painted_far_away);
|
||||
let mut d = Document::new(1000.0, 1000.0);
|
||||
let l = d.layers[0].id;
|
||||
let art = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(0.0, 0.0, 20.0, 20.0)), Appearance::default_art());
|
||||
d.symbols.push(crate::Symbol { dynamic: false, name: "Painted".into(), art: Arc::new(art) });
|
||||
let inst = d.alloc_id();
|
||||
let mut n = Node::new(inst, NodeKind::SymbolInstance { symbol: "Painted".into(), xf: vectorcraft_geom::Affine::IDENTITY });
|
||||
n.appearance = Appearance::default_art().into();
|
||||
let offset = crate::Effect { id: "path.offsetPath".into(), params: serde_json::json!({"offset": 10}), visible: true };
|
||||
n.appearance.items[0].effects_mut().push(offset);
|
||||
d.insert(Some(l), 0, n).unwrap();
|
||||
let measured = || PAINT_EVALUATED.with(std::cell::Cell::get);
|
||||
let before = measured();
|
||||
let at = |d: &Document, x: f64| hit_test(d, Point::new(x, 10.0), HitOptions::default()).map(|h| h.leaf);
|
||||
assert_eq!(at(&d, 310.0), Some(inst), "a click where the instance's fill paints");
|
||||
assert_eq!(at(&d, 500.0), None);
|
||||
assert_eq!(at(&d, 10.0), Some(inst));
|
||||
assert_eq!(measured(), before + 1);
|
||||
d.node_mut(inst).unwrap().appearance.items[0].effects_mut()[0].params = serde_json::json!({"offset": 12});
|
||||
assert_eq!(at(&d, 310.0), Some(inst));
|
||||
assert_eq!(measured(), before + 2, "a changed instance is measured again");
|
||||
let other = Node::path(d.alloc_id(), shapes::rectangle(Rect::new(0.0, 0.0, 5.0, 5.0)), Appearance::default_art());
|
||||
d.symbols.push(crate::Symbol { dynamic: false, name: "Other".into(), art: Arc::new(other) });
|
||||
assert_eq!(at(&d, 310.0), Some(inst));
|
||||
assert_eq!(measured(), before + 3, "changed symbols measure it again");
|
||||
assert_eq!(at(&d, 310.0), Some(inst));
|
||||
assert_eq!(measured(), before + 3);
|
||||
// An image's pixels change when its file is read again, so with one in a symbol's art every
|
||||
// click measures the instance.
|
||||
let xf = vectorcraft_geom::Affine::IDENTITY;
|
||||
let im = crate::ImageObject { key: "k".into(), width: 10, height: 10, xf, link: None, placement: Default::default(), pixels: None };
|
||||
let image = Node::new(d.alloc_id(), NodeKind::Image(Box::new(im)));
|
||||
d.symbols.push(crate::Symbol { dynamic: false, name: "Photo".into(), art: Arc::new(image) });
|
||||
assert_eq!(at(&d, 310.0), Some(inst));
|
||||
assert_eq!(at(&d, 310.0), Some(inst));
|
||||
assert!(measured() >= before + 5, "each click measures it: {}", measured() - before);
|
||||
}
|
||||
|
||||
/// A kept evaluation is the evaluation of the object only while the fonts and plug-ins
|
||||
/// ([`LiveInputs`]) are as they were.
|
||||
#[test]
|
||||
@@ -1274,19 +1390,32 @@ fn a_kept_evaluation_is_stale_after_the_live_inputs_change() {
|
||||
}
|
||||
|
||||
/// An evaluation of `n` in `d`, with inputs 7, holding no symbols, patterns or art.
|
||||
fn kept_evaluation(d: &Document, n: &Node) -> EvaluatedLive {
|
||||
EvaluatedLive {
|
||||
fn kept_evaluation(d: &Document, n: &Node) -> Evaluated<Vec<Node>> {
|
||||
Evaluated {
|
||||
node: n.clone(),
|
||||
symbols: vec![],
|
||||
patterns: vec![],
|
||||
swatches: d.swatches.clone(),
|
||||
swatch_groups: d.swatch_groups.clone(),
|
||||
unknown: d.unknown.clone(),
|
||||
inputs: 7,
|
||||
art: std::rc::Rc::new(vec![]),
|
||||
size: 0,
|
||||
}
|
||||
}
|
||||
|
||||
/// A kept evaluation is stale once a symbol's 9-slice guides or natural size change: they place
|
||||
/// the symbol's art, and the document keeps them apart from the symbols.
|
||||
#[test]
|
||||
fn a_kept_evaluation_is_stale_after_a_symbols_placement_changes() {
|
||||
let mut d = Document::new(100.0, 100.0);
|
||||
let n = Node::path(NodeId(3), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::default_art());
|
||||
let e = kept_evaluation(&d, &n);
|
||||
assert!(e.is_of(&d, &n, 7));
|
||||
d.unknown.insert(crate::SYMBOL_SIZES.into(), serde_json::json!({"Logo": [40.0, 20.0]}));
|
||||
assert!(!e.is_of(&d, &n, 7));
|
||||
}
|
||||
|
||||
/// A kept evaluation is stale once a swatch changes, in a color group too: a painted live effect's
|
||||
/// pieces name swatches.
|
||||
#[test]
|
||||
@@ -1823,6 +1952,216 @@ fn objects_at_matches_repeated_hits_on_random_documents() {
|
||||
}
|
||||
}
|
||||
|
||||
/// [`objects_at_repeated_after`] with each found object looked up in the ordered list itself: the
|
||||
/// reference the tests below hold the set lookup to, and the base that `select_behind_isolation_timing` times.
|
||||
fn objects_at_repeated_after_by_list(doc: &Document, p: Point, opt: HitOptions, scope: Option<NodeId>, mut tops: Vec<NodeId>) -> Vec<NodeId> {
|
||||
while let Some(top) = hit_test_skipping(doc, p, opt, &|id| tops.contains(&id), true).map(|h| h.top_object(scope)) {
|
||||
if tops.contains(&top) {
|
||||
break;
|
||||
}
|
||||
tops.push(top);
|
||||
}
|
||||
tops
|
||||
}
|
||||
|
||||
/// A layer holding a group of `count` overlapping 50 × 50 squares, member `i` at x = 5 × (`i` mod
|
||||
/// 10), with a square at x = 0 below the group and above it, and one at x = 100 above it: the
|
||||
/// document, the group and its members, topmost first.
|
||||
fn isolated_stack(count: u32) -> (Document, NodeId, Vec<NodeId>) {
|
||||
let mut d = Document::new(200.0, 200.0);
|
||||
let l = d.layers[0].id;
|
||||
let square = |d: &mut Document, x: f64| Node::path(d.alloc_id(), shapes::rectangle(Rect::new(x, 0.0, x + 50.0, 50.0)), Appearance::default_art());
|
||||
let below = square(&mut d, 0.0);
|
||||
d.insert(Some(l), usize::MAX, below).unwrap();
|
||||
let members: Vec<Node> = (0..count).map(|i| square(&mut d, f64::from(i % 10) * 5.0)).collect();
|
||||
let mut ids: Vec<NodeId> = members.iter().map(|n| n.id).collect();
|
||||
let g = d.alloc_id();
|
||||
d.insert(Some(l), usize::MAX, Node::group(g, members.into_iter().map(Arc::new).collect())).unwrap();
|
||||
for x in [0.0, 100.0] {
|
||||
let above = square(&mut d, x);
|
||||
d.insert(Some(l), usize::MAX, above).unwrap();
|
||||
}
|
||||
ids.reverse();
|
||||
(d, g, ids)
|
||||
}
|
||||
|
||||
/// Select Behind in an isolated group of 40 overlapping squares, with art around the group above
|
||||
/// and below them: each member once, front to back, over 41 rounds of hit tests, and nothing where
|
||||
/// only the art around the group lies.
|
||||
#[test]
|
||||
fn select_behind_in_isolation_lists_a_large_stack_once() {
|
||||
let (d, g, ids) = isolated_stack(40);
|
||||
let at = |x: f64, scope| objects_at(&d, Point::new(x, 25.0), HitOptions::default(), scope);
|
||||
assert_eq!(at(47.5, Some(g)), ids);
|
||||
assert_eq!(at(47.5, Some(g)).iter().collect::<HashSet<_>>().len(), 40, "no object twice");
|
||||
assert_eq!(at(47.5, None).len(), 3, "not isolated: the square above, the group and the square below");
|
||||
// At x = 17.5 only the members at x = 0 to 20 are hit (the one at 20 on its stroke, within
|
||||
// the tolerance): `ids[k]` is member 39 - k.
|
||||
let left: Vec<NodeId> = ids.iter().enumerate().filter(|(k, _)| (39 - k) % 10 <= 4).map(|(_, id)| *id).collect();
|
||||
assert_eq!(left.len(), 20);
|
||||
assert_eq!(at(17.5, Some(g)), left);
|
||||
assert!(at(125.0, Some(g)).is_empty(), "only the square around the group");
|
||||
assert_eq!(at(125.0, None).len(), 1);
|
||||
let isolated = HitOptions { scope: Some(g), ..HitOptions::default() };
|
||||
let p = Point::new(47.5, 25.0);
|
||||
assert_eq!(objects_at_repeated_after(&d, p, isolated, Some(g), ids[..15].to_vec()), ids, "the objects passed in stay first");
|
||||
let (d, g, clip, art) = masked_square(false);
|
||||
let isolated = HitOptions { scope: Some(g), ..SELECTING };
|
||||
for p in [Point::new(140.0, 90.0), Point::new(170.0, 90.0), Point::new(100.0, 90.0)] {
|
||||
let want = objects_at_repeated_after_by_list(&d, p, isolated, Some(g), vec![]);
|
||||
assert_eq!(objects_at(&d, p, SELECTING, Some(g)), want, "clip group isolated, {p:?}");
|
||||
}
|
||||
assert_eq!(objects_at(&d, Point::new(170.0, 90.0), SELECTING, Some(g)), vec![art], "the art its mask hides");
|
||||
assert!(objects_at(&d, Point::new(140.0, 90.0), SELECTING, Some(g)).contains(&clip), "the mask on its outline");
|
||||
}
|
||||
|
||||
/// Documents built at random (nested groups, clipping groups, envelopes in Edit Contents, hidden
|
||||
/// and locked objects), each object in turn isolated, and each list started with some of the
|
||||
/// objects already found: the set lookup returns what the ordered-list lookup returns, field for
|
||||
/// field.
|
||||
#[test]
|
||||
fn select_behind_in_isolation_matches_the_list_lookup_on_random_documents() {
|
||||
let mut seed = 0x2545_f491_u32;
|
||||
let mut next = move |n: u32| {
|
||||
seed ^= seed << 13;
|
||||
seed ^= seed >> 17;
|
||||
seed ^= seed << 5;
|
||||
seed % n
|
||||
};
|
||||
fn fill(d: &mut Document, parent: NodeId, depth: u32, next: &mut impl FnMut(u32) -> u32) {
|
||||
for _ in 0..2 + next(5) {
|
||||
let id = d.alloc_id();
|
||||
let rect = |next: &mut dyn FnMut(u32) -> u32| {
|
||||
let (x, y) = (f64::from(next(60)), f64::from(next(60)));
|
||||
Rect::new(x, y, x + 10.0 + f64::from(next(50)), y + 10.0 + f64::from(next(50)))
|
||||
};
|
||||
let mut n = match next(if depth < 3 { 9 } else { 4 }) {
|
||||
4 | 5 => Node::group(id, Vec::new()),
|
||||
6 => {
|
||||
let mut g = Node::group(id, Vec::new());
|
||||
g.set_clips(true);
|
||||
g
|
||||
}
|
||||
7 => {
|
||||
let content =
|
||||
(0..2).map(|_| Arc::new(Node::path(d.alloc_id(), shapes::rectangle(rect(next)), Appearance::default_art()))).collect();
|
||||
Node::new(
|
||||
id,
|
||||
NodeKind::Envelope {
|
||||
content,
|
||||
kind: Box::new(crate::live::EnvelopeKind::Warp {
|
||||
style: "arc".to_string(),
|
||||
bend: 0.0,
|
||||
h: 0.0,
|
||||
v: 0.0,
|
||||
horizontal: true,
|
||||
version: 0,
|
||||
}),
|
||||
fidelity: 100.0,
|
||||
editing: next(2) == 0,
|
||||
options: Default::default(),
|
||||
frame: Box::new(vectorcraft_geom::Affine::IDENTITY),
|
||||
},
|
||||
)
|
||||
}
|
||||
_ => Node::path(id, shapes::rectangle(rect(next)), if next(4) == 0 { Appearance::default() } else { Appearance::default_art() }),
|
||||
};
|
||||
n.visible = next(8) != 0;
|
||||
n.locked = next(8) == 0;
|
||||
let group = matches!(n.kind, NodeKind::Group { .. });
|
||||
d.insert(Some(parent), usize::MAX, n).unwrap();
|
||||
if group {
|
||||
fill(d, id, depth + 1, next);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut compared = 0;
|
||||
for round in 0..60 {
|
||||
let mut d = Document::new(120.0, 120.0);
|
||||
let layer = d.layers[0].id;
|
||||
fill(&mut d, layer, 0, &mut next);
|
||||
let mut scopes = vec![None];
|
||||
d.walk(|n| {
|
||||
if n.id != layer {
|
||||
scopes.push(Some(n.id));
|
||||
}
|
||||
});
|
||||
for _ in 0..6 {
|
||||
let p = Point::new(f64::from(next(120)), f64::from(next(120)));
|
||||
let opt = HitOptions { outline: next(5) == 0, path_only: next(5) == 0, clip_outlines: next(2) == 0, ..Default::default() };
|
||||
for &scope in &scopes {
|
||||
let opt = HitOptions { scope, ..opt };
|
||||
let want = objects_at_repeated_after_by_list(&d, p, opt, scope, vec![]);
|
||||
let context = format!("round {round}, {p:?}, {opt:?}");
|
||||
assert_eq!(objects_at_repeated_after(&d, p, opt, scope, vec![]), want, "{context}");
|
||||
if scope.is_some() {
|
||||
assert_eq!(objects_at(&d, p, opt, scope), want, "{context}");
|
||||
}
|
||||
for found in 1..want.len() {
|
||||
let start = want[..found].to_vec();
|
||||
assert_eq!(objects_at_repeated_after(&d, p, opt, scope, start.clone()), want, "{context}, {found} found");
|
||||
assert_eq!(objects_at_repeated_after_by_list(&d, p, opt, scope, start), want, "{context}, {found} found");
|
||||
}
|
||||
compared += usize::from(!want.is_empty());
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(compared > 500, "only {compared} non-empty lists compared");
|
||||
}
|
||||
|
||||
/// Times Select Behind in an isolated group of 200 and of 1,000 overlapping squares, the set lookup
|
||||
/// against the ordered-list lookup, alternating the two in one process:
|
||||
/// `cargo test --release -p vectorcraft-doc --lib -- --ignored --nocapture select_behind_isolation_timing`.
|
||||
#[test]
|
||||
#[ignore = "a timing, not a check"]
|
||||
fn select_behind_isolation_timing() {
|
||||
/// This thread's CPU time in nanoseconds on Linux; the elapsed time since `start` elsewhere.
|
||||
fn clock(start: std::time::Instant) -> u128 {
|
||||
let cpu = std::fs::read_to_string("/proc/thread-self/schedstat").ok();
|
||||
cpu.and_then(|s| s.split_whitespace().next()?.parse().ok()).unwrap_or_else(|| start.elapsed().as_nanos())
|
||||
}
|
||||
type Lookup = fn(&Document, Point, HitOptions, Option<NodeId>, Vec<NodeId>) -> Vec<NodeId>;
|
||||
let start = std::time::Instant::now();
|
||||
println!("clock: {}", if std::fs::metadata("/proc/thread-self/schedstat").is_ok() { "thread CPU time" } else { "wall clock" });
|
||||
let p = Point::new(47.5, 25.0);
|
||||
for count in [200, 1_000] {
|
||||
let (d, g, ids) = isolated_stack(count);
|
||||
let opt = HitOptions { scope: Some(g), ..HitOptions::default() };
|
||||
assert_eq!(objects_at_repeated_after(&d, p, opt, Some(g), vec![]), ids);
|
||||
assert_eq!(objects_at_repeated_after_by_list(&d, p, opt, Some(g), vec![]), ids);
|
||||
// The time per call of `f`: batches of calls double until one takes at least 100 ms.
|
||||
let per_call = |f: Lookup| {
|
||||
let mut calls = 1u32;
|
||||
loop {
|
||||
let t = clock(start);
|
||||
for _ in 0..calls {
|
||||
std::hint::black_box(f(&d, std::hint::black_box(p), opt, Some(g), vec![]));
|
||||
}
|
||||
let spent = clock(start) - t;
|
||||
if spent >= 100_000_000 || calls >= 1 << 20 {
|
||||
return (spent as f64 / f64::from(calls), calls);
|
||||
}
|
||||
calls *= 2;
|
||||
}
|
||||
};
|
||||
let (mut old, mut new) = (vec![], vec![]);
|
||||
for _ in 0..7 {
|
||||
old.push(per_call(objects_at_repeated_after_by_list));
|
||||
new.push(per_call(objects_at_repeated_after));
|
||||
}
|
||||
old.sort_by(|a, b| a.0.total_cmp(&b.0));
|
||||
new.sort_by(|a, b| a.0.total_cmp(&b.0));
|
||||
let (o, n) = (old[3], new[3]);
|
||||
println!(
|
||||
"{count} objects: list lookup {:.2} ms per call ({} calls), set lookup {:.2} ms per call ({} calls), median of 7 runs",
|
||||
o.0 / 1e6,
|
||||
o.1,
|
||||
n.0 / 1e6,
|
||||
n.1
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Select Behind finds a symbol instance by its symbol's art, as a click does: art from
|
||||
/// (100, 60) to (140, 80), outside the 20 × 20 square around the origin, drawn where it lies by
|
||||
/// one instance and 100 pt lower by an instance in a group.
|
||||
@@ -2397,7 +2736,7 @@ fn a_symbol_instance_is_hit_where_a_moved_clipping_path_in_its_art_shows_the_art
|
||||
assert_eq!(marquee(&d, edge, None, false), [g], "layer {layer}");
|
||||
assert_eq!(marquee(&d, edge, None, true), [inst], "layer {layer}");
|
||||
assert!(marquee(&d, past, None, false).is_empty());
|
||||
assert!(marquee_in_view(&d, edge, None, false, true).is_empty(), "Outline view");
|
||||
assert!(marquee_in_view(&d, edge, None, false, true, false).is_empty(), "Outline view");
|
||||
}
|
||||
// Preview off for the layer the instance is on.
|
||||
let (mut d, _, _) = build("test.move", Affine::IDENTITY, false, true, false);
|
||||
|
||||
@@ -82,6 +82,16 @@ impl Paths {
|
||||
pub(crate) fn len(&self) -> usize {
|
||||
self.ids.len()
|
||||
}
|
||||
/// The entry of `id` in the table: `Some(None)` when the id appears more than once, `None`
|
||||
/// when it isn't in the table.
|
||||
pub(crate) fn entry(&self, id: &NodeId) -> Option<Option<u32>> {
|
||||
self.ids.get(id).copied()
|
||||
}
|
||||
/// Entry `e`'s parent entry (`u32::MAX` for a top-level layer) and its index among its
|
||||
/// siblings.
|
||||
pub(crate) fn place(&self, e: u32) -> Option<(u32, u32)> {
|
||||
self.at.get(e as usize).copied()
|
||||
}
|
||||
}
|
||||
|
||||
/// Lookups that had to walk (the cache didn't have the id, or its path no longer checks out)
|
||||
@@ -108,6 +118,22 @@ pub(crate) fn note_tree_walk() {
|
||||
TREE_WALKS.set(TREE_WALKS.get().saturating_add(1));
|
||||
}
|
||||
|
||||
thread_local! {
|
||||
/// [`path_lookups`] of this thread.
|
||||
static PATH_LOOKUPS: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
|
||||
}
|
||||
|
||||
/// How many times [`crate::Document::index_path`] has run on this thread, the lookups that
|
||||
/// [`crate::Document::node`] and [`crate::Document::ancestry`] make through it included.
|
||||
pub fn path_lookups() -> u64 {
|
||||
PATH_LOOKUPS.get()
|
||||
}
|
||||
|
||||
/// Adds one to [`path_lookups`].
|
||||
pub(crate) fn note_path_lookup() {
|
||||
PATH_LOOKUPS.set(PATH_LOOKUPS.get().saturating_add(1));
|
||||
}
|
||||
|
||||
/// The cache, shared by clones of a document (each checks every path it uses against its own tree).
|
||||
#[derive(Default)]
|
||||
pub struct IdIndex(RwLock<Option<Arc<Paths>>>, std::sync::atomic::AtomicU32);
|
||||
|
||||
+218
-10
@@ -117,6 +117,29 @@ impl Document {
|
||||
/// symbol that shows itself inline ([`Self::inline_art_bounds`]) is shown as an empty slot.
|
||||
/// Returns the ids of the texts in the layers that changed.
|
||||
pub fn resolve_inline_art_with(&mut self, layout: &mut dyn FnMut(&mut TextObject)) -> Vec<NodeId> {
|
||||
self.resolve_inline_art_since(None, layout).changed
|
||||
}
|
||||
|
||||
/// [`Self::resolve_inline_art_with`], given `last`: a document an earlier pass left resolved,
|
||||
/// with the bounds that pass measured ([`InlinePass::measured`]). When this document has the
|
||||
/// same symbols, graph designs, pattern tiles and foreign data (`unknown`, which holds the
|
||||
/// symbols' natural sizes and 9-slice guides) as `last`, and each symbol name measured then
|
||||
/// still measures the same, the type in the layer trees that are the same nodes as `last`'s
|
||||
/// already has these bounds: only the other layer trees are checked, in the same order, and
|
||||
/// the document and the ids returned are those of the full pass. Otherwise, or without `last`,
|
||||
/// the full pass runs.
|
||||
pub fn resolve_inline_art_since(&mut self, last: Option<(&Document, &InlineMeasured)>, layout: &mut dyn FnMut(&mut TextObject)) -> InlinePass {
|
||||
if let Some((last, kept)) = last
|
||||
&& self.same_inline_inputs(last, kept)
|
||||
{
|
||||
let measured = Measured(RefCell::new(kept.0.clone()));
|
||||
let mut changed = vec![];
|
||||
let layers = resolve_kids(Some(&last.layers), &self.layers, &|n| measured.get(n, || self.inline_art_bounds(n)), layout, &mut changed);
|
||||
for (i, layer) in layers {
|
||||
self.layers[i] = layer;
|
||||
}
|
||||
return InlinePass { changed, measured: InlineMeasured(measured.0.into_inner()), partial: true };
|
||||
}
|
||||
let mut out = vec![];
|
||||
let mut unused = vec![];
|
||||
let graph = InlineGraph::of(self);
|
||||
@@ -147,10 +170,44 @@ impl Document {
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
InlinePass { changed: out, measured: InlineMeasured(measured.0.into_inner()), partial: false }
|
||||
}
|
||||
|
||||
/// Whether the type in this document's layer trees that are the same nodes as `last`'s already
|
||||
/// has the bounds a full pass would give it (see [`Self::resolve_inline_art_since`]).
|
||||
fn same_inline_inputs(&self, last: &Document, kept: &InlineMeasured) -> bool {
|
||||
self.symbols.len() == last.symbols.len()
|
||||
&& self.symbols.iter().zip(&last.symbols).all(|(a, b)| a.name == b.name && Arc::ptr_eq(&a.art, &b.art))
|
||||
&& self.graph_designs.len() == last.graph_designs.len()
|
||||
&& self.graph_designs.iter().zip(&last.graph_designs).all(|(a, b)| a.name == b.name && Arc::ptr_eq(&a.art, &b.art))
|
||||
&& self.patterns.len() == last.patterns.len()
|
||||
&& self
|
||||
.patterns
|
||||
.iter()
|
||||
.zip(&last.patterns)
|
||||
.all(|(a, b)| a.name == b.name && a.art.len() == b.art.len() && a.art.iter().zip(&b.art).all(|(x, y)| Arc::ptr_eq(x, y)))
|
||||
&& crate::Shared::ptr_eq(&self.unknown, &last.unknown)
|
||||
&& kept.0.iter().all(|(name, b)| self.inline_art_bounds(name) == *b)
|
||||
}
|
||||
}
|
||||
|
||||
/// What a pass of [`Document::resolve_inline_art_since`] did.
|
||||
#[derive(Debug)]
|
||||
pub struct InlinePass {
|
||||
/// The ids of the texts in the layers that changed, in the order the full pass finds them.
|
||||
pub changed: Vec<NodeId>,
|
||||
/// The bounds the pass gave the inline graphics of each symbol name, for the next pass.
|
||||
pub measured: InlineMeasured,
|
||||
/// Whether only the layer trees that differ from the last resolved document's were checked.
|
||||
pub partial: bool,
|
||||
}
|
||||
|
||||
/// The art bounds a pass of [`Document::resolve_inline_art_since`] gave the inline graphics of each
|
||||
/// symbol name it was asked for. A pass that checks only some layer trees keeps the names the
|
||||
/// pass before it measured, so the names of all the type in the document stay listed.
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct InlineMeasured(HashMap<String, Option<Rect>>);
|
||||
|
||||
/// Whether `t` has inline graphics whose bounds differ from what `bounds` gives their symbols.
|
||||
fn stale_by(t: &TextObject, bounds: &dyn Fn(&str) -> Option<Rect>) -> bool {
|
||||
t.runs.iter().filter_map(|r| r.inline.as_ref()).any(|a| a.bounds != bounds(&a.symbol))
|
||||
@@ -185,6 +242,22 @@ fn resolve_tree(
|
||||
layout: &mut dyn FnMut(&mut TextObject),
|
||||
changed: &mut Vec<NodeId>,
|
||||
) -> bool {
|
||||
resolve_since(None, n, bounds, layout, changed)
|
||||
}
|
||||
|
||||
/// [`resolve_tree`], given `old`: the node `n` was before an edit, in a document whose type was
|
||||
/// resolved with the same `bounds`. The opacity mask art and children of `n` that are the same
|
||||
/// nodes as `old`'s are skipped: their type already has these bounds. Without `old`, every node
|
||||
/// of the tree is visited.
|
||||
fn resolve_since(
|
||||
old: Option<&Node>,
|
||||
n: &mut Arc<Node>,
|
||||
bounds: &dyn Fn(&str) -> Option<Rect>,
|
||||
layout: &mut dyn FnMut(&mut TextObject),
|
||||
changed: &mut Vec<NodeId>,
|
||||
) -> bool {
|
||||
#[cfg(test)]
|
||||
tests::VISITS.with(|v| v.set(v.get() + 1));
|
||||
let mut copied = false;
|
||||
if matches!(&n.kind, NodeKind::Text(t) if stale_by(t, bounds)) {
|
||||
let node = Arc::make_mut(n);
|
||||
@@ -196,17 +269,17 @@ fn resolve_tree(
|
||||
}
|
||||
copied = true;
|
||||
}
|
||||
let old_mask = old.and_then(|o| o.extras().mask.as_deref()).map(|m| &m.art);
|
||||
let mask = n.extras().mask.as_deref().and_then(|m| {
|
||||
let mut art = m.art.clone();
|
||||
resolve_tree(&mut art, bounds, layout, changed).then_some(art)
|
||||
});
|
||||
let mut kids = vec![];
|
||||
for (i, c) in n.children().into_iter().flatten().enumerate() {
|
||||
let mut c = c.clone();
|
||||
if resolve_tree(&mut c, bounds, layout, changed) {
|
||||
kids.push((i, c));
|
||||
if old_mask.is_some_and(|o| Arc::ptr_eq(o, &m.art)) {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
let mut art = m.art.clone();
|
||||
let old_art = old_mask.filter(|o| o.id == art.id).map(|o| &**o);
|
||||
resolve_since(old_art, &mut art, bounds, layout, changed).then_some(art)
|
||||
});
|
||||
let old_kids = old.map(|o| o.children().map_or(&[][..], Vec::as_slice));
|
||||
let kids = resolve_kids(old_kids, n.children().map_or(&[][..], Vec::as_slice), bounds, layout, changed);
|
||||
if mask.is_none() && kids.is_empty() {
|
||||
return copied;
|
||||
}
|
||||
@@ -224,6 +297,35 @@ fn resolve_tree(
|
||||
true
|
||||
}
|
||||
|
||||
/// Resolves the trees `kids` as [`resolve_since`] does, each with the node of `old` (the same list
|
||||
/// before an edit) that has its id, found at the same position or else by id, and skips those that
|
||||
/// are the same nodes as theirs. Without `old`, every tree is visited. Returns the position and new
|
||||
/// node of each tree that changed.
|
||||
fn resolve_kids(
|
||||
old: Option<&[Arc<Node>]>,
|
||||
kids: &[Arc<Node>],
|
||||
bounds: &dyn Fn(&str) -> Option<Rect>,
|
||||
layout: &mut dyn FnMut(&mut TextObject),
|
||||
changed: &mut Vec<NodeId>,
|
||||
) -> Vec<(usize, Arc<Node>)> {
|
||||
let mut by_id: Option<HashMap<NodeId, &Arc<Node>>> = None;
|
||||
let mut out = vec![];
|
||||
for (i, c) in kids.iter().enumerate() {
|
||||
let o = old.and_then(|old| match old.get(i) {
|
||||
Some(b) if b.id == c.id => Some(b),
|
||||
_ => by_id.get_or_insert_with(|| old.iter().map(|b| (b.id, b)).collect()).get(&c.id).copied(),
|
||||
});
|
||||
if o.is_some_and(|o| Arc::ptr_eq(o, c)) {
|
||||
continue;
|
||||
}
|
||||
let mut c = c.clone();
|
||||
if resolve_since(o.map(|o| &**o), &mut c, bounds, layout, changed) {
|
||||
out.push((i, c));
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The art bounds of each symbol, measured once in a pass of [`Document::resolve_inline_art_with`].
|
||||
/// A symbol is first asked for after its own type is resolved (the pass goes in
|
||||
/// [`InlineGraph::order`]), so its measurement stays current for the rest of the pass.
|
||||
@@ -436,6 +538,112 @@ impl std::fmt::Debug for InlineCycles {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
thread_local! {
|
||||
/// How many nodes [`resolve_since`] has visited on this thread.
|
||||
pub(super) static VISITS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
|
||||
}
|
||||
|
||||
/// The nodes visited since the last call.
|
||||
fn visits() -> usize {
|
||||
VISITS.with(|v| v.replace(0))
|
||||
}
|
||||
|
||||
/// A copy of `d` resolved by the full pass, and the ids that pass returns.
|
||||
fn fully_resolved(d: &Document) -> (Document, Vec<NodeId>) {
|
||||
let mut full = d.clone();
|
||||
let ids = full.resolve_inline_art_with(&mut |_| {});
|
||||
(full, ids)
|
||||
}
|
||||
|
||||
/// The children of the layer at `i`, for an edit.
|
||||
fn layer_kids(d: &mut Document, i: usize) -> &mut Vec<Arc<Node>> {
|
||||
match Arc::make_mut(&mut d.layers[i]).children_mut() {
|
||||
Some(kids) => kids,
|
||||
None => panic!("layer {i} is a group"),
|
||||
}
|
||||
}
|
||||
|
||||
/// 50 groups of 20 squares, symbol `S`, type showing `S` in the first group, and type showing
|
||||
/// `S` in the opacity mask of the second.
|
||||
fn many_groups() -> Document {
|
||||
let mut d = Document::new(500.0, 500.0);
|
||||
let square = stroked(&mut d, Rect::new(0.0, 0.0, 10.0, 10.0));
|
||||
symbol(&mut d, "S", vec![square]);
|
||||
for _ in 0..50 {
|
||||
let kids = (0..20).map(|_| stroked(&mut d, Rect::new(0.0, 0.0, 5.0, 5.0))).collect();
|
||||
let group = Node::group(d.alloc_id(), kids);
|
||||
d.layers.push(Arc::new(group));
|
||||
}
|
||||
let t = showing(&mut d, "S");
|
||||
layer_kids(&mut d, 0).push(t);
|
||||
let masked = showing(&mut d, "S");
|
||||
Arc::make_mut(&mut d.layers[1]).extras_mut().mask = Some(Box::new(crate::OpacityMask::new((*masked).clone(), true)));
|
||||
d
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_pass_after_an_edit_checks_only_the_trees_the_edit_changed() {
|
||||
let mut d = many_groups();
|
||||
let first = d.resolve_inline_art_since(None, &mut |_| {});
|
||||
assert!(!first.partial);
|
||||
assert_eq!(first.changed.len(), 2);
|
||||
let last = d.clone();
|
||||
visits();
|
||||
let _ = fully_resolved(&d);
|
||||
let full_visits = visits();
|
||||
// The edit moves a square in the 31st group, adds type showing S to the 41st, and gives the
|
||||
// second group's opacity mask new type: its 20 squares stay the same nodes.
|
||||
let moved = stroked(&mut d, Rect::new(1.0, 1.0, 6.0, 6.0));
|
||||
layer_kids(&mut d, 30)[5] = moved;
|
||||
let added = showing(&mut d, "S");
|
||||
layer_kids(&mut d, 40).push(added.clone());
|
||||
let mask_type = showing(&mut d, "S");
|
||||
if let Some(m) = Arc::make_mut(&mut d.layers[1]).extras_if_any().and_then(|e| e.mask.as_deref_mut()) {
|
||||
m.art = mask_type.clone();
|
||||
}
|
||||
let (want, ids) = fully_resolved(&d);
|
||||
assert_eq!(ids, [mask_type.id, added.id]);
|
||||
visits();
|
||||
let pass = d.resolve_inline_art_since(Some((&last, &first.measured)), &mut |_| {});
|
||||
let partial_visits = visits();
|
||||
assert!(pass.partial);
|
||||
assert_eq!(pass.changed, ids);
|
||||
assert_eq!(d, want);
|
||||
// The three changed groups, the mask's new type, the moved square and the added type.
|
||||
assert_eq!(partial_visits, 6);
|
||||
assert!(full_visits > 1000, "{full_visits}");
|
||||
assert_eq!(pass.measured, first.measured);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn changed_symbols_or_symbol_sizes_take_the_full_pass() {
|
||||
let mut d = many_groups();
|
||||
let mut pass = d.resolve_inline_art_since(None, &mut |_| {});
|
||||
// A natural size for S, its art unchanged.
|
||||
let last = d.clone();
|
||||
d.unknown.insert(SYMBOL_SIZES.into(), serde_json::json!({ "S": [40.0, 20.0] }));
|
||||
let (want, ids) = fully_resolved(&d);
|
||||
assert_eq!(ids.len(), 2);
|
||||
pass = d.resolve_inline_art_since(Some((&last, &pass.measured)), &mut |_| {});
|
||||
assert!(!pass.partial);
|
||||
assert_eq!((&d, &pass.changed), (&want, &ids));
|
||||
// New art for S.
|
||||
let last = d.clone();
|
||||
let bigger = stroked(&mut d, Rect::new(0.0, 0.0, 30.0, 30.0));
|
||||
d.symbols[0].art = Arc::new(Node::group(d.alloc_id(), vec![bigger]));
|
||||
let (want, ids) = fully_resolved(&d);
|
||||
assert_eq!(ids.len(), 2);
|
||||
pass = d.resolve_inline_art_since(Some((&last, &pass.measured)), &mut |_| {});
|
||||
assert!(!pass.partial);
|
||||
assert_eq!((&d, &pass.changed), (&want, &ids));
|
||||
// A measurement that no longer holds, with the same symbols and foreign data.
|
||||
let last = d.clone();
|
||||
let stale = InlineMeasured(HashMap::from([("S".to_owned(), Some(Rect::new(0.0, 0.0, 1.0, 1.0)))]));
|
||||
pass = d.resolve_inline_art_since(Some((&last, &stale)), &mut |_| {});
|
||||
assert!(!pass.partial);
|
||||
assert!(pass.changed.is_empty());
|
||||
}
|
||||
|
||||
/// The position of each node in `order`.
|
||||
fn positions(order: &[usize]) -> Vec<usize> {
|
||||
let mut at = vec![0; order.len()];
|
||||
|
||||
@@ -21,7 +21,7 @@ pub mod graph;
|
||||
mod halftone_radii;
|
||||
pub mod hit;
|
||||
mod id_index;
|
||||
pub use id_index::tree_walks;
|
||||
pub use id_index::{path_lookups, tree_walks};
|
||||
pub mod inks;
|
||||
mod inline;
|
||||
pub mod intertwine;
|
||||
@@ -31,7 +31,7 @@ mod symbol_nine_slice;
|
||||
pub mod symbol_overrides;
|
||||
mod symbol_pixel_aligned;
|
||||
mod symbol_registration;
|
||||
pub use inline::{SYMBOL_HALF, SYMBOL_SIZES};
|
||||
pub use inline::{InlineMeasured, InlinePass, SYMBOL_HALF, SYMBOL_SIZES};
|
||||
pub use shared::Shared;
|
||||
pub use symbol_export_type::{SYMBOL_EXPORT_TYPE, SymbolExportType};
|
||||
pub use symbol_nine_slice::{
|
||||
@@ -48,6 +48,8 @@ pub mod marks;
|
||||
mod mem;
|
||||
pub use mem::{appearance_heap_bytes, paint_heap_bytes};
|
||||
pub mod metadata;
|
||||
mod nearest;
|
||||
pub use nearest::NearestFinder;
|
||||
pub mod node;
|
||||
pub mod objects_on_path;
|
||||
pub mod orient;
|
||||
|
||||
@@ -66,7 +66,8 @@ pub use expand::{
|
||||
use mesh::grid_eval;
|
||||
pub use mesh::{Coons, GradientMesh, MeshAppearance, MeshPiece, MeshPoint, MeshQuad, default_fidelity, grid_points, nodes_bounds};
|
||||
pub use warp::{
|
||||
WARP_NET, WarpNet, WarpStyle, fit_piece, map_nonlinear, map_nonlinear_within, map_smooth_within, pieces, uses_net, warp_point, warp_version,
|
||||
WARP_NET, WarpNet, WarpStyle, fit_piece, map_handles_within, map_nonlinear, map_nonlinear_within, map_smooth_within, pieces, uses_net,
|
||||
warp_point, warp_version,
|
||||
};
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -508,6 +508,17 @@ pub fn map_smooth_within(path: &PathData, max_piece: f64, max: usize, f: impl Fn
|
||||
map_pieces_within(path, max_piece, max, &f, |p, h| mapped_handle(&f, p, h))
|
||||
}
|
||||
|
||||
/// [`map_nonlinear_within`] with `handle(point, handle)` supplying each mapped handle position.
|
||||
pub fn map_handles_within(
|
||||
path: &PathData,
|
||||
max_piece: f64,
|
||||
max: usize,
|
||||
f: impl Fn(Point) -> Point,
|
||||
handle: impl Fn(Point, Point) -> Point,
|
||||
) -> PathData {
|
||||
map_pieces_within(path, max_piece, max, &f, handle)
|
||||
}
|
||||
|
||||
/// Handle `h` of point `p` mapped through `f`: `f(p)` plus `f`'s derivative at `p` along `h - p`
|
||||
/// (a central difference), so the image curve leaves `f(p)` the way `f` takes the curve.
|
||||
fn mapped_handle(f: &impl Fn(Point) -> Point, p: Point, h: Point) -> Point {
|
||||
@@ -553,7 +564,8 @@ fn map_pieces_within(path: &PathData, max_piece: f64, max: usize, f: &impl Fn(Po
|
||||
let c = seg_cubic(sp, i);
|
||||
let k = pieces(poly_len(&c), max_piece, MAX_PIECES);
|
||||
for j in 0..k {
|
||||
let sub = c.subsegment((j as f64 / k as f64)..((j + 1) as f64 / k as f64));
|
||||
// Evaluating an unchanged curve can overflow even when its control points are finite.
|
||||
let sub = if k == 1 { c } else { c.subsegment((j as f64 / k as f64)..((j + 1) as f64 / k as f64)) };
|
||||
if let Some(last) = res.last_mut() {
|
||||
last.h_out = handle(sub.p0, sub.p1);
|
||||
}
|
||||
@@ -613,3 +625,53 @@ pub(super) fn resample(poly: &[Point], m: usize) -> Vec<Point> {
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod handle_tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn an_unsplit_curve_keeps_its_finite_control_points() {
|
||||
let start = Point::new(1e308, 0.0);
|
||||
let end = Point::new(1.03e308, 0.0);
|
||||
let path = PathData::new(vec![SubPath::new(
|
||||
vec![Anchor::with_handles(start, start, Point::new(1.01e308, 1.0)), Anchor::with_handles(end, Point::new(1.02e308, 1.0), end)],
|
||||
false,
|
||||
)]);
|
||||
assert_eq!(map_handles_within(&path, 1.0, 2, |p| p, |_, h| h), path);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rounded_samples_preserve_a_smooth_interior_join() {
|
||||
let center = Point::new(1e16, 0.0);
|
||||
let path = PathData::new(vec![SubPath::new(
|
||||
vec![
|
||||
Anchor::corner(center + vectorcraft_geom::kurbo::Vec2::new(-18.0, 0.0)),
|
||||
Anchor::with_handles(
|
||||
center,
|
||||
center + vectorcraft_geom::kurbo::Vec2::new(-6.0, 0.0),
|
||||
center + vectorcraft_geom::kurbo::Vec2::new(6.0, 0.0),
|
||||
),
|
||||
Anchor::corner(center + vectorcraft_geom::kurbo::Vec2::new(18.0, 0.0)),
|
||||
],
|
||||
false,
|
||||
)]);
|
||||
let mapped = map_smooth_within(&path, f64::INFINITY, 3, |p| Point::new(p.x, p.y + (p.x - center.x).powi(2) * 0.1));
|
||||
let join = &mapped.subpaths[0].anchors[1];
|
||||
let incoming = join.p - join.h_in;
|
||||
let outgoing = join.h_out - join.p;
|
||||
assert!(incoming.cross(outgoing).abs() < 1e-9, "{incoming:?} {outgoing:?}");
|
||||
assert!(incoming.dot(outgoing) > 0.0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_midpoint_rounded_to_an_endpoint_keeps_the_handle_direction() {
|
||||
for x in [1e16, 1e16 + 2.0, -1e16] {
|
||||
for offset in [-6.0, -2.0, 2.0, 6.0] {
|
||||
let p = Point::new(x, 0.0);
|
||||
let h = Point::new(x + offset, 0.0);
|
||||
assert_eq!(mapped_handle(&|point| point, p, h), h);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
//! The nearest node of a kind at or above each of many objects, found along one index path per
|
||||
//! object.
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use crate::id_index::Paths;
|
||||
use crate::{Document, Node, NodeId};
|
||||
|
||||
/// Finds, for one object after another, the nearest node that passes a test: the object itself,
|
||||
/// then its parent, and so on up to its layer. Made by [`Document::nearest_finder`].
|
||||
///
|
||||
/// Each node on the way is tested as [`Document::node`] gives its id, so the answer is the one that
|
||||
/// `doc.ancestry(id)` read from the end, with `doc.node` for each id, gives. While the lookup cache
|
||||
/// places the object and each id on its path where they are, a lookup reads that one path; an id
|
||||
/// the cache does not place there (one that appears more than once, or a cache older than the
|
||||
/// tree) is looked up with [`Document::node`].
|
||||
pub struct NearestFinder<'a> {
|
||||
doc: &'a Document,
|
||||
cache: Option<Arc<Paths>>,
|
||||
/// The cache entries from the top-level layer down to the object.
|
||||
entries: Vec<u32>,
|
||||
/// The nodes at those entries.
|
||||
nodes: Vec<&'a Node>,
|
||||
}
|
||||
|
||||
impl Document {
|
||||
/// A [`NearestFinder`] for this document.
|
||||
pub fn nearest_finder(&self) -> NearestFinder<'_> {
|
||||
NearestFinder { doc: self, cache: self.index.get(), entries: vec![], nodes: vec![] }
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> NearestFinder<'a> {
|
||||
/// The node nearest `id` (itself, then its parent, and so on up to its layer) for which `pred`
|
||||
/// holds; `None` when `id` is not in the tree or no node on its path passes.
|
||||
pub fn nearest(&mut self, id: NodeId, mut pred: impl FnMut(&Node) -> bool) -> Option<&'a Node> {
|
||||
let doc = self.doc;
|
||||
let ids: Vec<NodeId> = if self.cached_path(id) {
|
||||
let cache = self.cache.as_deref()?;
|
||||
// The depth of the first id from the object up that the cache does not place there.
|
||||
let mut unplaced = None;
|
||||
for (k, (&node, &e)) in self.nodes.iter().zip(&self.entries).enumerate().rev() {
|
||||
if cache.entry(&node.id) != Some(Some(e)) {
|
||||
unplaced = Some(k);
|
||||
break;
|
||||
}
|
||||
if pred(node) {
|
||||
return Some(node);
|
||||
}
|
||||
}
|
||||
let k = unplaced?;
|
||||
self.nodes[..=k].iter().map(|n| n.id).collect()
|
||||
} else {
|
||||
doc.ancestry(id).unwrap_or_default()
|
||||
};
|
||||
let found = ids.into_iter().rev().find_map(|a| doc.node(a).filter(|n| pred(n)));
|
||||
// Those lookups may have built the cache again.
|
||||
self.cache = doc.index.get();
|
||||
found
|
||||
}
|
||||
|
||||
/// Fill `entries` and `nodes` with the cached path to `id`; false when the cache has no path for
|
||||
/// it or the path no longer leads to it.
|
||||
fn cached_path(&mut self, id: NodeId) -> bool {
|
||||
self.entries.clear();
|
||||
self.nodes.clear();
|
||||
let Some(cache) = self.cache.as_deref() else { return false };
|
||||
let Some(Some(mut e)) = cache.entry(&id) else { return false };
|
||||
loop {
|
||||
let Some((parent, _)) = cache.place(e) else { return false };
|
||||
self.entries.push(e);
|
||||
if parent == u32::MAX {
|
||||
break;
|
||||
}
|
||||
// A parent's entry is made before its children's, so the walk up ends.
|
||||
if parent >= e {
|
||||
return false;
|
||||
}
|
||||
e = parent;
|
||||
}
|
||||
self.entries.reverse();
|
||||
let mut siblings: &'a [Arc<Node>] = &self.doc.layers;
|
||||
for &e in &self.entries {
|
||||
let Some(n) = cache.place(e).and_then(|(_, i)| siblings.get(i as usize)) else { return false };
|
||||
self.nodes.push(&**n);
|
||||
siblings = n.children().map_or(&[], |c| c.as_slice());
|
||||
}
|
||||
self.nodes.last().is_some_and(|n| n.id == id)
|
||||
}
|
||||
}
|
||||
@@ -179,6 +179,48 @@ impl LiveShape {
|
||||
*xf = Affine::rotate_about((now - angle).to_radians(), centre) * *xf;
|
||||
}
|
||||
}
|
||||
/// A line's length in the document, from its first end to its second. None for other shapes.
|
||||
pub fn line_length(&self) -> Option<f64> {
|
||||
let LiveShape::Line { a, b } = self else { return None };
|
||||
Some((*b - *a).hypot())
|
||||
}
|
||||
/// A line's angle: the counterclockwise degrees in [0, 360) from the page's horizontal to the
|
||||
/// direction from its first end to its second (the Rotate field's sense). 0 for a line whose
|
||||
/// ends meet. None for other shapes.
|
||||
pub fn line_angle(&self) -> Option<f64> {
|
||||
let LiveShape::Line { a, b } = self else { return None };
|
||||
if a == b {
|
||||
return Some(0.0);
|
||||
}
|
||||
// No −0° or 360° from rounding: a line drawn left to right reads 0°.
|
||||
let a = (-self.angle_deg()).rem_euclid(360.0);
|
||||
Some(if a > 360.0 - 1e-9 { 0.0 } else { a + 0.0 })
|
||||
}
|
||||
/// Make a line `len` long (0 or more), keeping its first end in place and its direction, or
|
||||
/// pointing it to the right when its ends meet.
|
||||
pub fn set_line_length(&mut self, len: f64) {
|
||||
let LiveShape::Line { a, b } = self else { return };
|
||||
if !len.is_finite() || len < 0.0 {
|
||||
return;
|
||||
}
|
||||
let now = (*b - *a).hypot();
|
||||
*b = if now > 0.0 { *a + (*b - *a) * (len / now) } else { Point::new(a.x + len, a.y) };
|
||||
}
|
||||
/// Turn a line about its midpoint to `angle` (degrees, as [`LiveShape::line_angle`]). A line
|
||||
/// whose ends meet stays as it is.
|
||||
pub fn set_line_angle(&mut self, angle: f64) {
|
||||
let LiveShape::Line { a, b } = self else { return };
|
||||
let half = (*b - *a).hypot() / 2.0;
|
||||
if !angle.is_finite() || half <= 0.0 {
|
||||
return;
|
||||
}
|
||||
let mid = a.midpoint(*b);
|
||||
let t = angle.to_radians();
|
||||
// The page's y axis points down, so a counterclockwise angle goes up the page.
|
||||
let (dx, dy) = (half * t.cos(), -half * t.sin());
|
||||
*a = Point::new(mid.x - dx, mid.y - dy);
|
||||
*b = Point::new(mid.x + dx, mid.y + dy);
|
||||
}
|
||||
/// Make a polygon's sides equal (Make Sides Equal): drop the uneven scale and the shear from
|
||||
/// `xf`, keeping its centre, angle, reflection and [`LiveShape::polygon_radius`].
|
||||
pub fn make_sides_equal(&mut self) {
|
||||
|
||||
+57
-13
@@ -90,6 +90,42 @@ impl Node {
|
||||
matches!(self.kind, NodeKind::RulerGuide { .. } | NodeKind::Path { guide: true, .. })
|
||||
}
|
||||
|
||||
/// This object without the paths made into guides among the members of its groups, layers,
|
||||
/// Intertwine groups and compound paths, at any depth, for measuring the art around them while
|
||||
/// Lock Guides or Hide Guides leaves them out (#8538). The clipping path of a clip group or
|
||||
/// layer and the original shapes of a Shaper group stay, guides or not, so the object keeps
|
||||
/// its structure. `None` when it holds no such guide.
|
||||
pub fn without_guides(&self) -> Option<Node> {
|
||||
let (NodeKind::Layer { children, .. }
|
||||
| NodeKind::Group { children, .. }
|
||||
| NodeKind::Intertwine { children }
|
||||
| NodeKind::Compound { children, .. }) = &self.kind
|
||||
else {
|
||||
return None;
|
||||
};
|
||||
let keep = usize::from(self.clips() || self.extras().shaper.is_some());
|
||||
let mut changed = false;
|
||||
let mut out = Vec::with_capacity(children.len());
|
||||
for (i, c) in children.iter().enumerate() {
|
||||
if i >= keep && matches!(c.kind, NodeKind::Path { guide: true, .. }) {
|
||||
changed = true;
|
||||
} else if let Some(stripped) = c.without_guides() {
|
||||
changed = true;
|
||||
out.push(Arc::new(stripped));
|
||||
} else {
|
||||
out.push(c.clone());
|
||||
}
|
||||
}
|
||||
if !changed {
|
||||
return None;
|
||||
}
|
||||
let mut n = self.clone();
|
||||
if let Some(c) = n.children_mut() {
|
||||
*c = out;
|
||||
}
|
||||
Some(n)
|
||||
}
|
||||
|
||||
/// A template layer (Layer Options → Template).
|
||||
pub fn is_template(&self) -> bool {
|
||||
matches!(self.kind, NodeKind::Layer { template: true, .. })
|
||||
@@ -216,8 +252,10 @@ impl Node {
|
||||
/// path give it ([`crate::hit::set_clip_region`]). An image's box takes in
|
||||
/// the shapes its own fills and strokes paint ([`crate::hit::set_image_paint`]). Groups, layers
|
||||
/// without a clipping mask and Intertwine groups take in their members' boxes, grown by their
|
||||
/// own strokes. Symbol instances are measured as in [`Node::visual_bounds`]. A blend's box
|
||||
/// takes in where its spine can put its keys and steps.
|
||||
/// own strokes. Symbol instances are measured as in [`Node::visual_bounds`], taking in the
|
||||
/// shapes their art paints with the geometry effects of their own fill or stroke
|
||||
/// ([`crate::hit::set_image_paint`]). A blend's box takes in where its spine can put its keys
|
||||
/// and steps.
|
||||
pub fn reach_bounds(&self) -> Option<Rect> {
|
||||
self.reach(None)
|
||||
}
|
||||
@@ -254,14 +292,8 @@ impl Node {
|
||||
.map(|b| b.inflate(o, o))
|
||||
}
|
||||
NodeKind::Intertwine { children } => children.iter().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, c.reach(symbols))),
|
||||
// The frame and each shape the image's own fills and strokes paint, a stroke's grown by
|
||||
// the farthest it can reach from its shape.
|
||||
NodeKind::Image(_) => {
|
||||
crate::hit::image_paint(symbols.map(SymbolBoxes::document), self).iter().fold(self.geometric(symbols), |acc, (bp, _, item)| {
|
||||
let o = if let crate::AppearanceItem::Stroke(s) = item { s.reach() } else { 0.0 };
|
||||
vectorcraft_geom::union_opt(acc, (!bp.elements().is_empty()).then(|| bp.bounding_box().inflate(o, o)))
|
||||
})
|
||||
}
|
||||
// The frame and each shape the image's own fills and strokes paint.
|
||||
NodeKind::Image(_) => self.with_own_paint(self.geometric(symbols), symbols),
|
||||
// Keys and steps placed on a spine, turned to it with Align to Path, can reach past the
|
||||
// keys and the spine.
|
||||
NodeKind::Blend { children, spec } => {
|
||||
@@ -272,13 +304,15 @@ impl Node {
|
||||
NodeKind::Layer { children, clip: true, .. } | NodeKind::Group { children, clip: true } => {
|
||||
vectorcraft_geom::union_opt(self.visual(symbols), children.first().and_then(|c| crate::hit::reshaped_clip_box(c)))
|
||||
}
|
||||
// The live geometry effects of the clipping paths in the art can draw it past its box.
|
||||
// The live geometry effects of the clipping paths in the art can draw it past its box,
|
||||
// and the box takes in each shape the art paints with the geometry effects of the
|
||||
// instance's own fill or stroke.
|
||||
NodeKind::SymbolInstance { symbol, xf } => {
|
||||
let Some((s, art, region)) = symbols.and_then(|s| {
|
||||
let a = s.art(symbol)?;
|
||||
Some((s, a, a.reshaped?))
|
||||
}) else {
|
||||
return self.visual(symbols);
|
||||
return self.with_own_paint(self.visual(symbols), symbols);
|
||||
};
|
||||
let map = s.document().symbol_slice_map_of(symbol, art.geometric, *xf);
|
||||
let placed = if moves_only(*xf) && map.is_none() {
|
||||
@@ -294,12 +328,22 @@ impl Node {
|
||||
map.map_or_else(|| xf.transform_rect_bbox(all), |m| m.placement_bounds(all)).inflate(grow, grow)
|
||||
};
|
||||
let o = self.appearance.outset();
|
||||
vectorcraft_geom::union_opt(self.visual(symbols), self.projected(Some(placed)).map(|b| b.inflate(o, o)))
|
||||
self.with_own_paint(vectorcraft_geom::union_opt(self.visual(symbols), self.projected(Some(placed)).map(|b| b.inflate(o, o))), symbols)
|
||||
}
|
||||
_ => self.visual(symbols),
|
||||
}
|
||||
}
|
||||
|
||||
/// `start` grown by each shape the node's own fills and strokes paint
|
||||
/// ([`crate::hit::set_image_paint`]), a stroke's grown by the farthest it can reach from its
|
||||
/// shape.
|
||||
fn with_own_paint(&self, start: Option<Rect>, symbols: Option<&SymbolBoxes>) -> Option<Rect> {
|
||||
crate::hit::image_paint(symbols.map(SymbolBoxes::document), self).iter().fold(start, |acc, (bp, _, item)| {
|
||||
let o = if let crate::AppearanceItem::Stroke(s) = item { s.reach() } else { 0.0 };
|
||||
vectorcraft_geom::union_opt(acc, (!bp.elements().is_empty()).then(|| bp.bounding_box().inflate(o, o)))
|
||||
})
|
||||
}
|
||||
|
||||
/// Geometric bounds (no stroke), recursively. Clip groups are bounded by their clip path. A
|
||||
/// symbol instance is measured as its transform applied to the 20 × 20 square around the origin
|
||||
/// that symbols made in the app keep their art in ([`Node::geometric_bounds_with`] measures
|
||||
|
||||
@@ -220,6 +220,13 @@ pub fn language_quotes(language: &str) -> Option<Quotes> {
|
||||
LANGUAGES.iter().find(|(l, _, _)| l.eq_ignore_ascii_case(language)).map(|(_, _, q)| *q)
|
||||
}
|
||||
|
||||
/// The BCP 47 tag of the [`LANGUAGES`] entry named or tagged `language` (case-insensitive), the
|
||||
/// default's included (`en-US`): what a document's language ([`DocSetup::language`]) is written
|
||||
/// as in an exported file. `None` for a language not in the list.
|
||||
pub fn language_tag(language: &str) -> Option<&'static str> {
|
||||
LANGUAGES.iter().find(|(n, t, _)| n.eq_ignore_ascii_case(language) || t.eq_ignore_ascii_case(language)).map(|(_, t, _)| *t)
|
||||
}
|
||||
|
||||
/// The [`LANGUAGES`] entry named or tagged `language` (case-insensitive) as a character's
|
||||
/// language ([`crate::CharStyle::language`]) stores it: its tag, or `None` for the default (the
|
||||
/// first entry); `Err` for a language not in the list.
|
||||
@@ -404,6 +411,16 @@ impl DocSetup {
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// A document's language is written by its tag, the default's included (#3644).
|
||||
#[test]
|
||||
fn document_languages_have_their_tags() {
|
||||
assert_eq!(language_tag(&DocSetup::default().language), Some("en-US"));
|
||||
assert_eq!(language_tag("French"), Some("fr"));
|
||||
assert_eq!(language_tag("german: swiss"), Some("de-CH"));
|
||||
assert_eq!(language_tag("sr-latn"), Some("sr-Latn"));
|
||||
assert_eq!((language_tag("Klingon"), language_tag("")), (None, None));
|
||||
}
|
||||
|
||||
/// Characters store a language of the list by its tag, the default as none.
|
||||
#[test]
|
||||
fn char_languages_are_stored_by_tag() {
|
||||
|
||||
@@ -187,8 +187,9 @@ impl Document {
|
||||
/// [`Document::map_solid_paints`] limited to the art in the subtrees of `ids` (each paint
|
||||
/// visited once even when an id is inside another).
|
||||
pub fn map_solid_paints_in(&mut self, ids: &[NodeId], f: &mut LinkFn) -> usize {
|
||||
let listed: HashSet<NodeId> = ids.iter().copied().collect();
|
||||
let roots: Vec<NodeId> =
|
||||
ids.iter().copied().filter(|id| !self.ancestry(*id).is_some_and(|a| a[..a.len() - 1].iter().any(|p| ids.contains(p)))).collect();
|
||||
ids.iter().copied().filter(|id| !self.ancestry(*id).is_some_and(|a| a[..a.len() - 1].iter().any(|p| listed.contains(p)))).collect();
|
||||
let mut n = 0;
|
||||
let mut g = relink(f);
|
||||
for id in roots {
|
||||
@@ -844,6 +845,77 @@ mod tests {
|
||||
assert_eq!(colors, [(Color::rgb(1.0, 0.0, 0.0), None)]);
|
||||
}
|
||||
|
||||
/// [`Document::map_solid_paints_in`] with each ancestor searched for in `ids` rather than looked up in a set.
|
||||
fn map_solid_paints_in_by_search(d: &mut Document, ids: &[NodeId], f: &mut LinkFn) -> usize {
|
||||
let roots: Vec<NodeId> =
|
||||
ids.iter().copied().filter(|id| !d.ancestry(*id).is_some_and(|a| a[..a.len() - 1].iter().any(|p| ids.contains(p)))).collect();
|
||||
let mut n = 0;
|
||||
let mut g = relink(f);
|
||||
for id in roots {
|
||||
let Some(node) = d.node(id) else { continue };
|
||||
if let Some((new, count)) = map_node(node, &mut g)
|
||||
&& let Some(slot) = d.node_mut(id)
|
||||
{
|
||||
*slot = new;
|
||||
n += count;
|
||||
}
|
||||
}
|
||||
n
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mapping_within_ids_matches_a_search_of_the_ids() {
|
||||
// Two layers: the first holds group `outer` (group `inner` with two rectangles, and a
|
||||
// rectangle) and a rectangle; the second holds a rectangle. Each rectangle has its own color.
|
||||
let mut d = Document::new(100.0, 100.0);
|
||||
let first = d.layers[0].id;
|
||||
let second = d.alloc_id();
|
||||
d.insert(None, usize::MAX, Node::layer(second, "Second", crate::LayerColor::Preset(1))).unwrap();
|
||||
let rect = |d: &mut Document, i: u8| {
|
||||
let id = d.alloc_id();
|
||||
let r = shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0));
|
||||
let color = Color::rgb(f32::from(i) / 8.0, 0.0, 0.0);
|
||||
(id, Arc::new(Node::path(id, r, Appearance::basic(Paint::solid(color), Paint::solid(color), 1.0))))
|
||||
};
|
||||
let (r1, n1) = rect(&mut d, 1);
|
||||
let (r2, n2) = rect(&mut d, 2);
|
||||
let (r3, n3) = rect(&mut d, 3);
|
||||
let (r4, n4) = rect(&mut d, 4);
|
||||
let (r5, n5) = rect(&mut d, 5);
|
||||
let (inner, outer) = (d.alloc_id(), d.alloc_id());
|
||||
let outer_node = Node::group(outer, vec![Arc::new(Node::group(inner, vec![n1, n2])), n3]);
|
||||
d.insert(Some(first), usize::MAX, outer_node).unwrap();
|
||||
d.insert(Some(first), usize::MAX, Arc::unwrap_or_clone(n4)).unwrap();
|
||||
d.insert(Some(second), usize::MAX, Arc::unwrap_or_clone(n5)).unwrap();
|
||||
let missing = NodeId(u64::MAX);
|
||||
let all = [first, second, outer, inner, r1, r2, r3, r4, r5, missing];
|
||||
// Every list of up to three of them: nested ids in both orders, duplicates, a missing id and none.
|
||||
let mut lists: Vec<Vec<NodeId>> = vec![vec![]];
|
||||
let mut shorter: Vec<Vec<NodeId>> = vec![vec![]];
|
||||
for _ in 0..3 {
|
||||
shorter = shorter.iter().flat_map(|l| all.map(|id| [l.as_slice(), &[id]].concat())).collect();
|
||||
lists.extend(shorter.iter().cloned());
|
||||
}
|
||||
assert_eq!(lists.len(), 1 + 10 + 100 + 1000);
|
||||
for ids in &lists {
|
||||
// A callback that changes every paint it visits, so a paint visited twice counts twice.
|
||||
let run = |map: &dyn Fn(&mut Document, &[NodeId], &mut LinkFn) -> usize| {
|
||||
let mut d = d.clone();
|
||||
let mut visits = vec![];
|
||||
let n = map(&mut d, ids, &mut |c, s, t| {
|
||||
visits.push((*c, s.clone(), *t));
|
||||
*s = Some(format!("{}", visits.len()));
|
||||
*t *= 0.5;
|
||||
true
|
||||
});
|
||||
(n, visits, d.layers)
|
||||
};
|
||||
let by_set = run(&|d, ids, f| d.map_solid_paints_in(ids, f));
|
||||
let by_search = run(&|d, ids, f| map_solid_paints_in_by_search(d, ids, f));
|
||||
assert_eq!(by_set, by_search, "{ids:?}");
|
||||
}
|
||||
}
|
||||
|
||||
/// The colors [`node_colors`] visits, in its order, by a [`Node::walk`] that reads the whole subtree.
|
||||
fn full_walk(n: &Node, f: &mut dyn FnMut(&Color, Option<&str>)) {
|
||||
n.walk(&mut |m| {
|
||||
|
||||
@@ -157,6 +157,58 @@ fn cached_lookups_follow_any_edit_of_the_tree() {
|
||||
}
|
||||
}
|
||||
|
||||
/// Every node whose id is in `ids`, by walking the tree.
|
||||
fn every_node(d: &Document, ids: &[NodeId]) -> Vec<*const Node> {
|
||||
let mut out = vec![];
|
||||
d.walk(|n| {
|
||||
if ids.contains(&n.id) {
|
||||
out.push(n as *const Node);
|
||||
}
|
||||
});
|
||||
out
|
||||
}
|
||||
|
||||
/// [`Document::nodes_in_order`] gives every node with each id in tree order, repeated ids
|
||||
/// included, with the cache built and without it, for a few ids (cached paths) and for many (a
|
||||
/// walk).
|
||||
#[test]
|
||||
fn nodes_in_order_match_a_walk() {
|
||||
for seed in 1..40 {
|
||||
let (d, ids) = tree(seed);
|
||||
let few: Vec<NodeId> = ids.iter().copied().step_by(17).collect();
|
||||
for cold in [true, false] {
|
||||
if cold {
|
||||
d.drop_lookup_cache();
|
||||
} else {
|
||||
d.node(ids[0]);
|
||||
}
|
||||
for list in [&ids[..], &few[..], &ids[ids.len() / 2..ids.len() / 2 + 1], &[]] {
|
||||
let found: Vec<*const Node> = d.nodes_in_order(list.iter().copied()).into_iter().map(|n| n as *const Node).collect();
|
||||
assert_eq!(found, every_node(&d, list), "seed {seed}, cold {cold}, {list:?}");
|
||||
}
|
||||
}
|
||||
// An id that the tree repeats: every node with it.
|
||||
let Some(dup) = ids.iter().enumerate().find(|(i, id)| ids[..*i].contains(id)).map(|(_, id)| *id) else { continue };
|
||||
assert!(d.nodes_in_order([dup]).len() >= 2, "seed {seed}: {dup:?} is in the tree more than once");
|
||||
// A second node given an id once held once, after the cache was built: the lookup finds the
|
||||
// cached node, which has that id; with the cache built afresh, both.
|
||||
let mut d = d;
|
||||
let once = ids.iter().copied().find(|id| every_node(&d, &[*id]).len() == 1 && d.node(*id).is_some_and(|n| !n.is_layer()));
|
||||
let Some(once) = once else { continue };
|
||||
d.node(once);
|
||||
let copy = Arc::new(Node::path(once, shapes::rectangle(Rect::new(0.0, 0.0, 2.0, 2.0)), Appearance::default_art()));
|
||||
if let Some(ch) = Arc::make_mut(&mut d.layers[0]).children_mut() {
|
||||
ch.insert(0, copy);
|
||||
}
|
||||
let found = d.nodes_in_order([once]);
|
||||
assert!(!found.is_empty() && found.iter().all(|n| n.id == once), "seed {seed}: {once:?}");
|
||||
d.drop_lookup_cache();
|
||||
d.node(once);
|
||||
let found: Vec<*const Node> = d.nodes_in_order([once]).into_iter().map(|n| n as *const Node).collect();
|
||||
assert_eq!(found, every_node(&d, &[once]), "seed {seed}: {once:?} cached afresh");
|
||||
}
|
||||
}
|
||||
|
||||
/// Nodes of `d` picked and ordered by `seed`. None lies inside another, and each of them, and each
|
||||
/// node it is in, appears in the tree once.
|
||||
fn picks(d: &Document, seed: u64) -> Vec<NodeId> {
|
||||
@@ -282,3 +334,112 @@ fn edits_of_many_refuse_missing_repeated_and_nested_ids() {
|
||||
assert_eq!(serde_json::to_string(&b).ok(), saved, "{what}: the document stays as it was");
|
||||
}
|
||||
}
|
||||
|
||||
/// The nearest node passing `pred` at or above `id`, as `ancestry` read from the end with `node`
|
||||
/// for each id finds it.
|
||||
fn nearest_by_ancestry(d: &Document, id: NodeId, pred: impl Fn(&Node) -> bool) -> Option<*const Node> {
|
||||
d.ancestry(id).unwrap_or_default().into_iter().rev().find_map(|a| d.node(a).filter(|n| pred(n))).map(|n| n as *const Node)
|
||||
}
|
||||
|
||||
/// [`Document::nearest_finder`] gives what [`nearest_by_ancestry`] gives for every id, on a clone
|
||||
/// each, so both start from the same cache.
|
||||
fn nearest_agrees(d: &Document, ids: &[NodeId], what: &str) {
|
||||
type Pred = fn(&Node) -> bool;
|
||||
let preds: [(&str, Pred); 5] = [
|
||||
("group", |n| matches!(n.kind, NodeKind::Group { .. })),
|
||||
("layer", |n| n.is_layer()),
|
||||
("any", |_| true),
|
||||
("none", |_| false),
|
||||
("id divisible by 3", |n| n.id.0 % 3 == 0),
|
||||
];
|
||||
for (name, pred) in preds {
|
||||
let (a, b) = (d.clone(), d.clone());
|
||||
let want: Vec<_> = ids.iter().map(|id| nearest_by_ancestry(&a, *id, pred)).collect();
|
||||
let mut find = b.nearest_finder();
|
||||
let got: Vec<_> = ids.iter().map(|id| find.nearest(*id, pred).map(|n| n as *const Node)).collect();
|
||||
assert_eq!(got, want, "{what}: {name}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nearest_finder_matches_the_ancestry_walk() {
|
||||
for seed in 1..30 {
|
||||
let (mut d, ids) = tree(seed);
|
||||
nearest_agrees(&d, &ids, "no cache");
|
||||
d.node(ids[0]);
|
||||
nearest_agrees(&d, &ids, "cached");
|
||||
// Every path in the first layer shifts: the cache is stale there.
|
||||
let extra = d.alloc_id();
|
||||
let leaf = Arc::new(Node::path(extra, shapes::rectangle(Rect::new(0.0, 0.0, 1.0, 1.0)), Appearance::default_art()));
|
||||
if let Some(ch) = Arc::make_mut(&mut d.layers[0]).children_mut() {
|
||||
ch.insert(0, leaf);
|
||||
}
|
||||
nearest_agrees(&d, &ids, "a stale cache");
|
||||
// A group with the id of a node in the last layer, earlier in tree order than it, put in
|
||||
// after the cache was built.
|
||||
d.drop_lookup_cache();
|
||||
d.node(ids[0]);
|
||||
let last = d.layers.len() - 1;
|
||||
let dup = d.layers[last].children().and_then(|c| c.last()).map(|n| n.id);
|
||||
if let Some(dup) = dup
|
||||
&& let Some(ch) = Arc::make_mut(&mut d.layers[0]).children_mut()
|
||||
{
|
||||
ch.insert(0, Arc::new(Node::group(dup, vec![])));
|
||||
}
|
||||
nearest_agrees(&d, &ids, "a duplicate put in after the cache was built");
|
||||
d.drop_lookup_cache();
|
||||
nearest_agrees(&d, &ids, "a duplicate, cached afresh");
|
||||
}
|
||||
}
|
||||
|
||||
/// An id on the path that an earlier node of another kind also has: the earlier node is the one
|
||||
/// tested, as `node` gives it.
|
||||
#[test]
|
||||
fn nearest_finder_tests_the_first_node_with_a_repeated_id() {
|
||||
let mut d = Document::new(612.0, 792.0);
|
||||
let layer = d.layers[0].id;
|
||||
let leaf = |id: u64| Arc::new(Node::path(NodeId(id), shapes::rectangle(Rect::new(0.0, 0.0, 5.0, 5.0)), Appearance::default_art()));
|
||||
d.insert(Some(layer), 0, Node::group(NodeId(500), vec![leaf(501)])).unwrap();
|
||||
d.insert(Some(layer), 1, Node::path(NodeId(600), shapes::rectangle(Rect::new(0.0, 0.0, 5.0, 5.0)), Appearance::default_art())).unwrap();
|
||||
// A group that has the path's id, after the path in tree order.
|
||||
d.insert(Some(layer), 2, Node::group(NodeId(600), vec![leaf(601)])).unwrap();
|
||||
let is_group = |n: &Node| matches!(n.kind, NodeKind::Group { .. });
|
||||
for cached in [false, true] {
|
||||
d.drop_lookup_cache();
|
||||
if cached {
|
||||
d.node(layer);
|
||||
}
|
||||
let mut find = d.nearest_finder();
|
||||
assert_eq!(find.nearest(NodeId(501), is_group).map(|n| n.id), Some(NodeId(500)), "cached {cached}");
|
||||
assert_eq!(find.nearest(NodeId(601), is_group).map(|n| n.id), None, "cached {cached}: id 600 is the path");
|
||||
assert_eq!(find.nearest(NodeId(999_999), is_group).map(|n| n.id), None, "cached {cached}: not in the tree");
|
||||
}
|
||||
}
|
||||
|
||||
/// With the cache built, finding the nearest group of every object of a large tree looks no id up
|
||||
/// and walks the tree no time.
|
||||
#[test]
|
||||
fn nearest_finder_reads_one_path_per_object() {
|
||||
let mut d = Document::new(612.0, 792.0);
|
||||
let layer = d.layers[0].id;
|
||||
let mut leaves = vec![];
|
||||
for g in 0..2_000 {
|
||||
let kids: Vec<Arc<Node>> = (0..3)
|
||||
.map(|_| {
|
||||
let id = d.alloc_id();
|
||||
leaves.push(id);
|
||||
Arc::new(Node::path(id, shapes::rectangle(Rect::new(0.0, 0.0, 5.0, 5.0)), Appearance::default_art()))
|
||||
})
|
||||
.collect();
|
||||
let gid = d.alloc_id();
|
||||
d.insert(Some(layer), g, Node::group(gid, kids)).unwrap();
|
||||
}
|
||||
d.drop_lookup_cache();
|
||||
d.node(layer);
|
||||
let (lookups, walks) = (path_lookups(), tree_walks());
|
||||
let mut find = d.nearest_finder();
|
||||
let found = leaves.iter().filter(|id| find.nearest(**id, |n| matches!(n.kind, NodeKind::Group { .. })).is_some()).count();
|
||||
assert_eq!(found, leaves.len());
|
||||
assert_eq!(path_lookups() - lookups, 0, "lookups by id");
|
||||
assert_eq!(tree_walks() - walks, 0, "walks of the tree");
|
||||
}
|
||||
@@ -28,7 +28,8 @@ use vectorcraft_geom::{Affine, FillRule, PathData, Rect, Vec2};
|
||||
use crate::distort::{transform_move, transform_offsets};
|
||||
use crate::group::{has_own_paint, paints};
|
||||
use crate::reshape::{
|
||||
as_art, clipping_text_outline, dressed, geometry_effects, glyph_outlines, outline_nested_text, paint_type_clip, reshape_leaves,
|
||||
as_art, clip_region_path, clipping_text_outline, dressed, geometry_effects, glyph_outlines, knockout_inside, outline_nested_text,
|
||||
paint_type_clip, reshape_leaves,
|
||||
};
|
||||
use crate::{
|
||||
GeomContext, adjust_in_document, apply_geometry_carrying, crop_marks_art, evaluate_container, has_adjustment, has_crop_marks, has_geometry,
|
||||
@@ -502,13 +503,7 @@ fn clip_group_with_type_clip(d: &mut Document, n: &Node) -> Option<Node> {
|
||||
{
|
||||
return None;
|
||||
}
|
||||
let (bp, rule) = crate::clip_outline(first)?;
|
||||
let mut clip = Node::path(first.id, PathData::from_bezpath(&bp), Appearance::default());
|
||||
if let NodeKind::Path { rule: r, clipping, .. } = &mut clip.kind {
|
||||
(*r, *clipping) = (rule, true);
|
||||
}
|
||||
clip.name = first.name.clone();
|
||||
clip.visible = first.visible;
|
||||
let clip = clip_region_path(first)?;
|
||||
let paint = first.clip_paint();
|
||||
// The type's fills and strokes as art: baked with the type's id, as the renderer draws them,
|
||||
// then given ids of their own.
|
||||
@@ -532,7 +527,8 @@ fn clip_group_with_type_clip(d: &mut Document, n: &Node) -> Option<Node> {
|
||||
return Some(m);
|
||||
};
|
||||
// `n` keeps its id, name and transparency, and holds the clip group and the strokes over it.
|
||||
let inner = Node::new(d.alloc_id(), NodeKind::Group { children: members, clip: true });
|
||||
let mut inner = Node::new(d.alloc_id(), NodeKind::Group { children: members, clip: true });
|
||||
knockout_inside(&mut m, &mut inner);
|
||||
match &mut m.kind {
|
||||
NodeKind::Group { children, clip } | NodeKind::Layer { children, clip, .. } => {
|
||||
*children = vec![Arc::new(inner), stroke];
|
||||
|
||||
@@ -776,7 +776,7 @@ fn type_outlined_next_to_type_that_stays_type_keeps_its_look() {
|
||||
let mut shadowed = type_node(55);
|
||||
shadowed.opacity = 0.5;
|
||||
shadowed.appearance.effects.push(fx("stylize.dropShadow", json!({})));
|
||||
// Type that clips a group is outlined as the plain outlines it clips by.
|
||||
// Type that clips a group is outlined as a plain path of the region it clips by.
|
||||
let square = Node::path(NodeId(57), shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 100.0)), Appearance::default_art());
|
||||
let clip = Node::new(NodeId(58), NodeKind::Group { children: vec![Arc::new(type_node(56)), Arc::new(square)], clip: true });
|
||||
g.children_mut().unwrap().extend([Arc::new(shadowed), Arc::new(clip)]);
|
||||
@@ -789,7 +789,10 @@ fn type_outlined_next_to_type_that_stays_type_keeps_its_look() {
|
||||
let b = o.geometric_bounds().unwrap();
|
||||
assert!(b.x0 < 30.0 && b.x1 > 220.0, "{b:?}");
|
||||
let clipped = d.node(NodeId(58)).and_then(|n| n.children()).and_then(|c| c.first()).unwrap();
|
||||
assert!(matches!(clipped.kind, NodeKind::Group { .. }) && clipped.opacity == 1.0, "{clipped:?}");
|
||||
assert!(matches!(clipped.kind, NodeKind::Path { .. } | NodeKind::Compound { .. }) && clipped.opacity == 1.0, "{clipped:?}");
|
||||
// The region is copied with the type.
|
||||
let b = clipped.geometric_bounds().unwrap();
|
||||
assert!(b.x0 < 30.0 && b.x1 > 220.0, "{b:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -189,7 +189,7 @@ pub fn effect_catalog() -> Vec<EffectInfo> {
|
||||
EXTRUDE,
|
||||
"Extrude & Bevel…",
|
||||
&["Effect", "3D and Materials"],
|
||||
"{depth: pt (0..2000, 50), twist: degrees (0..360, 0; the back turned against the front), taper: % (1..100, 100; the back's size), cap: bool (true: solid; false: hollow), bevel: none|classic|rounded|cove|step|ogee (none), bevelWidth: pt (0..1000, 4), bevelHeight: pt (0..1000, 4), bevelRepeat: integer (1..32, 1), bevelSpace: % (0..90, 0; flat between repeats), bevelInside: bool (false: added around the shape; true: carved into it), bevelBothSides: bool (false), rotationX: degrees (-180..180, -21.88), rotationY: degrees (-180..180, -23.4), rotationZ: degrees (-180..180, 9.06; the defaults are the Off-Axis Front position), perspectiveAngle: degrees (0..160, 0; 0 is none, wider brings the eye nearer), perspective: % (0..100; the earlier form, read as the perspectiveAngle that shows the same view), shade: bool (true), lightColor: #rrggbb (white, #ffffff; legacy directional light color), lights: null or array of 1..10 objects (color: #rrggbb, intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, softness: % 0..100, behind: bool; overrides the single-light fields; ambient is shared), lightRotation: degrees (-180..180, 125.26; round the object on the page, 0 on its right, counterclockwise), lightHeight: degrees (0..90, 30; 0 beside the object, 90 straight in front), lightBehind: bool (false; true lights it from behind), lightIntensity: % (0..100, 80), lightSoftness: % (0..100, 0; how far round the object the light reaches, and how much it blurs the shadow), ambient: % (0..200, 25; Ambient Light), lightAzimuth: degrees (the earlier form: with lightElevation, read as the lightRotation, lightHeight and lightBehind of the same light), lightElevation: degrees (the earlier form, with lightAzimuth), shadow: bool (false; the first light casts a shadow, black at 50% times the art's opacity, hard-edged at the first light's softness 0 and blurred above it), shadowPosition: behind|below (behind; behind: on a plane square to the view, below: on the floor under the object, turned with it), shadowDistance: % (0..100, 0; how far the plane is from the object, as a share of its largest size), shadowBounds: % (10..400, 100; how far the plane reaches: at 100 it is four times the object's largest size across), graphics: array of 0..64 objects ([]; the 3D and Materials panel's Graphics on the caps, see threeD.mapGraphic: symbol: name of a document symbol, face: front|back (front; the back reads left to right as seen from behind), x: pt (0; the offset of the graphic's center from the center of the object's bounds, in the face's own plane), y: pt (0), scale: % (1..10000, 100; of the symbol's own size), rotation: degrees (-360..360, 0; counterclockwise); drawn turned, foreshortened and shaded with the cap and clipped to it, on a solid cap only), render: object ({mode: shaded}; mode: shaded|wireframe, as Revolve's)}. The front face is the art, extruded backwards about the centre of its bounds; painted with the top fill (else the top stroke).",
|
||||
"{depth: pt (0..2000, 50), twist: degrees (0..360, 0; the back turned against the front), taper: % (1..100, 100; the back's size), cap: bool (true: solid; false: hollow), bevel: none|classic|rounded|cove|step|ogee (none), bevelWidth: pt (0..1000, 4), bevelHeight: pt (0..1000, 4), bevelRepeat: integer (1..32, 1), bevelSpace: % (0..90, 0; flat between repeats), bevelInside: bool (false: added around the shape; true: carved into it), bevelBothSides: bool (false), rotationX: degrees (-180..180, -21.88), rotationY: degrees (-180..180, -23.4), rotationZ: degrees (-180..180, 9.06; the defaults are the Off-Axis Front position), perspectiveAngle: degrees (0..160, 0; 0 is none, wider brings the eye nearer), perspective: % (0..100; the earlier form, read as the perspectiveAngle that shows the same view), shade: bool (true), lightColor: #rrggbb (white, #ffffff; legacy directional light color), lights: null or array of 1..10 objects (color: #rrggbb, intensity: % 0..100, rotation: degrees -180..180, height: degrees 0..90, softness: % 0..100, behind: bool; overrides the single-light fields; ambient is shared), lightRotation: degrees (-180..180, 125.26; round the object on the page, 0 on its right, counterclockwise), lightHeight: degrees (0..90, 30; 0 beside the object, 90 straight in front), lightBehind: bool (false; true lights it from behind), lightIntensity: % (0..100, 80), lightSoftness: % (0..100, 0; how far round the object the light reaches, and how much it blurs the shadow), ambient: % (0..200, 25; Ambient Light), lightAzimuth: degrees (the earlier form: with lightElevation, read as the lightRotation, lightHeight and lightBehind of the same light), lightElevation: degrees (the earlier form, with lightAzimuth), shadow: bool (false; the first light casts a shadow, black at 50% times the art's opacity, hard-edged at the first light's softness 0 and blurred above it), shadowPosition: behind|below (behind; behind: on a plane square to the view, below: on the floor under the object, turned with it), shadowDistance: % (0..100, 0; how far the plane is from the object, as a share of its largest size), shadowBounds: % (10..400, 100; how far the plane reaches: at 100 it is four times the object's largest size across), graphics: array of 0..64 objects ([]; the 3D and Materials panel's Graphics on the caps and the side, see threeD.mapGraphic: symbol: name of a document symbol, face: front|back|side (front; the back reads left to right as seen from behind; side is the walls and bevels), x: pt (0; the offset of the graphic's center from the center of the object's bounds, in the face's own plane; on the side from the middle of the side unrolled flat, along the outline, clockwise from its top), y: pt (0; on the side from the front toward the back), scale: % (1..10000, 100; of the symbol's own size), rotation: degrees (-360..360, 0; counterclockwise); drawn turned, foreshortened and shaded with the face and clipped to it: on a cap of a solid object only, and on the side of a solid or hollow object wrapped around it and drawn only where its outside faces the viewer), render: object ({mode: shaded}; mode: shaded|wireframe, as Revolve's)}. The front face is the art, extruded backwards about the centre of its bounds; painted with the top fill (else the top stroke).",
|
||||
json!({"depth":50.0,"twist":0.0,"taper":100.0,"cap":true,"bevel":"none","bevelWidth":4.0,"bevelHeight":4.0,"bevelRepeat":1,"bevelSpace":0.0,"bevelInside":false,"bevelBothSides":false,"rotationX":-21.88,"rotationY":-23.4,"rotationZ":9.06,"perspectiveAngle":0.0,"shade":true,"lightColor":"#ffffff","lights":null,"lightRotation":125.26438968275465,"lightHeight":30.0,"lightBehind":false,"lightIntensity":80.0,"lightSoftness":0.0,"ambient":25.0,"shadow":false,"shadowPosition":"behind","shadowDistance":0.0,"shadowBounds":100.0,"graphics":[],"render":{"mode":"shaded"}}),
|
||||
),
|
||||
g(
|
||||
@@ -277,7 +277,13 @@ pub fn effect_catalog() -> Vec<EffectInfo> {
|
||||
"{h: amount (10), v: amount (10), relative: bool (true: % of size), anchors: bool (true), in: bool (true), out: bool (true), seed: int (0)}",
|
||||
json!({"h": 10.0, "v": 10.0, "relative": true, "anchors": true, "in": true, "out": true, "seed": 0}),
|
||||
),
|
||||
g("distort.twist", "Twist…", DT, "{angle: deg (-3600..3600, 10)}", json!({"angle": 10.0})),
|
||||
g(
|
||||
"distort.twist",
|
||||
"Twist…",
|
||||
DT,
|
||||
"{angle: deg (-3600..3600, 10)} Outer-circle anchors stay fixed; their handles follow the inward tangent.",
|
||||
json!({"angle": 10.0}),
|
||||
),
|
||||
g(
|
||||
"distort.zigZag",
|
||||
"Zig Zag…",
|
||||
|
||||
@@ -6,7 +6,7 @@ use vectorcraft_geom::{Affine, Anchor, ParamCurve, PathData, Point, Rect, SubPat
|
||||
use vectorcraft_pathops::addons::pathtools::insert_at;
|
||||
|
||||
use crate::util::{
|
||||
catmull_rom, fit_piece, flag, map_nonlinear_within, map_smooth_within, mean_size, noise, normal_at, num, pieces, seed, seg_cubic, smooth_points,
|
||||
catmull_rom, fit_piece, flag, map_handles_within, map_nonlinear_within, mean_size, noise, normal_at, num, pieces, seed, seg_cubic, smooth_points,
|
||||
};
|
||||
|
||||
fn diag(b: Rect) -> f64 {
|
||||
@@ -328,7 +328,7 @@ pub fn tweak(path: &PathData, b: Rect, p: &Value) -> PathData {
|
||||
|
||||
/// Twist: rotation that is strongest at the centre and fades to zero at the bounding circle,
|
||||
/// clockwise on the page for a positive `angle`, making at most `max` anchors. Its handles follow
|
||||
/// the rotation's derivative ([`map_smooth_within`]), so the pieces join without kinks (#7069).
|
||||
/// the rotation's directional derivative, including each side of the outer circle.
|
||||
pub fn twist(path: &PathData, b: Rect, angle: f64, max: usize) -> PathData {
|
||||
let ang = angle.clamp(-3600.0, 3600.0).to_radians();
|
||||
if ang == 0.0 {
|
||||
@@ -336,16 +336,46 @@ pub fn twist(path: &PathData, b: Rect, angle: f64, max: usize) -> PathData {
|
||||
}
|
||||
let c = b.center();
|
||||
let r = diag(b) / 2.0;
|
||||
let half = Vec2::new(b.width() * 0.5, b.height() * 0.5);
|
||||
let boundary = move |p: Point, length: f64| {
|
||||
if length == r {
|
||||
return true;
|
||||
}
|
||||
if !r.is_finite() || (length - r).abs() > 8.0 * f64::EPSILON * r {
|
||||
return false;
|
||||
}
|
||||
// A bounds-relative distance identifies boundary points affected by center rounding.
|
||||
(Vec2::new(p.x - b.x0, p.y - b.y0) - half).hypot() == r
|
||||
};
|
||||
let f = move |q: Point| {
|
||||
let d = q - c;
|
||||
let t = (1.0 - d.hypot() / r).max(0.0);
|
||||
let length = d.hypot();
|
||||
let t = (1.0 - length / r).max(0.0);
|
||||
// y runs down, so a positive turn is clockwise on the page.
|
||||
let a = ang * t;
|
||||
if a == 0.0 {
|
||||
return q;
|
||||
}
|
||||
let (s, co) = a.sin_cos();
|
||||
c + Vec2::new(d.x * co - d.y * s, d.x * s + d.y * co)
|
||||
};
|
||||
let piece = (r / 8.0).min(r / (1.0 + ang.abs() * 2.0));
|
||||
map_smooth_within(path, piece, max, f)
|
||||
map_handles_within(path, piece, max, f, |p, h| {
|
||||
let v = h - p;
|
||||
if !v.hypot().is_finite() {
|
||||
return f(p);
|
||||
}
|
||||
let d = p - c;
|
||||
let length = d.hypot();
|
||||
let radial = if length > 0.0 { (d / length).dot(v) } else { 0.0 };
|
||||
// The clamped rotation has different inward and outward derivatives at the circle.
|
||||
let inside = if boundary(p, length) { radial < 0.0 } else { length < r };
|
||||
let gradient = if inside { -ang / r * radial } else { 0.0 };
|
||||
let tangent = if gradient == 0.0 { v } else { v + Vec2::new(-d.y, d.x) * gradient };
|
||||
let a = ang * (1.0 - length / r).max(0.0);
|
||||
let (s, co) = a.sin_cos();
|
||||
f(p) + Vec2::new(tangent.x * co - tangent.y * s, tangent.x * s + tangent.y * co)
|
||||
})
|
||||
}
|
||||
|
||||
const ZIGZAG_ARCLEN_ACCURACY: f64 = 1e-4;
|
||||
|
||||
@@ -312,6 +312,36 @@ impl Carry {
|
||||
}
|
||||
}
|
||||
|
||||
/// Undo the actual maps of already placed gradients. Failure only changes this temporary
|
||||
/// appearance; callers retain the stored row unchanged when a map cannot be inverted.
|
||||
pub(crate) fn unapply_placed(&self, ap: &mut Appearance) -> Option<()> {
|
||||
for step in self.0.iter().rev() {
|
||||
for item in &mut ap.items {
|
||||
if !matches!(item.paint(), vectorcraft_doc::color::Paint::Gradient(_)) {
|
||||
continue;
|
||||
}
|
||||
let map = match *step {
|
||||
CarryStep::Affine { m, .. } => m,
|
||||
CarryStep::Boxes { from, to } => match item {
|
||||
AppearanceItem::Fill(_) => crate::reshape::box_map(from, to),
|
||||
AppearanceItem::Stroke(s) => crate::reshape::box_map(s.paint_bounds(from), s.paint_bounds(to)),
|
||||
},
|
||||
};
|
||||
if vectorcraft_doc::node::flattens(map) {
|
||||
return None;
|
||||
}
|
||||
let inverse = map.inverse();
|
||||
if !inverse.is_finite() {
|
||||
return None;
|
||||
}
|
||||
if let vectorcraft_doc::color::Paint::Gradient(g) = item.paint_mut() {
|
||||
g.transform(inverse);
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(())
|
||||
}
|
||||
|
||||
pub(crate) fn push(&mut self, more: Carry) {
|
||||
self.0.extend(more.0);
|
||||
self.1.extend(more.1);
|
||||
|
||||
+113
-33
@@ -110,13 +110,15 @@ fn leaves(doc: Option<&Document>, n: &Node, hook: Option<OutlineHook>, nodes: &S
|
||||
// Every path of the outline art, at any depth, is drawn inside the object's opacity
|
||||
// and blend mode. A symbol's art comes with the live objects and the instances of
|
||||
// other symbols inside it given as their art, and the type inside it outlined, so the
|
||||
// art has nothing left for `hook` to give.
|
||||
// art has nothing left for `hook` to give. Its fills and strokes carry the geometry
|
||||
// effects of the instance's active fill and stroke, as the canvas draws them.
|
||||
if let Some(h) = hook
|
||||
&& let Some(art) = h(n)
|
||||
{
|
||||
let art = match &n.kind {
|
||||
NodeKind::SymbolInstance { symbol, .. } if nodes.charge(&art) => {
|
||||
let mut art = crate::reshape::symbol_art_with(&art, h, nodes, symbol);
|
||||
let mut art = instance_art(doc, &art, h, nodes, symbol);
|
||||
crate::reshape::add_instance_row_effects(doc, n, &mut art);
|
||||
crate::reshape::outline_nested_text(doc, &mut art, false);
|
||||
transparency_into_members(&mut art);
|
||||
art
|
||||
@@ -134,6 +136,19 @@ fn leaves(doc: Option<&Document>, n: &Node, hook: Option<OutlineHook>, nodes: &S
|
||||
}
|
||||
}
|
||||
|
||||
/// `art`, the art `hook` gave an instance of the symbol named `symbol`, with the live objects and
|
||||
/// the instances of other symbols inside it given as their art
|
||||
/// ([`crate::reshape::symbol_art_with`]). The art of each of those instances carries the geometry
|
||||
/// effects of its own active fill and stroke ([`crate::reshape::add_instance_row_effects`]).
|
||||
fn instance_art(doc: Option<&Document>, art: &Node, hook: OutlineHook, nodes: &SymbolNodes, symbol: &str) -> Node {
|
||||
let drawn = |m: &Node| {
|
||||
let mut a = hook(m)?;
|
||||
crate::reshape::add_instance_row_effects(doc, m, &mut a);
|
||||
Some(a)
|
||||
};
|
||||
crate::reshape::symbol_art_with(art, &drawn, nodes, symbol)
|
||||
}
|
||||
|
||||
/// `l`, a path drawn inside `n`: its opacity multiplied by `n`'s, and `n`'s blend mode when it is
|
||||
/// not Normal.
|
||||
fn within(l: &mut Node, n: &Node) {
|
||||
@@ -221,13 +236,15 @@ fn reshaped_art(doc: Option<&Document>, n: &Node, hook: Option<OutlineHook>, nod
|
||||
}
|
||||
},
|
||||
// A symbol instance with a warp: its symbol's art placed by the instance, with the type
|
||||
// inside it outlined, reshaped as one piece, as the renderer draws it.
|
||||
// inside it outlined, reshaped as one piece, as the renderer draws it. The fills and strokes
|
||||
// of the art then carry the geometry effects of the instance's active fill and stroke.
|
||||
NodeKind::SymbolInstance { symbol, .. } if !fx.is_empty() => {
|
||||
let h = hook?;
|
||||
let art = h(n).filter(|art| nodes.charge(art))?;
|
||||
let mut art = crate::reshape::symbol_art_with(&art, h, nodes, symbol);
|
||||
let mut art = instance_art(doc, &art, h, nodes, symbol);
|
||||
crate::reshape::outline_nested_text(doc, &mut art, false);
|
||||
members_as_drawn(doc, &mut art);
|
||||
crate::reshape::add_instance_row_effects(doc, n, &mut art);
|
||||
let carry = crate::reshape::reshape_leaves_carrying(&mut art, &fx, &n.appearance.effects, doc);
|
||||
// The art's own fills and strokes follow the effects as its members do.
|
||||
if carry.moves(&art.appearance) {
|
||||
@@ -703,6 +720,11 @@ pub fn member_shapes(doc: Option<&Document>, n: &Node) -> Vec<(PathData, FillRul
|
||||
}
|
||||
}
|
||||
fn members(doc: Option<&Document>, n: &Node, out: &mut Vec<(PathData, FillRule)>) {
|
||||
// A clip group whose clipping type's strokes paint around it is outlined as that clip
|
||||
// group: the strokes outside the clip add nothing.
|
||||
if let Some(inner) = crate::reshape::painted_clip_inner(n) {
|
||||
return members(doc, inner, out);
|
||||
}
|
||||
// A clip group shows its members only inside its clipping path: its outline is that
|
||||
// region, not the clipped members' own shapes, which may reach far outside it (#7289).
|
||||
if n.clips() {
|
||||
@@ -824,23 +846,19 @@ fn take_sublayer_guides(n: &mut Node, out: &mut Vec<Arc<Node>>, is_guide: &impl
|
||||
take_held_guides(n, held, out, false, false);
|
||||
}
|
||||
|
||||
/// `n`, a group or layer, as plain art: its Pathfinder effects evaluated, its geometry effects
|
||||
/// reshaping all its members as one piece (the whole art's bounds as their reference box) after
|
||||
/// the members' own geometry and Pathfinder effects ([`members_as_drawn`]), and its
|
||||
/// own fills and strokes turned into art painting the members' geometry ([`member_shapes`]) below
|
||||
/// the members (after a clipping path) or above them, as its contents slot says. Its
|
||||
/// transparency, opacity mask and raster effects stay. `None` when it has none of these. Live
|
||||
/// objects among the members are evaluated with the symbols of `doc` (see [`member_shapes`]), and
|
||||
/// a Pathfinder operation or compound shape takes the symbol instances among its members as their
|
||||
/// symbols' art from `doc`. A Transform effect that makes copies with raster effects listed before
|
||||
/// it gives each copy those raster effects ([`copied_container`]).
|
||||
pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
|
||||
struct PreparedContainer {
|
||||
m: Node,
|
||||
guides: Vec<Arc<Node>>,
|
||||
paint: bool,
|
||||
carry: crate::Carry,
|
||||
}
|
||||
|
||||
/// The existing container pass up to its own rows becoming art. Keep its carried appearance for
|
||||
/// rendering, and retain the same Carry for freezing only missing stored placements separately.
|
||||
fn prepare_container(doc: Option<&Document>, n: &Node) -> Option<PreparedContainer> {
|
||||
if !is_container(n) {
|
||||
return None;
|
||||
}
|
||||
if let Some(t) = crate::reshape::copied_container_raster_at(n) {
|
||||
return Some(copied_container(doc, n, t));
|
||||
}
|
||||
let pathfinder = has_pathfinder(n);
|
||||
let fx = crate::reshape::geometry_effects(n);
|
||||
let paint = has_own_paint(n);
|
||||
@@ -848,6 +866,7 @@ pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
|
||||
return None;
|
||||
}
|
||||
let mut m = n.clone();
|
||||
let mut carry = crate::Carry::default();
|
||||
// Its ruler guides take no part: they go back above the evaluated art at the end. With effects
|
||||
// that replace or copy the art, so do its guides among the art and those in its sublayers and
|
||||
// groups, which would otherwise go with that art: they stay on `n`, in order, hidden and
|
||||
@@ -874,7 +893,7 @@ pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
|
||||
let _later = crate::raster::LaterGroups::enter(&n.appearance.effects);
|
||||
members_as_drawn(doc, &mut m);
|
||||
}
|
||||
let carry = crate::reshape::reshape_leaves_carrying(&mut m, &fx, &n.appearance.effects, doc);
|
||||
carry = crate::reshape::reshape_leaves_carrying(&mut m, &fx, &n.appearance.effects, doc);
|
||||
// The group's own fills and strokes paint the members as a whole: their gradients follow
|
||||
// the effects as the members' do.
|
||||
if paint && carry.moves(&m.appearance) {
|
||||
@@ -883,15 +902,40 @@ pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
|
||||
}
|
||||
m.appearance.effects = crate::raster::without_geometry(&m.appearance.effects);
|
||||
m.appearance.effects.retain(|e| !is_pathfinder(&e.id));
|
||||
Some(PreparedContainer { m, guides, paint, carry })
|
||||
}
|
||||
|
||||
/// `n`, a group or layer, as plain art: its Pathfinder effects evaluated, its geometry effects
|
||||
/// reshaping all its members as one piece (the whole art's bounds as their reference box) after
|
||||
/// the members' own geometry and Pathfinder effects ([`members_as_drawn`]), and its
|
||||
/// own fills and strokes turned into art painting the members' geometry ([`member_shapes`]) below
|
||||
/// the members (after a clipping path) or above them, as its contents slot says. Its
|
||||
/// transparency, opacity mask and raster effects stay. `None` when it has none of these. Live
|
||||
/// objects among the members are evaluated with the symbols of `doc` (see [`member_shapes`]), and
|
||||
/// a Pathfinder operation or compound shape takes the symbol instances among its members as their
|
||||
/// symbols' art from `doc`. A Transform effect that makes copies with raster effects listed before
|
||||
/// it gives each copy those raster effects ([`copied_container`]).
|
||||
pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
|
||||
if !is_container(n) {
|
||||
return None;
|
||||
}
|
||||
if let Some(t) = crate::reshape::copied_container_raster_at(n) {
|
||||
return Some(copied_container(doc, n, t));
|
||||
}
|
||||
let PreparedContainer { mut m, guides, paint, .. } = prepare_container(doc, n)?;
|
||||
if paint {
|
||||
let shapes = member_shapes(doc, &m);
|
||||
let bounds = m.geometric_bounds();
|
||||
// A clip group whose clipping type paints strokes is now a group of a clip group and those
|
||||
// strokes ([`crate::reshape::paint_type_clip`]): its own fills and strokes paint inside
|
||||
// that clip group. Such groups among the members are measured as their clip groups.
|
||||
let wrapped = n.clips() && crate::reshape::painted_clip_inner(&m).is_some();
|
||||
let (shapes, bounds) = (member_shapes(doc, &m), crate::reshape::clip_bounds(&m));
|
||||
let art =
|
||||
|items: &[AppearanceItem]| -> Vec<Arc<Node>> { items.iter().filter_map(|i| item_art(n.id, i, &shapes, bounds)).map(Arc::new).collect() };
|
||||
let (below, above) = m.appearance.split_contents();
|
||||
let (below, above) = (art(below), art(above));
|
||||
let at = usize::from(m.clips());
|
||||
if let Some(ch) = m.children_mut() {
|
||||
let at = usize::from(wrapped || m.clips());
|
||||
let target = if wrapped { m.children_mut().and_then(|ch| ch.first_mut()).map(Arc::make_mut) } else { Some(&mut m) };
|
||||
if let Some(ch) = target.and_then(Node::children_mut) {
|
||||
let at = at.min(ch.len());
|
||||
ch.splice(at..at, below);
|
||||
ch.extend(above);
|
||||
@@ -905,16 +949,8 @@ pub fn evaluate_container(doc: Option<&Document>, n: &Node) -> Option<Node> {
|
||||
Some(m)
|
||||
}
|
||||
|
||||
/// `n`, a group or layer whose own effects split at `t` ([`crate::reshape::copied_container_raster_at`]),
|
||||
/// as plain art: the effects before the Transform effect at `t` evaluated on its members as one
|
||||
/// piece ([`evaluate_container`]), with the raster effects among them, and that piece copied by the
|
||||
/// Transform effect, each copy a group of its own carrying those raster effects moved, turned,
|
||||
/// reflected and scaled with it ([`crate::reshape::copied_container_art`]). The art keeps the kind,
|
||||
/// transparency and opacity mask of `n` and the raster effects from `t` on, which paint once around
|
||||
/// all the copies; a clip group's or clipping layer's copies each clip, and the art itself does not.
|
||||
/// Its ruler guides, those in its sublayers and groups included, go once above the copies, hidden
|
||||
/// and locked as their containers were.
|
||||
fn copied_container(doc: Option<&Document>, n: &Node, t: usize) -> Node {
|
||||
/// The exact pre-copy source shared by rendering and stored gradient placement.
|
||||
fn copied_container_source(doc: Option<&Document>, n: &Node, t: usize) -> (Node, Vec<Arc<Node>>, Node) {
|
||||
let mut m = n.clone();
|
||||
let mut guides = vec![];
|
||||
take_sublayer_guides(&mut m, &mut guides, &Node::is_ruler_guide);
|
||||
@@ -929,6 +965,20 @@ fn copied_container(doc: Option<&Document>, n: &Node, t: usize) -> Node {
|
||||
let _later = crate::raster::LaterGroups::enter(&n.appearance.effects);
|
||||
members_as_drawn(doc, &mut source);
|
||||
}
|
||||
(m, guides, source)
|
||||
}
|
||||
|
||||
/// `n`, a group or layer whose own effects split at `t` ([`crate::reshape::copied_container_raster_at`]),
|
||||
/// as plain art: the effects before the Transform effect at `t` evaluated on its members as one
|
||||
/// piece ([`evaluate_container`]), with the raster effects among them, and that piece copied by the
|
||||
/// Transform effect, each copy a group of its own carrying those raster effects moved, turned,
|
||||
/// reflected and scaled with it ([`crate::reshape::copied_container_art`]). The art keeps the kind,
|
||||
/// transparency and opacity mask of `n` and the raster effects from `t` on, which paint once around
|
||||
/// all the copies; a clip group's or clipping layer's copies each clip, and the art itself does not.
|
||||
/// Its ruler guides, those in its sublayers and groups included, go once above the copies, hidden
|
||||
/// and locked as their containers were.
|
||||
fn copied_container(doc: Option<&Document>, n: &Node, t: usize) -> Node {
|
||||
let (mut m, guides, source) = copied_container_source(doc, n, t);
|
||||
let mut piece = evaluate_container(doc, &source).unwrap_or_else(|| {
|
||||
let mut p = source.clone();
|
||||
p.appearance.effects = crate::raster::without_geometry(&p.appearance.effects);
|
||||
@@ -962,6 +1012,36 @@ fn copied_container(doc: Option<&Document>, n: &Node, t: usize) -> Node {
|
||||
m
|
||||
}
|
||||
|
||||
/// Freeze representable fitted own paints to the box the container pass gives them, retaining
|
||||
/// every live effect and already explicit placement. Hidden-only containers the pass does not
|
||||
/// evaluate stay unchanged; this does not add a different fallback to `evaluate_container`.
|
||||
pub fn pinned_container_appearance(doc: &Document, n: &Node) -> Option<Appearance> {
|
||||
if !n.appearance.has_unplaced_gradient() {
|
||||
return None;
|
||||
}
|
||||
if let Some(t) = crate::reshape::copied_container_raster_at(n) {
|
||||
let (_, _, source) = copied_container_source(Some(doc), n, t);
|
||||
let pinned = pinned_container_appearance(doc, &source)?;
|
||||
let mut out = (*n.appearance).clone();
|
||||
out.items = pinned.items;
|
||||
return Some(out);
|
||||
}
|
||||
let PreparedContainer { m, carry, .. } = prepare_container(Some(doc), n)?;
|
||||
let bounds = m.geometric_bounds()?;
|
||||
let mut out = (*n.appearance).clone();
|
||||
let mut changed = false;
|
||||
for (item, original) in out.items.iter_mut().zip(&n.appearance.items) {
|
||||
if paints(original)
|
||||
&& matches!(original.paint(), Paint::Gradient(g) if !g.is_placed())
|
||||
&& let Some(pinned) = crate::pinned_gradient_item(original, bounds, &[&carry])
|
||||
{
|
||||
*item = pinned;
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
changed.then_some(out)
|
||||
}
|
||||
|
||||
/// Replace each visible member of `n` with geometry or Pathfinder effects of its own, at every
|
||||
/// depth of its groups and layers, by the art it draws ([`evaluate_container`],
|
||||
/// [`crate::reshape::own_effects_art`]), so the geometry effects of `n` reshape what its members
|
||||
|
||||
@@ -45,6 +45,7 @@ mod lighting_presets;
|
||||
mod live;
|
||||
mod marks;
|
||||
pub mod pixel;
|
||||
mod placement;
|
||||
pub mod preview;
|
||||
mod raster;
|
||||
mod reshape;
|
||||
@@ -75,12 +76,13 @@ pub use bake::{
|
||||
pub use clip::{WarpSeams, clip_outline, knockout_silhouette, reshaped_clip_outline, warp_pieces_translucent};
|
||||
pub use group::{
|
||||
OutlineHook, PATHFINDER_EFFECTS, compound_shape_area, compound_shape_art, evaluate_container, has_container_appearance, has_pathfinder,
|
||||
is_pathfinder, member_leaves, member_shapes, paints, pathfinder_children, shape_art,
|
||||
is_pathfinder, member_leaves, member_shapes, paints, pathfinder_children, pinned_container_appearance, shape_art,
|
||||
};
|
||||
pub use lighting_presets::{LIGHTING_PRESETS, LightingPreset, lighting_preset_params, matching_lighting_preset};
|
||||
pub use live::{expand_live, expand_live_deep, expanded_live_group, outline_object, text_outliner};
|
||||
pub use marks::{CROP_MARKS, crop_marks_art, has_crop_marks};
|
||||
pub use pixel::{PIXEL_EFFECTS, PixelFx, PixelSpace};
|
||||
pub use placement::pinned_gradient_item;
|
||||
pub use raster::{
|
||||
RASTERIZE, RasterFx, Rasterize, color_param, follow_items, item_effects_in, outset, raster_effects, rasterize_stage, stage_maps, staged_effects,
|
||||
without_geometry,
|
||||
@@ -103,8 +105,8 @@ pub use solids::{
|
||||
validate_three_d_params, view_options, with_graphic,
|
||||
};
|
||||
pub use solids::{
|
||||
GRAPHIC_MAX_OFFSET, GRAPHIC_SCALE_RANGE, GRAPHICS_NOT_TAKEN, appearance_graphic_symbols, exports_three_d, graphic_frame_at,
|
||||
graphics_reshaped_after, rename_appearance_graphic_symbol,
|
||||
GRAPHIC_MAX_OFFSET, GRAPHIC_SCALE_RANGE, GRAPHICS_NOT_TAKEN, appearance_graphic_symbols, exports_three_d, graphic_fitting_scale,
|
||||
graphic_frame_at, graphic_side_size, graphics_reshaped_after, rename_appearance_graphic_symbol,
|
||||
};
|
||||
pub use stylize::{ScribbleSetting, scribble_setting_id, scribble_settings};
|
||||
pub use svg_filter::SVG_FILTER;
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
//! Conservative stored placements for gradients fitted by the existing effects passes.
|
||||
|
||||
use vectorcraft_doc::color::{GradientKind, GradientPaint, Paint};
|
||||
use vectorcraft_doc::{Appearance, AppearanceItem};
|
||||
use vectorcraft_geom::Rect;
|
||||
|
||||
use crate::Carry;
|
||||
|
||||
/// Freeze one fitted gradient at the evaluated row's geometric bounds, before its live effects.
|
||||
/// `carries` are the actual object and item passes, in rendering order. Only missing placement
|
||||
/// fields are returned; explicit coordinates and the row's other data stay unchanged. A map or
|
||||
/// model that cannot reproduce the original resolved row returns `None`, leaving it fitted.
|
||||
pub fn pinned_gradient_item(item: &AppearanceItem, bounds: Rect, carries: &[&Carry]) -> Option<AppearanceItem> {
|
||||
if gradient(item)?.is_placed() {
|
||||
return Some(item.clone());
|
||||
}
|
||||
if ![bounds.x0, bounds.y0, bounds.x1, bounds.y1].iter().all(|v| v.is_finite()) {
|
||||
return None;
|
||||
}
|
||||
let resolved = resolve(item, bounds, carries);
|
||||
if !finite_placement(resolved.items.first()?) {
|
||||
return None;
|
||||
}
|
||||
let mut stored = resolved.clone();
|
||||
for carry in carries.iter().rev() {
|
||||
carry.unapply_placed(&mut stored)?;
|
||||
}
|
||||
if !finite_placement(stored.items.first()?) {
|
||||
return None;
|
||||
}
|
||||
let candidate = missing_placement(item, stored.items.first()?)?;
|
||||
let replayed = resolve(&candidate, bounds, carries);
|
||||
(finite_placement(replayed.items.first()?) && replayed.approx_eq(&resolved)).then_some(candidate)
|
||||
}
|
||||
|
||||
fn gradient(item: &AppearanceItem) -> Option<&GradientPaint> {
|
||||
match item.paint() {
|
||||
Paint::Gradient(g) => Some(g),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn resolve(item: &AppearanceItem, bounds: Rect, carries: &[&Carry]) -> Appearance {
|
||||
let mut ap = Appearance { items: vec![item.clone()], ..Default::default() };
|
||||
for carry in carries {
|
||||
carry.apply(&mut ap);
|
||||
}
|
||||
ap.pin_gradients(bounds);
|
||||
ap
|
||||
}
|
||||
|
||||
fn missing_placement(item: &AppearanceItem, placed: &AppearanceItem) -> Option<AppearanceItem> {
|
||||
let original = gradient(item)?;
|
||||
let placed = gradient(placed)?;
|
||||
let mut out = item.clone();
|
||||
let Paint::Gradient(g) = out.paint_mut() else { return None };
|
||||
if original.geom.is_none() {
|
||||
g.geom = placed.geom;
|
||||
}
|
||||
if original.gradient.kind == GradientKind::Freeform && !original.has_freeform_points() {
|
||||
let freeform = placed.freeform.as_ref()?;
|
||||
match &mut g.freeform {
|
||||
Some(f) => f.points.clone_from(&freeform.points),
|
||||
None => g.freeform = Some(freeform.clone()),
|
||||
}
|
||||
}
|
||||
Some(out)
|
||||
}
|
||||
|
||||
fn finite_placement(item: &AppearanceItem) -> bool {
|
||||
let Some(g) = gradient(item) else { return false };
|
||||
g.geom.is_none_or(|v| v.start.is_finite() && v.end.is_finite() && v.aspect.is_finite() && v.focal.is_none_or(|p| p.is_finite()))
|
||||
&& g.freeform.as_ref().is_none_or(|f| f.points.iter().all(|p| p.at.is_finite()))
|
||||
}
|
||||
+195
-45
@@ -387,7 +387,7 @@ fn row_effects_of(fx: &[Effect]) -> Vec<Effect> {
|
||||
/// of a symbol whose art (in `doc`) holds an instance of `n`'s symbol, at any depth, keeps its
|
||||
/// appearance, so the effects never pass round a symbol that holds itself. Without `doc`, no
|
||||
/// instance in the art takes them.
|
||||
fn add_instance_row_effects(doc: Option<&Document>, n: &Node, art: &mut Node) {
|
||||
pub(crate) fn add_instance_row_effects(doc: Option<&Document>, n: &Node, art: &mut Node) {
|
||||
let NodeKind::SymbolInstance { symbol, .. } = &n.kind else { return };
|
||||
let fill = active_fill(n).map_or(vec![], |f| row_effects_of(&f.effects));
|
||||
let stroke = active_stroke(n).map_or(vec![], |s| row_effects_of(&s.effects));
|
||||
@@ -613,32 +613,101 @@ fn traced_opaque_area(bytes: &[u8]) -> Traced {
|
||||
/// rule and the fill or stroke that paints it: the paths (or compound paths) that [`reshape`]
|
||||
/// makes along its frame or, for those whose first effect is Outline Object, along the outline of
|
||||
/// its opaque area ([`opaque_area`]), with each fill's or stroke's geometry effects applied as the
|
||||
/// renderer applies them. Empty for anything but an image with such fills or strokes. The swatches
|
||||
/// and patterns that live-effect plug-ins painting their pieces name are looked up in `doc`, and
|
||||
/// the image's pixels in `doc` when the image does not hold them.
|
||||
/// renderer applies them. For a symbol instance whose active fill or stroke has a visible geometry
|
||||
/// effect ([`has_item_geometry`]), the shapes that the fills and strokes of the art it draws paint
|
||||
/// ([`instance_paint`]). Empty for anything else. The swatches and patterns that live-effect
|
||||
/// plug-ins painting their pieces name are looked up in `doc`, and the image's pixels in `doc` when
|
||||
/// the image does not hold them.
|
||||
pub fn image_paint(doc: Option<&Document>, n: &Node) -> Vec<(BezPath, FillRule, AppearanceItem)> {
|
||||
if !matches!(n.kind, NodeKind::Image(_)) || !has_item_geometry(n) {
|
||||
return vec![];
|
||||
}
|
||||
let Some(art) = reshape(doc, n, None) else { return vec![] };
|
||||
let mut out = vec![];
|
||||
art.walk(&mut |c| {
|
||||
let (NodeKind::Path { rule, .. } | NodeKind::Compound { rule, .. }) = &c.kind else { return };
|
||||
let Some(g) = c.stroke_path() else { return };
|
||||
let ctx = GeomContext { doc, ..GeomContext::of(c) };
|
||||
for item in c.appearance.items.iter().filter(|i| crate::paints(i)) {
|
||||
let fx = item.effects();
|
||||
let shape = if crate::has_geometry(fx) && !g.elements().is_empty() {
|
||||
crate::apply_geometry_bez(fx, &g, g.bounding_box(), &ctx.item(item))
|
||||
} else {
|
||||
g.clone()
|
||||
};
|
||||
out.push((shape, *rule, item.clone()));
|
||||
}
|
||||
});
|
||||
if matches!(n.kind, NodeKind::SymbolInstance { .. }) {
|
||||
let mut budget = SYMBOL_ART_MAX_NODES;
|
||||
instance_paint(doc, n, 1, &mut budget, &mut out);
|
||||
return out;
|
||||
}
|
||||
if !matches!(n.kind, NodeKind::Image(_)) || !has_item_geometry(n) {
|
||||
return out;
|
||||
}
|
||||
let Some(art) = reshape(doc, n, None) else { return out };
|
||||
art.walk(&mut |c| push_painted(doc, c, &mut out));
|
||||
out
|
||||
}
|
||||
|
||||
/// The shapes that the fills and strokes of path or compound path `c` paint, each with the
|
||||
/// geometry effects of that fill or stroke applied ([`image_paint`]); nothing for other objects.
|
||||
fn push_painted(doc: Option<&Document>, c: &Node, out: &mut Vec<(BezPath, FillRule, AppearanceItem)>) {
|
||||
let (NodeKind::Path { rule, .. } | NodeKind::Compound { rule, .. }) = &c.kind else { return };
|
||||
let Some(g) = c.stroke_path() else { return };
|
||||
let ctx = GeomContext { doc, ..GeomContext::of(c) };
|
||||
for item in c.appearance.items.iter().filter(|i| crate::paints(i)) {
|
||||
let fx = item.effects();
|
||||
let shape = if crate::has_geometry(fx) && !g.elements().is_empty() {
|
||||
crate::apply_geometry_bez(fx, &g, g.bounding_box(), &ctx.item(item))
|
||||
} else {
|
||||
g.clone()
|
||||
};
|
||||
out.push((shape, *rule, item.clone()));
|
||||
}
|
||||
}
|
||||
|
||||
/// The shapes that symbol instance `n`, `depth` instances deep, paints with the geometry effects of
|
||||
/// its active fill and stroke ([`has_item_geometry`]): the paths of the art [`reshape`] makes of it,
|
||||
/// each with its own geometry effects and those of each fill and stroke applied
|
||||
/// ([`crate::bake_type_appearance`], [`push_painted`]), the paths that the own fills and strokes of
|
||||
/// the groups and layers in the art paint and the results of their Pathfinder effects
|
||||
/// ([`crate::evaluate_container`]), the shapes that the own fills and strokes of the images in the
|
||||
/// art paint ([`image_paint`]), and the instances in that art that took those effects, in turn.
|
||||
/// Hidden objects, clipping paths, guides, the members of clip groups and the original shapes of
|
||||
/// Shaper groups add nothing, and neither does an instance more than
|
||||
/// [`vectorcraft_doc::depth::MAX_DEPTH`] deep or whose symbol's art would take the objects measured
|
||||
/// so far past `budget`.
|
||||
fn instance_paint(doc: Option<&Document>, n: &Node, depth: usize, budget: &mut u64, out: &mut Vec<(BezPath, FillRule, AppearanceItem)>) {
|
||||
let NodeKind::SymbolInstance { symbol, .. } = &n.kind else { return };
|
||||
if depth >= vectorcraft_doc::depth::MAX_DEPTH || !has_item_geometry(n) {
|
||||
return;
|
||||
}
|
||||
let Some(sym) = doc.and_then(|d| d.symbols.iter().find(|s| s.name == *symbol)) else { return };
|
||||
let count = sym.art.count() as u64;
|
||||
if count > *budget {
|
||||
return;
|
||||
}
|
||||
*budget -= count;
|
||||
let Some(art) = reshape(doc, n, Some(&vectorcraft_doc::symbol_overrides::dynamic_art(&sym.art, n))) else { return };
|
||||
painted_in(doc, &art, depth, budget, out);
|
||||
}
|
||||
|
||||
/// [`instance_paint`] of the objects in `n`, art of an instance `depth` instances deep.
|
||||
fn painted_in(doc: Option<&Document>, n: &Node, depth: usize, budget: &mut u64, out: &mut Vec<(BezPath, FillRule, AppearanceItem)>) {
|
||||
if !n.visible {
|
||||
return;
|
||||
}
|
||||
match &n.kind {
|
||||
NodeKind::Path { clipping: false, guide: false, .. } | NodeKind::Compound { .. } => match crate::bake_type_appearance(doc, n) {
|
||||
// One path for each fill and stroke, its effects applied.
|
||||
Some(pieces) => painted_in(doc, &pieces, depth, budget, out),
|
||||
None => push_painted(doc, n, out),
|
||||
},
|
||||
NodeKind::Path { .. } => {}
|
||||
NodeKind::Image(_) => out.extend(image_paint(doc, n)),
|
||||
NodeKind::SymbolInstance { .. } => instance_paint(doc, n, depth + 1, budget, out),
|
||||
_ if n.clips() => {}
|
||||
_ => {
|
||||
// A Pathfinder effect paints its result, not the members it combines.
|
||||
let evaluated = (crate::has_container_appearance(n) || crate::has_pathfinder(n)).then(|| crate::evaluate_container(doc, n)).flatten();
|
||||
let g = evaluated.as_ref().unwrap_or(n);
|
||||
if g.clips() {
|
||||
return;
|
||||
}
|
||||
// A Shaper group's first member holds its original shapes, which are not drawn. The
|
||||
// group's own fills and strokes can be painted before it, so it is found by its id.
|
||||
let sources = n.extras().shaper.is_some().then(|| n.children().and_then(|c| c.first()).map(|c| c.id)).flatten();
|
||||
for c in g.children().into_iter().flatten().filter(|c| Some(c.id) != sources) {
|
||||
painted_in(doc, c, depth, budget, out);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The glyph outlines of type `t` in text space with its underline and strikethrough bars: one
|
||||
/// path per run, and all of them as one.
|
||||
pub(crate) fn glyph_outlines(t: &vectorcraft_doc::TextObject) -> (Vec<kurbo::BezPath>, kurbo::BezPath) {
|
||||
@@ -954,6 +1023,74 @@ pub(crate) fn clipping_text_outline(t: &Node) -> Option<Node> {
|
||||
Some(Node { visible: t.visible, ..o })
|
||||
}
|
||||
|
||||
/// Clipping path `clip` of a clip group as a clipping path of the region it clips to
|
||||
/// ([`crate::clip_outline`]), with its id, name and visibility. For type that paints, the geometry
|
||||
/// effects of its fills and strokes reshape what they paint and leave that region as it is.
|
||||
/// `None` when it has nothing to clip by.
|
||||
pub(crate) fn clip_region_path(clip: &Node) -> Option<Node> {
|
||||
let (bp, rule) = crate::clip_outline(clip)?;
|
||||
let mut p = Node::path(clip.id, PathData::from_bezpath(&bp), Appearance::default());
|
||||
if let NodeKind::Path { rule: r, clipping, .. } = &mut p.kind {
|
||||
(*r, *clipping) = (rule, true);
|
||||
}
|
||||
p.name = clip.name.clone();
|
||||
p.visible = clip.visible;
|
||||
Some(p)
|
||||
}
|
||||
|
||||
/// Knockout Group for clip group `m` turned into a group around `inner`, a clip group of its
|
||||
/// members, and its clipping path's strokes: `inner` takes `m`'s setting, so the clipped art knocks
|
||||
/// out as before, and `m` is set Off so the strokes paint over it, as the renderer draws them. A
|
||||
/// neutral `m` stays neutral, so both take the setting of the groups around them.
|
||||
pub(crate) fn knockout_inside(m: &mut Node, inner: &mut Node) {
|
||||
inner.knockout = m.knockout;
|
||||
if m.knockout != vectorcraft_doc::Knockout::Neutral {
|
||||
m.knockout = vectorcraft_doc::Knockout::Off;
|
||||
}
|
||||
}
|
||||
|
||||
/// The clip group in `n` when `n` is a group or layer that [`paint_type_clip`] made of a clip
|
||||
/// group and its clipping type's strokes: a group that does not clip whose first member is a clip
|
||||
/// group with `n`'s id and whose second member has the id of that clip group's clipping path. The
|
||||
/// clip group's region is what `n` stands for, as the clip group it was made from: the strokes
|
||||
/// paint outside it and add nothing to its outline ([`crate::member_shapes`]) or its bounds
|
||||
/// ([`clip_bounds`]).
|
||||
pub(crate) fn painted_clip_inner(n: &Node) -> Option<&Node> {
|
||||
if n.clips() || !matches!(n.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }) {
|
||||
return None;
|
||||
}
|
||||
let [inner, stroke, ..] = n.children()?.as_slice() else { return None };
|
||||
let clip = inner.children()?.first()?;
|
||||
(inner.clips() && inner.id == n.id && stroke.id == clip.id && !stroke.clips()).then_some(&**inner)
|
||||
}
|
||||
|
||||
/// The geometric bounds of `n` ([`Node::geometric_bounds`]) with each group or layer in it that
|
||||
/// [`painted_clip_inner`] finds measured as its clip group, so the strokes of a clipping type
|
||||
/// outside the clip do not widen them.
|
||||
pub(crate) fn clip_bounds(n: &Node) -> Option<Rect> {
|
||||
fn holds(n: &Node) -> bool {
|
||||
painted_clip_inner(n).is_some() || n.children().into_iter().flatten().any(|c| holds(c))
|
||||
}
|
||||
fn unwrap(n: &mut Node) {
|
||||
if let Some(inner) = painted_clip_inner(n) {
|
||||
let mut inner = inner.clone();
|
||||
inner.visible = n.visible;
|
||||
*n = inner;
|
||||
}
|
||||
for c in n.children_mut().into_iter().flatten() {
|
||||
if holds(c) {
|
||||
unwrap(Arc::make_mut(c));
|
||||
}
|
||||
}
|
||||
}
|
||||
if !holds(n) {
|
||||
return n.geometric_bounds();
|
||||
}
|
||||
let mut probe = n.clone();
|
||||
unwrap(&mut probe);
|
||||
probe.geometric_bounds()
|
||||
}
|
||||
|
||||
/// Replace type anywhere inside `n` by its outlines, as art that keeps the type's look
|
||||
/// ([`as_art`]). Type in a clip group's clipping path (all of `n` when `clipping` is set) becomes
|
||||
/// its outlines with its visibility and effects ([`clipping_text_outline`]), and its fills and
|
||||
@@ -981,32 +1118,41 @@ pub(crate) fn outline_nested_text(doc: Option<&Document>, n: &mut Node, clipping
|
||||
}
|
||||
|
||||
/// When `n` is a clip group or clipping layer whose clipping path is type that paints
|
||||
/// ([`Node::clip_paint`]), make it the art the canvas draws for it: the type's outlines clip
|
||||
/// ([`clipping_text_outline`]), its fills as art ([`as_art`]) paint behind the clipped art inside
|
||||
/// the clip, and its strokes as art paint over it, outside the clip, in a group that `n` becomes
|
||||
/// (keeping its id, name and transparency) with the clip group inside. The other members stay as
|
||||
/// they are. Hidden type paints nothing.
|
||||
/// ([`Node::clip_paint`]), make it the art the canvas draws for it: a path of the region the type
|
||||
/// clips to clips ([`clip_region_path`]), its fills as art ([`as_art`]) paint behind the clipped
|
||||
/// art inside the clip, and its strokes as art paint over it, outside the clip. Each part is the
|
||||
/// type's art with only those fills or strokes, their own geometry effects applied. With strokes,
|
||||
/// `n` becomes a group (keeping its id, name, visibility and transparency) that holds a clip group
|
||||
/// of the clipping path, the fills and the other members, with `n`'s id, then the strokes; a
|
||||
/// clipping layer keeps its ruler guides last. [`knockout_inside`] sets the Knockout Group of both,
|
||||
/// and [`painted_clip_inner`] finds that clip group. The other members stay as they are. Hidden
|
||||
/// type paints nothing.
|
||||
pub(crate) fn paint_type_clip(doc: Option<&Document>, n: &mut Node) {
|
||||
let Some((first, rest)) = n.children().and_then(|ch| ch.split_first()) else { return };
|
||||
if !n.clips() || !matches!(first.kind, NodeKind::Text(_)) || !first.visible {
|
||||
let Some(first) = n.children().and_then(|ch| ch.first()).filter(|_| n.clips()) else { return };
|
||||
if !matches!(first.kind, NodeKind::Text(_)) || !first.visible {
|
||||
return;
|
||||
}
|
||||
let paint = first.clip_paint();
|
||||
if paint.fill.is_none() && paint.stroke.is_none() {
|
||||
return;
|
||||
}
|
||||
let Some(clip) = clipping_text_outline(first) else { return };
|
||||
let Some(clip) = clip_region_path(first) else { return };
|
||||
let art = |part: Option<Node>| part.and_then(|p| as_art(doc, &p, None)).map(Arc::new);
|
||||
let members: Vec<Arc<Node>> = std::iter::once(Arc::new(clip)).chain(art(paint.fill)).chain(rest.iter().cloned()).collect();
|
||||
let stroke = art(paint.stroke);
|
||||
let (fill, stroke) = (art(paint.fill), art(paint.stroke));
|
||||
let id = n.id;
|
||||
match (&mut n.kind, stroke) {
|
||||
(NodeKind::Group { children, .. } | NodeKind::Layer { children, .. }, None) => *children = members,
|
||||
(NodeKind::Group { children, clip } | NodeKind::Layer { children, clip, .. }, Some(stroke)) => {
|
||||
*children = vec![Arc::new(Node::new(id, NodeKind::Group { children: members, clip: true })), stroke];
|
||||
*clip = false;
|
||||
}
|
||||
_ => {}
|
||||
let Some(ch) = n.children_mut() else { return };
|
||||
let Some(slot) = ch.first_mut() else { return };
|
||||
*slot = Arc::new(clip);
|
||||
if let Some(fill) = fill {
|
||||
ch.insert(1, fill);
|
||||
}
|
||||
let Some(stroke) = stroke else { return };
|
||||
let guides = ch.split_off(Node::guide_run_start(ch));
|
||||
let mut inner = Node::new(id, NodeKind::Group { children: std::mem::take(ch), clip: true });
|
||||
knockout_inside(n, &mut inner);
|
||||
if let NodeKind::Group { children, clip } | NodeKind::Layer { children, clip, .. } = &mut n.kind {
|
||||
*children = [Arc::new(inner), stroke].into_iter().chain(guides).collect();
|
||||
*clip = false;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1822,7 +1968,7 @@ impl Step<'_> {
|
||||
if !groups.is_empty() {
|
||||
carry_groups(art, groups, after, &|from, to| crate::Carry::of(&e.id, params, bounds, from, to, seed));
|
||||
}
|
||||
let drawn = warped.as_deref().map_or_else(|| art.geometric_bounds(), |w| w.bounds(art));
|
||||
let drawn = warped.as_deref().map_or_else(|| clip_bounds(art), |w| w.bounds(art));
|
||||
let whole = (follows && !held).then(|| crate::Carry::of(&e.id, params, bounds, Some(bounds), drawn, seed));
|
||||
Ran { kept: !kept_ids.is_empty(), took, masks, short, whole }
|
||||
}
|
||||
@@ -3247,6 +3393,9 @@ fn group_marks(
|
||||
NodeKind::Image(_) => (images.map_or_else(|| n.geometric_bounds(), |w| w.image_bounds(n)), false),
|
||||
NodeKind::Group { children, clip } | NodeKind::Layer { children, clip, .. } if !n.extras().type_outlines => {
|
||||
let layer = matches!(n.kind, NodeKind::Layer { .. });
|
||||
// A clip group whose clipping type's strokes paint around it is measured as that clip
|
||||
// group: the strokes outside the clip do not widen it ([`clip_bounds`]).
|
||||
let clip = *clip || painted_clip_inner(n).is_some();
|
||||
let skip = children.len().saturating_sub(n.editing_children().len());
|
||||
let (mut bounds, mut held) = (None, false);
|
||||
for (i, c) in children.iter().enumerate() {
|
||||
@@ -3257,7 +3406,7 @@ fn group_marks(
|
||||
}
|
||||
at.pop();
|
||||
// Only members measured in the bounds hold the group's gradients in place.
|
||||
let counts = if *clip { i == 0 } else { i >= skip && (c.visible || !layer) };
|
||||
let counts = if clip { i == 0 } else { i >= skip && (c.visible || !layer) };
|
||||
if counts {
|
||||
bounds = vectorcraft_geom::union_opt(bounds, b);
|
||||
held |= h;
|
||||
@@ -3356,7 +3505,7 @@ pub(crate) fn follow_boxes(ap: &mut Appearance, from: Rect, to: Rect) {
|
||||
|
||||
/// The map that takes box `from` onto box `to` along each axis (along an axis `from` has no extent
|
||||
/// on, a move from its center to `to`'s).
|
||||
fn box_map(from: Rect, to: Rect) -> vectorcraft_geom::Affine {
|
||||
pub(crate) fn box_map(from: Rect, to: Rect) -> vectorcraft_geom::Affine {
|
||||
let axis = |a0: f64, a1: f64, b0: f64, b1: f64| {
|
||||
if (a1 - a0).abs() > 1e-12 {
|
||||
let s = (b1 - b0) / (a1 - a0);
|
||||
@@ -3473,16 +3622,17 @@ impl WarpedImages {
|
||||
|
||||
/// The geometric bounds of `art` as it draws after the effects so far: each image this table
|
||||
/// lists measured by the pieces the warps and moves it took would cut it into, when the art
|
||||
/// has room for them ([`cut_warped_images`]).
|
||||
/// has room for them ([`cut_warped_images`]). The strokes of clipping type outside its clip
|
||||
/// are left out ([`clip_bounds`]).
|
||||
pub(crate) fn bounds(&self, art: &Node) -> Option<Rect> {
|
||||
if self.images.is_empty() || !self.fits(art, crate::distort::MAX_COPY_OBJECTS) {
|
||||
return art.geometric_bounds();
|
||||
return clip_bounds(art);
|
||||
}
|
||||
// The pieces the images would be cut into now: each group of pieces is shown or hidden as
|
||||
// its image is, and hidden objects are left out of a layer's bounds.
|
||||
let mut probe = art.clone();
|
||||
restore_warped_images(&mut probe, self, true);
|
||||
probe.geometric_bounds()
|
||||
clip_bounds(&probe)
|
||||
}
|
||||
|
||||
/// The geometric bounds of image `n`: when this table lists it, measured by the pieces the
|
||||
|
||||
@@ -6,7 +6,7 @@ use serde_json::Value;
|
||||
use vectorcraft_doc::color::{Color, Paint};
|
||||
use vectorcraft_doc::{Appearance, AppearanceItem, Document, Effect, FillLayer, Node, NodeId, NodeKind};
|
||||
use vectorcraft_geom::{FillRule, PathData, PathEl, Point, Rect, Vec2};
|
||||
use vectorcraft_three_d::{Edge, Revolve, SolidFaces};
|
||||
use vectorcraft_three_d::{Edge, PlanarFace, Revolve, SolidFaces};
|
||||
|
||||
use crate::solids::wireframe::{WireFace, wireframe_params};
|
||||
use crate::solids::{
|
||||
@@ -168,7 +168,7 @@ pub(crate) fn validate_in(doc: Option<&Document>, n: &Node, id: &str, p: &Value)
|
||||
// With no member to carry them, the graphics' art must still fit its limits.
|
||||
None => {
|
||||
crate::solids::graphics::validate_symbols(doc, p)?;
|
||||
crate::solids::graphics::validate_surface_symbols(doc, p)?;
|
||||
crate::solids::graphics::validate_surface_symbols(doc, p, PlanarFace::Front)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -201,10 +201,10 @@ fn check_graphics(doc: Option<&Document>, id: &str, path: &PathData, b: Rect, op
|
||||
let graphics = crate::solids::mapped_graphics(p);
|
||||
let Some(doc) = doc.filter(|_| id == REVOLVE && !graphics.is_empty()) else { return Ok(()) };
|
||||
crate::solids::graphics::validate_symbols(doc, p)?;
|
||||
crate::solids::graphics::validate_surface_symbols(doc, p)?;
|
||||
crate::solids::graphics::validate_surface_symbols(doc, p, PlanarFace::Front)?;
|
||||
let faces = vectorcraft_three_d::revolve(path, b, options)?;
|
||||
let mut used = *copies;
|
||||
match crate::solids::graphics::surface_parts(Some(doc), NodeId(0), &graphics, &faces, &|_, c| Paint::solid(c), &mut used) {
|
||||
match crate::solids::graphics::surface_parts(Some(doc), NodeId(0), (&graphics, PlanarFace::Front), &faces, &|_, c| Paint::solid(c), &mut used) {
|
||||
Some(_) => {
|
||||
*copies = used;
|
||||
Ok(())
|
||||
@@ -523,7 +523,7 @@ fn surface(
|
||||
let mut parts = if graphics.is_empty() {
|
||||
vec![]
|
||||
} else {
|
||||
match crate::solids::graphics::surface_parts(doc, n.id, &graphics, &faces, &shade, &mut used) {
|
||||
match crate::solids::graphics::surface_parts(doc, n.id, (&graphics, PlanarFace::Front), &faces, &shade, &mut used) {
|
||||
Some(parts) => {
|
||||
copies.graphics = used;
|
||||
parts
|
||||
|
||||
@@ -520,7 +520,8 @@ fn the_copies_of_a_graphics_paint_have_a_budget_of_their_own() {
|
||||
let faces = vectorcraft_three_d::revolve(path, path.bounds().unwrap(), options_of(REVOLVE, &p)).unwrap();
|
||||
let parts_of = |symbol: &str, copies: &mut usize| {
|
||||
let graphics = crate::solids::mapped_graphics(&json!({"graphics": [{"symbol": symbol}]}));
|
||||
crate::solids::graphics::surface_parts(Some(&d), NodeId(0), &graphics, &faces, &|_, c| Paint::solid(c), copies).map(|p| p.concat().len())
|
||||
crate::solids::graphics::surface_parts(Some(&d), NodeId(0), (&graphics, PlanarFace::Front), &faces, &|_, c| Paint::solid(c), copies)
|
||||
.map(|p| p.concat().len())
|
||||
};
|
||||
// Each opaque part copies the paint into its fill and its seam stroke; a part with
|
||||
// transparent stops takes no seam stroke and copies it once.
|
||||
|
||||
+181
-17
@@ -30,7 +30,7 @@ pub use graphics::{
|
||||
};
|
||||
pub use graphics::{
|
||||
MAX_OFFSET as GRAPHIC_MAX_OFFSET, NOT_TAKEN as GRAPHICS_NOT_TAKEN, SCALE_RANGE as GRAPHIC_SCALE_RANGE, appearance_graphic_symbols,
|
||||
rename_appearance_graphic_symbol,
|
||||
fitting as graphic_fitting_scale, rename_appearance_graphic_symbol,
|
||||
};
|
||||
|
||||
pub(crate) mod shadow;
|
||||
@@ -84,11 +84,14 @@ pub fn three_d_params_as(from: &str, params: &Value, to: &str) -> Value {
|
||||
}
|
||||
}
|
||||
// A plane has only a front, and Revolve's graphics go on its side, named the front, so graphics
|
||||
// on the back cap are dropped.
|
||||
// on the back cap and on Extrude & Bevel's side are dropped.
|
||||
if (to == ROTATE || to == crate::REVOLVE)
|
||||
&& let Some(Value::Array(list)) = out.get_mut(GRAPHICS)
|
||||
{
|
||||
list.retain(|g| g.get("face").and_then(Value::as_str) != Some(PlanarFace::Back.id()));
|
||||
list.retain(|g| {
|
||||
let face = g.get("face").and_then(Value::as_str);
|
||||
face != Some(PlanarFace::Back.id()) && face != Some(PlanarFace::Side.id())
|
||||
});
|
||||
}
|
||||
Value::Object(out)
|
||||
}
|
||||
@@ -177,6 +180,7 @@ pub fn extrude_options(p: &Value) -> Extrude {
|
||||
both_sides: flag(p, "bevelBothSides", false),
|
||||
}),
|
||||
hidden: false,
|
||||
map_surface: false,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -253,6 +257,56 @@ fn facets(id: &str, path: &PathData, rule: FillRule, bounds: Rect, p: &Value) ->
|
||||
}
|
||||
}
|
||||
|
||||
/// [`facets`] of Extrude & Bevel with parameters `p`, with the pieces of the side of its longest
|
||||
/// contour carrying where they lie on it unrolled ([`Facet::surface`]), for its side's graphics.
|
||||
fn side_facets(path: &PathData, rule: FillRule, bounds: Rect, p: &Value) -> Result<Vec<Facet>, String> {
|
||||
#[cfg(test)]
|
||||
SOLID_GEOMETRY_BUILT.with(|n| n.set(n.get() + 1));
|
||||
vectorcraft_three_d::extrude(path, rule, bounds, Extrude { map_surface: true, ..extrude_options(p) }, view_options(p))
|
||||
}
|
||||
|
||||
/// [`side_facets`], and with `cast` the faces the solid's shadow is cast from, from the same build
|
||||
/// ([`facets_and_faces`]).
|
||||
fn side_facets_and_faces(path: &PathData, rule: FillRule, bounds: Rect, p: &Value, cast: bool) -> Result<CastingSolid, String> {
|
||||
if !cast {
|
||||
return side_facets(path, rule, bounds, p).map(|f| (f, None));
|
||||
}
|
||||
#[cfg(test)]
|
||||
SOLID_GEOMETRY_BUILT.with(|n| n.set(n.get() + 1));
|
||||
let options = Extrude { map_surface: true, ..extrude_options(p) };
|
||||
vectorcraft_three_d::extrude_shadowed(path, rule, bounds, options, view_options(p)).map(|(f, faces)| (f, Some(faces)))
|
||||
}
|
||||
|
||||
/// The part of `parts` ([`solid_parts`]) whose solid takes the graphics on Extrude & Bevel's side,
|
||||
/// with parameters `p` and built about `bounds`: the first of those with the longest outline
|
||||
/// ([`vectorcraft_three_d::extrude_side_size`]). `None` when the effect `id` is not Extrude & Bevel
|
||||
/// or has no graphic on its side, or when no part has a side.
|
||||
fn side_carrier(id: &str, p: &Value, parts: &[Part<'_>], bounds: Rect) -> Option<usize> {
|
||||
if id != EXTRUDE || !mapped_graphics(p).iter().any(|g| g.face == PlanarFace::Side) {
|
||||
return None;
|
||||
}
|
||||
let options = extrude_options(p);
|
||||
parts
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(k, (_, _, area, rule, _, _))| vectorcraft_three_d::extrude_side_size(area, *rule, bounds, options).map(|(w, ..)| (k, w)))
|
||||
.fold(None, |best: Option<(usize, f64)>, (k, w)| if best.is_some_and(|(_, top)| top >= w) { best } else { Some((k, w)) })
|
||||
.map(|(k, _)| k)
|
||||
}
|
||||
|
||||
/// The size of Extrude & Bevel's side unrolled for the graphics on it: the side of the part of
|
||||
/// `shapes` that [`side_carrier`] picks, with parameters `p`, as wide as the part of it about x = 0
|
||||
/// that does not reach its cut and as tall as the length across its bevels and walls.
|
||||
fn side_size(p: &Value, shapes: &[Profile]) -> Option<(f64, f64)> {
|
||||
let (parts, bounds) = solid_parts(shapes, union_bounds(shapes)?);
|
||||
let options = extrude_options(p);
|
||||
parts
|
||||
.iter()
|
||||
.filter_map(|(_, _, area, rule, _, _)| vectorcraft_three_d::extrude_side_size(area, *rule, bounds, options))
|
||||
.fold(None, |best: Option<(f64, f64, f64)>, size| if best.is_some_and(|top| top.0 >= size.0) { best } else { Some(size) })
|
||||
.map(|(_, height, span)| (span, height))
|
||||
}
|
||||
|
||||
/// [`facets`], and with `cast` for Extrude & Bevel or Rotate the faces the solid's shadow is cast
|
||||
/// from, from the same build. Inflate's solids are built together ([`built_solids_cast`]), and the
|
||||
/// classic effects cast no shadow: they keep no faces.
|
||||
@@ -339,7 +393,8 @@ fn validate_solid_for(doc: Option<&Document>, n: &Node, id: &str, p: &Value, at:
|
||||
reshape_members(n, before, &mut shapes);
|
||||
let b = union_bounds(&shapes).ok_or_else(|| format!("{label} requires a group holding a shape with at least two anchors"))?;
|
||||
check_profiles(id, p, &shapes, b)?;
|
||||
return check_solids(id, p, &shapes);
|
||||
check_solids(id, p, &shapes)?;
|
||||
return check_side_graphics(doc, n, id, p, &shapes);
|
||||
}
|
||||
let (path, rule) = object_profile(n, label)?;
|
||||
let anchors = || format!("{label} requires a shape with at least two anchors");
|
||||
@@ -356,7 +411,8 @@ fn validate_solid_for(doc: Option<&Document>, n: &Node, id: &str, p: &Value, at:
|
||||
let b = path.bounds().ok_or_else(anchors)?;
|
||||
let shapes = [Profile { path, rule, items, opacity: 1.0, scopes: vec![] }];
|
||||
check_profiles(id, p, &shapes, b)?;
|
||||
check_solids(id, p, &shapes)
|
||||
check_solids(id, p, &shapes)?;
|
||||
check_side_graphics(doc, n, id, p, &shapes)
|
||||
}
|
||||
|
||||
/// Does 3D effect `id` with parameters `p` cast a shadow: is it Extrude & Bevel, Inflate or Rotate
|
||||
@@ -370,6 +426,30 @@ fn visible(item: &AppearanceItem, member: f32) -> bool {
|
||||
paint_of(item, member).1 > 0.0
|
||||
}
|
||||
|
||||
/// An error when the graphics on the side of Extrude & Bevel `id` with parameters `p`, with the
|
||||
/// symbols of `doc`, are past their limits on the side of the solid of `shapes` that takes them
|
||||
/// ([`side_carrier`]): their art, or the parts they draw on its pieces
|
||||
/// ([`graphics::surface_parts`]), or when the object `n`'s surfaces can't be built at all. They are
|
||||
/// built as the art builds them ([`surfaces_with`]), so its pieces are the ones the art draws, cuts
|
||||
/// included. Without `doc` nothing is drawn, and nothing is checked.
|
||||
fn check_side_graphics(doc: Option<&Document>, n: &Node, id: &str, p: &Value, shapes: &[Profile]) -> Result<(), String> {
|
||||
let Some(doc) = doc else { return Ok(()) };
|
||||
let Some(b) = union_bounds(shapes) else { return Ok(()) };
|
||||
let (parts, bounds) = solid_parts(shapes, b);
|
||||
if side_carrier(id, p, &parts, bounds).is_none() {
|
||||
return Ok(());
|
||||
}
|
||||
graphics::validate_surface_symbols(doc, p, PlanarFace::Side)?;
|
||||
let fx = Effect { id: id.into(), params: p.clone(), visible: true };
|
||||
let mut dropped = false;
|
||||
// Art that can't be built draws the source path, without the side's graphics.
|
||||
let built = surfaces_with(Some(doc), n, &fx, shapes, false, &mut dropped);
|
||||
if dropped || built.is_none() {
|
||||
return Err("The graphics are too complex: simplify the symbols' art".into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Do the solids 3D effect `id` with parameters `p` builds from the profiles of `shapes` about `b`
|
||||
/// build? Only the profiles no solid of [`check_solids`] is built from are built here: for Rotate
|
||||
/// every shape's, except with its shadow cast that of a shape with a visible fill, whose plane is
|
||||
@@ -414,7 +494,7 @@ fn check_solids(id: &str, p: &Value, shapes: &[Profile]) -> Result<(), String> {
|
||||
if !cast {
|
||||
return built_solids(id, p, &parts, bounds, MAX_OBJECT_FACES).try_for_each(|r| r.map(|_| ()));
|
||||
}
|
||||
let built = built_solids_cast(id, p, &parts, bounds, MAX_OBJECT_FACES, true)
|
||||
let built = built_solids_cast(id, p, &parts, bounds, MAX_OBJECT_FACES, true, None)
|
||||
.map(|r| r.map(|solid| solid.and_then(|(_, faces)| faces)))
|
||||
.collect::<Result<Vec<_>, String>>()?;
|
||||
cast_built(id, p, shapes, built).map(|_| ())
|
||||
@@ -688,6 +768,30 @@ fn surface(n: &Node, facets: Vec<Facet>, paint: &Paint, opacity: f32, blend: Ble
|
||||
group
|
||||
}
|
||||
|
||||
/// `surface`, a plain group of one face for each facet ([`surface`]), with each face followed by
|
||||
/// the parts of the side's graphics that `parts` holds for its facet ([`graphics::surface_parts`]):
|
||||
/// a face with parts becomes a group of the face and its parts, so nearer faces drawn after it
|
||||
/// cover them too. `surface` is returned as it is when no facet has a part or it is not such a group.
|
||||
fn with_side_parts(id: NodeId, mut surface: Node, parts: Vec<Vec<Arc<Node>>>) -> Node {
|
||||
if parts.iter().all(Vec::is_empty) {
|
||||
return surface;
|
||||
}
|
||||
let NodeKind::Group { children, clip: false } = &mut surface.kind else { return surface };
|
||||
if children.len() != parts.len() {
|
||||
return surface;
|
||||
}
|
||||
for (child, extra) in children.iter_mut().zip(parts) {
|
||||
if extra.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let mut list = Vec::with_capacity(extra.len() + 1);
|
||||
list.push(child.clone());
|
||||
list.extend(extra);
|
||||
*child = Arc::new(Node::group(id, list));
|
||||
}
|
||||
surface
|
||||
}
|
||||
|
||||
/// The bounds of every facet of `facets` together (`Rect::ZERO` when none has any).
|
||||
pub(crate) fn facets_bounds(facets: &[Facet]) -> Rect {
|
||||
facets.iter().filter_map(|f| f.path().bounds()).reduce(|a, c| a.union(c)).unwrap_or(Rect::ZERO)
|
||||
@@ -802,7 +906,7 @@ fn built_solids<'a>(
|
||||
bounds: Rect,
|
||||
limit: usize,
|
||||
) -> impl Iterator<Item = Result<Option<Vec<Facet>>, String>> + 'a {
|
||||
built_solids_cast(id, p, parts, bounds, limit, false).map(|r| r.map(|s| s.map(|(f, _)| f)))
|
||||
built_solids_cast(id, p, parts, bounds, limit, false, None).map(|r| r.map(|s| s.map(|(f, _)| f)))
|
||||
}
|
||||
|
||||
/// One solid's facets and, when its shadow is cast, the faces it is cast from.
|
||||
@@ -813,7 +917,9 @@ type CastingSolid = (Vec<Facet>, Option<SolidFaces>);
|
||||
type SurfacesAndFaces = (Vec<Arc<Node>>, Vec<Option<SolidFaces>>);
|
||||
|
||||
/// [`built_solids`], and with `cast` for Extrude & Bevel or Inflate each solid's faces its shadow
|
||||
/// is cast from, from the same build ([`SolidFaces`]).
|
||||
/// is cast from, from the same build ([`SolidFaces`]). The solid of part `side`, when there is one,
|
||||
/// is built with the pieces of its side carrying where they lie on it unrolled, for the graphics
|
||||
/// on Extrude & Bevel's side ([`side_carrier`]).
|
||||
fn built_solids_cast<'a>(
|
||||
id: &'a str,
|
||||
p: &'a Value,
|
||||
@@ -821,6 +927,7 @@ fn built_solids_cast<'a>(
|
||||
bounds: Rect,
|
||||
limit: usize,
|
||||
cast: bool,
|
||||
side: Option<usize>,
|
||||
) -> impl Iterator<Item = Result<Option<CastingSolid>, String>> + 'a {
|
||||
// Inflate's eye is placed for every puff together, as far away as the highest needs.
|
||||
let mut inflated = (id == INFLATE).then(|| -> Box<dyn Iterator<Item = Result<CastingSolid, String>>> {
|
||||
@@ -834,7 +941,7 @@ fn built_solids_cast<'a>(
|
||||
});
|
||||
let mut kept = 0usize;
|
||||
let mut ended = false;
|
||||
parts.iter().map_while(move |(item, _, area, rule, _, _)| {
|
||||
parts.iter().enumerate().map_while(move |(k, (item, _, area, rule, _, _))| {
|
||||
if ended {
|
||||
return None;
|
||||
}
|
||||
@@ -846,6 +953,7 @@ fn built_solids_cast<'a>(
|
||||
SOLID_GEOMETRY_BUILT.with(|n| n.set(n.get() + 1));
|
||||
each.next().unwrap_or_else(|| Ok((vec![], None)))
|
||||
}
|
||||
None if side == Some(k) => side_facets_and_faces(area, *rule, bounds, p, cast),
|
||||
None => facets_and_faces(id, area, *rule, bounds, p, cast),
|
||||
};
|
||||
let result = match built {
|
||||
@@ -1098,6 +1206,8 @@ fn cut(s: &Facet, c: &[Point], wall: &Facet, outline: &[Point], turn: f64) -> Op
|
||||
f.depth = s.depth_at(mid).unwrap_or(s.depth);
|
||||
f.contours = vec![points];
|
||||
f.outline = s.outline.as_ref().and_then(|o| clip_to_side(o, c, &values, sign));
|
||||
// A piece keeps where the whole face lies on the side: the parts of the side's graphics
|
||||
// drawn on it are cut to its own outline ([`graphics::SurfaceFace::curved`]).
|
||||
Some(f)
|
||||
};
|
||||
Some((piece(1.0)?, piece(-1.0)?))
|
||||
@@ -1776,6 +1886,12 @@ fn seen_ends(f: &[Facet]) -> impl Iterator<Item = &Facet> {
|
||||
/// solid built also keeps the faces its shadow is cast from, from the same build, in the order the
|
||||
/// solids are built ([`cast_built`]); `None` for a stroke's solid left out of the art.
|
||||
fn surfaces_for(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profile], cast: bool) -> Option<SurfacesAndFaces> {
|
||||
surfaces_with(doc, n, fx, shapes, cast, &mut false)
|
||||
}
|
||||
|
||||
/// [`surfaces_for`], setting `side_dropped` when the graphics on Extrude & Bevel's side are past
|
||||
/// their limits on the pieces drawn, and the solid that takes them draws without them.
|
||||
fn surfaces_with(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profile], cast: bool, side_dropped: &mut bool) -> Option<SurfacesAndFaces> {
|
||||
let b = union_bounds(shapes)?;
|
||||
let p = crate::merged_params(&fx.id, &fx.params);
|
||||
let classic = fx.id == CLASSIC_EXTRUDE || fx.id == CLASSIC_ROTATE;
|
||||
@@ -1818,9 +1934,13 @@ fn surfaces_for(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profile
|
||||
return Some((if masks { masked(n.id, out) } else { out.into_iter().map(|(_, s)| s).collect() }, built));
|
||||
}
|
||||
let (parts, bounds) = solid_parts(shapes, b);
|
||||
// The graphics on Extrude & Bevel's side go once, on the side of the solid with the longest
|
||||
// outline, whose pieces are built carrying where they lie on it.
|
||||
let carrier = if graphics_on { side_carrier(&fx.id, &p, &parts, bounds) } else { None };
|
||||
let mut solids = vec![];
|
||||
let mut built = vec![];
|
||||
for ((item, opacity, _, _, scopes, member), f) in parts.iter().zip(built_solids_cast(&fx.id, &p, &parts, bounds, MAX_OBJECT_FACES, cast)) {
|
||||
let made = built_solids_cast(&fx.id, &p, &parts, bounds, MAX_OBJECT_FACES, cast, carrier);
|
||||
for (k, ((item, opacity, _, _, scopes, member), f)) in parts.iter().zip(made).enumerate() {
|
||||
let item: &AppearanceItem = item;
|
||||
match f {
|
||||
Ok(Some((f, _))) if !crate::revolve::paint_copies_add(&mut paint_bytes, facet_copies(&f, paint_ref(item), colored), paint_ref(item)) => {
|
||||
@@ -1830,8 +1950,12 @@ fn surfaces_for(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profile
|
||||
solids.push((item, *opacity, *scopes, f, *member));
|
||||
built.push(faces);
|
||||
}
|
||||
// A stroke's outline past the limits is left out; the fill's solid still draws.
|
||||
Ok(None) => built.push(None),
|
||||
// A stroke's outline past the limits is left out; the fill's solid still draws, and
|
||||
// the side's graphics on that outline are not drawn.
|
||||
Ok(None) => {
|
||||
built.push(None);
|
||||
*side_dropped |= carrier == Some(k);
|
||||
}
|
||||
// A loaded file or a shape edited past the limits (its own, or those of the object's
|
||||
// solids together) keeps drawing its source path instead of failing the frame;
|
||||
// commands validate the same evaluator and report its errors.
|
||||
@@ -1915,6 +2039,9 @@ fn surfaces_for(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profile
|
||||
// ([`in_one_order`], [`underlaid_surface`]).
|
||||
let seals: Vec<bool> = solids.iter().map(|(.., f, _)| underlaid(f, colored)).collect();
|
||||
let seal = |range: std::ops::Range<usize>| seals.get(range).is_some_and(|s| s.iter().any(|s| *s));
|
||||
let side_graphics = carrier.map(|_| mapped_graphics(&p)).unwrap_or_default();
|
||||
// The paint copies of the side's graphics, apart from those of the surfaces, as on Revolve.
|
||||
let mut graphic_copies = 0usize;
|
||||
let surfaces: Vec<BuiltSurface> = solids
|
||||
.into_iter()
|
||||
.map(|(item, member, scopes, f, shape)| {
|
||||
@@ -1922,10 +2049,22 @@ fn surfaces_for(doc: Option<&Document>, n: &Node, fx: &Effect, shapes: &[Profile
|
||||
let depths: Vec<Placed> = f.iter().map(|f| Placed::of(f, shape, paints)).collect();
|
||||
let ends = f.iter().map(|f| f.end.filter(|_| !f.away)).collect();
|
||||
let (paint, opacity, blend) = paint_of(item, member);
|
||||
// The carrier's pieces draw the parts of the side's graphics that fall on them; past
|
||||
// the graphics' limits the solid draws without them.
|
||||
let parts = if side_graphics.is_empty() || !f.iter().any(|f| f.surface.is_some()) {
|
||||
vec![]
|
||||
} else {
|
||||
let shade = |f: &Facet, c: vectorcraft_doc::color::Color| Paint::solid(crate::lighting::shade(c, f.illumination));
|
||||
let parts = graphics::surface_parts(doc, n.id, (&side_graphics, PlanarFace::Side), &f, &shade, &mut graphic_copies);
|
||||
*side_dropped |= parts.is_none();
|
||||
parts.unwrap_or_default()
|
||||
};
|
||||
let drawn = parts.iter().any(|p| !p.is_empty());
|
||||
let art = if classic {
|
||||
classic::surface(n, f, &paint, opacity, blend, &p)
|
||||
} else {
|
||||
surface(n, f, &paint, opacity, blend, colored, split && shared.get(shape).copied().unwrap_or(false))
|
||||
let faces = drawn || (split && shared.get(shape).copied().unwrap_or(false));
|
||||
with_side_parts(n.id, surface(n, f, &paint, opacity, blend, colored, faces), parts)
|
||||
};
|
||||
(depths, art, scopes, ends)
|
||||
})
|
||||
@@ -2239,8 +2378,18 @@ pub fn graphics_reshaped_after(n: &Node, item: Option<usize>, index: usize) -> b
|
||||
/// Finds a 3D effect in a list of effects, with its index there.
|
||||
type Pick<'p> = dyn for<'e> Fn(&'e [Effect]) -> Option<(usize, &'e Effect)> + 'p;
|
||||
|
||||
/// [`graphic_frame`] of the 3D effect `pick` finds in the effects of `n` or its `item`.
|
||||
fn frame_of(doc: Option<&Document>, n: &Node, item: Option<usize>, pick: &Pick<'_>) -> Option<graphics::GraphicFrame> {
|
||||
/// The size of the side unrolled of the Extrude & Bevel at `index` of the effects of `n` (on the
|
||||
/// object itself with `item` `None`, else on its fill or stroke `item`), that a new graphic on it
|
||||
/// fits: on the side of its solid with the longest outline, as wide as the part about x = 0 that
|
||||
/// does not reach the side's cut, and as tall as the length across its bevels and walls. `None` when that effect is not a visible Extrude & Bevel with a
|
||||
/// depth, or its art can't be built.
|
||||
pub fn graphic_side_size(doc: Option<&Document>, n: &Node, item: Option<usize>, index: usize) -> Option<(f64, f64)> {
|
||||
let (fx, shapes) = frame_shapes(doc, n, item, &|fx: &[Effect]| fx.get(index).filter(|e| e.visible && e.id == EXTRUDE).map(|e| (index, e)))?;
|
||||
side_size(&crate::merged_params(&fx.id, &fx.params), &shapes)
|
||||
}
|
||||
|
||||
/// The 3D effect `pick` finds in the effects of `n` or its `item`, and the shapes it builds from.
|
||||
fn frame_shapes(doc: Option<&Document>, n: &Node, item: Option<usize>, pick: &Pick<'_>) -> Option<(Effect, Vec<Profile>)> {
|
||||
let n = &*resolve(doc, n, "").ok()?;
|
||||
let (fx, shapes) = if is_container(n) {
|
||||
let (index, fx) = pick(&n.appearance.effects).filter(|_| item.is_none())?;
|
||||
@@ -2264,6 +2413,12 @@ fn frame_of(doc: Option<&Document>, n: &Node, item: Option<usize>, pick: &Pick<'
|
||||
}
|
||||
}
|
||||
};
|
||||
Some((fx.clone(), shapes))
|
||||
}
|
||||
|
||||
/// [`graphic_frame`] of the 3D effect `pick` finds in the effects of `n` or its `item`.
|
||||
fn frame_of(doc: Option<&Document>, n: &Node, item: Option<usize>, pick: &Pick<'_>) -> Option<graphics::GraphicFrame> {
|
||||
let (fx, shapes) = frame_shapes(doc, n, item, pick)?;
|
||||
if !takes_graphics(&fx.id) {
|
||||
return None;
|
||||
}
|
||||
@@ -2289,10 +2444,19 @@ fn frame_of(doc: Option<&Document>, n: &Node, item: Option<usize>, pick: &Pick<'
|
||||
let plane = vectorcraft_three_d::plane_face_map(b, view);
|
||||
return Some(graphics::GraphicFrame::new(b, plane, None));
|
||||
}
|
||||
let (_, bounds) = solid_parts(&shapes, b);
|
||||
let (parts, bounds) = solid_parts(&shapes, b);
|
||||
let options = extrude_options(&p);
|
||||
let map = |face| vectorcraft_three_d::extrude_face_map(bounds, options, view, face);
|
||||
Some(graphics::GraphicFrame::new(bounds, map(PlanarFace::Front), map(PlanarFace::Back)))
|
||||
let frame = graphics::GraphicFrame::new(bounds, map(PlanarFace::Front), map(PlanarFace::Back));
|
||||
// With graphics on the side, the part of it the viewer sees places their handles.
|
||||
let side = side_carrier(&fx.id, &p, &parts, bounds)
|
||||
.and_then(|k| parts.get(k))
|
||||
.and_then(|(_, _, area, rule, _, _)| side_facets(area, *rule, bounds, &p).ok())
|
||||
.map(|facets| graphics::SideFrame::of(&facets));
|
||||
Some(match side {
|
||||
Some(side) => frame.with_side(side),
|
||||
None => frame,
|
||||
})
|
||||
}
|
||||
|
||||
/// The bounds of the art symbol `name` of `doc` draws as a graphic, in the symbol's coordinates.
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
//! Graphics mapped onto a 3D object's planar faces (Window › 3D and Materials › Materials ›
|
||||
//! Graphics): the art of a document symbol drawn on Extrude & Bevel's front or back cap, or on a
|
||||
//! plane, turned, foreshortened and shaded with that face and clipped to it.
|
||||
//! Graphics mapped onto a 3D object's faces (Window › 3D and Materials › Materials ›
|
||||
//! Graphics): the art of a document symbol drawn on Extrude & Bevel's front or back cap or on its
|
||||
//! side, or on a plane, turned, foreshortened and shaded with that face and clipped to it.
|
||||
//!
|
||||
//! The effect keeps its graphics in its `graphics` parameter, each `{symbol, face, x, y, scale,
|
||||
//! rotation}`: the symbol's name, the face, the offset of the graphic's center from the center of
|
||||
@@ -12,7 +12,10 @@
|
||||
//! On Revolve the graphics lie on the swept side surface, unrolled flat
|
||||
//! ([`vectorcraft_three_d::SurfaceCell`]): x and y are the offset of the graphic's center from the
|
||||
//! middle of that surface, x around the axis and y along the profile, and each face of the side
|
||||
//! draws the part of the graphics that falls on it ([`surface_parts`]).
|
||||
//! draws the part of the graphics that falls on it ([`surface_parts`]). Graphics on Extrude &
|
||||
//! Bevel's side (face `side`) lie on its walls and bevels unrolled the same way, x along the
|
||||
//! outline and y from the front toward the back, drawn on the pieces of the side of the solid with
|
||||
//! the longest outline.
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
@@ -110,7 +113,7 @@ impl MappedGraphic {
|
||||
};
|
||||
let face = match m.get("face") {
|
||||
None => PlanarFace::Front,
|
||||
Some(v) => v.as_str().and_then(PlanarFace::parse).ok_or_else(|| format!("`{GRAPHICS}` face must be front or back"))?,
|
||||
Some(v) => v.as_str().and_then(PlanarFace::parse).ok_or_else(|| format!("`{GRAPHICS}` face must be front, back or side"))?,
|
||||
};
|
||||
let number = |key: &str, default: f64, (lo, hi): (f64, f64)| -> Result<f64, String> {
|
||||
match m.get(key) {
|
||||
@@ -139,7 +142,7 @@ impl MappedGraphic {
|
||||
* Affine::scale(self.scale / 100.0)
|
||||
* Affine::translate(-art.center().to_vec2());
|
||||
match self.face {
|
||||
PlanarFace::Front => place,
|
||||
PlanarFace::Front | PlanarFace::Side => place,
|
||||
// Seen from behind, the back's right is the front's left.
|
||||
PlanarFace::Back => {
|
||||
Affine::translate(center.to_vec2()) * Affine::scale_non_uniform(-1.0, 1.0) * Affine::translate(-center.to_vec2()) * place
|
||||
@@ -148,8 +151,8 @@ impl MappedGraphic {
|
||||
}
|
||||
}
|
||||
|
||||
/// The 3D effects that take graphics: Extrude & Bevel (its caps), Rotate (the plane) and Revolve
|
||||
/// (its swept side).
|
||||
/// The 3D effects that take graphics: Extrude & Bevel (its caps and its side), Rotate (the plane)
|
||||
/// and Revolve (its swept side).
|
||||
pub fn takes_graphics(id: &str) -> bool {
|
||||
id == super::EXTRUDE || id == super::ROTATE || id == crate::REVOLVE
|
||||
}
|
||||
@@ -165,7 +168,7 @@ pub fn mapped_graphics(p: &Value) -> Vec<MappedGraphic> {
|
||||
|
||||
/// Are the graphics in parameters `p` of 3D effect `id` valid? Only Extrude & Bevel, Rotate and
|
||||
/// Revolve take graphics; a plane has only a front, and Revolve's graphics go on its side, named
|
||||
/// the front.
|
||||
/// the front. Only Extrude & Bevel takes graphics on its side.
|
||||
pub fn validate(id: &str, p: &Value) -> Result<(), String> {
|
||||
let list = match p.get(GRAPHICS) {
|
||||
None => return Ok(()),
|
||||
@@ -183,10 +186,10 @@ pub fn validate(id: &str, p: &Value) -> Result<(), String> {
|
||||
}
|
||||
for v in list {
|
||||
let g = MappedGraphic::from_value(v)?;
|
||||
if id == super::ROTATE && g.face == PlanarFace::Back {
|
||||
if id == super::ROTATE && g.face != PlanarFace::Front {
|
||||
return Err("A plane has one face: map its graphics onto the front".into());
|
||||
}
|
||||
if id == crate::REVOLVE && g.face == PlanarFace::Back {
|
||||
if id == crate::REVOLVE && g.face != PlanarFace::Front {
|
||||
return Err("Revolve maps graphics onto its side: map them onto the front".into());
|
||||
}
|
||||
}
|
||||
@@ -598,14 +601,14 @@ struct Unrolled {
|
||||
place: Affine,
|
||||
}
|
||||
|
||||
/// The areas of `graphics` (those of the front: Revolve's side) placed on the unrolled side
|
||||
/// surface, cut into straight pieces. A graphic whose symbol `doc` does not have, or whose art is
|
||||
/// past the limits of [`pieces_of`], is left out. `None` when the pieces take more than
|
||||
/// [`MAX_ELEMENTS`] points together.
|
||||
fn unrolled(doc: &Document, graphics: &[MappedGraphic]) -> Option<Vec<Unrolled>> {
|
||||
/// The areas of `graphics` on `face` (the front, for Revolve's side, or Extrude & Bevel's side)
|
||||
/// placed on the unrolled side surface, cut into straight pieces. A graphic whose symbol `doc` does
|
||||
/// not have, or whose art is past the limits of [`pieces_of`], is left out. `None` when the pieces
|
||||
/// take more than [`MAX_ELEMENTS`] points together.
|
||||
fn unrolled(doc: &Document, graphics: &[MappedGraphic], face: PlanarFace) -> Option<Vec<Unrolled>> {
|
||||
let mut pieces = vec![];
|
||||
let mut points = 0usize;
|
||||
for g in graphics.iter().filter(|g| g.face == PlanarFace::Front) {
|
||||
for g in graphics.iter().filter(|g| g.face == face) {
|
||||
let Some(symbol) = doc.symbols.iter().find(|s| s.name == g.symbol) else { continue };
|
||||
let Ok(art) = pieces_of(doc, symbol) else { continue };
|
||||
let Some(bounds) = art.iter().filter_map(|p| p.path.bounds()).reduce(|a, b| a.union(b)) else { continue };
|
||||
@@ -682,38 +685,96 @@ fn straight_pieces(path: &BezPath, points: &mut usize) -> Option<Vec<Vec<Point>>
|
||||
(*points <= MAX_ELEMENTS).then_some(polygons)
|
||||
}
|
||||
|
||||
/// Do the graphics in Revolve parameters `p` fit the limits with the symbols of `doc`? Their art,
|
||||
/// cut into straight pieces on the side surface, may take up to [`MAX_ELEMENTS`] points together.
|
||||
pub(crate) fn validate_surface_symbols(doc: &Document, p: &Value) -> Result<(), String> {
|
||||
/// Do the graphics on `face` in parameters `p` (the front of Revolve, Extrude & Bevel's side) fit
|
||||
/// the limits with the symbols of `doc`? Their art, cut into straight pieces on the side surface,
|
||||
/// may take up to [`MAX_ELEMENTS`] points together.
|
||||
pub(crate) fn validate_surface_symbols(doc: &Document, p: &Value, face: PlanarFace) -> Result<(), String> {
|
||||
let list = mapped_graphics(p);
|
||||
if list.is_empty() || unrolled(doc, &list).is_some() {
|
||||
if !list.iter().any(|g| g.face == face) || unrolled(doc, &list, face).is_some() {
|
||||
return Ok(());
|
||||
}
|
||||
Err("The graphics are too complex: simplify the symbols' art".into())
|
||||
}
|
||||
|
||||
/// The parts of `graphics` that fall on each of `faces`, a revolved surface's faces in drawing
|
||||
/// order, for an object with id `id`: for each face, the nodes to draw right after it. Only faces
|
||||
/// of the swept side that show their outside to the viewer carry a part, so a graphic narrows
|
||||
/// toward the silhouette, is hidden past it and is covered by the nearer faces drawn after it.
|
||||
/// `shade` gives the paint of a solid color on a face, as the surface under it is shaded; the
|
||||
/// colors of gradients and patterns are multiplied by the face's light. A graphic whose symbol
|
||||
/// `doc` does not have, or that is past the limits of its art, draws nothing. `None` past
|
||||
/// [`MAX_ELEMENTS`] points together before they are cut at the faces, [`MAX_SURFACE_POINTS`]
|
||||
/// after, [`MAX_SURFACE_CUTS`] points cut, or when the copies of their paints in the parts take
|
||||
/// `copies`, the bytes of the copies of the object's graphics so far, past Revolve's budget for
|
||||
/// them: commands refuse such graphics, and a loaded file draws the surface without them.
|
||||
pub(crate) fn surface_parts(
|
||||
/// A face of a side surface that graphics are drawn on ([`surface_parts`]): a face of Revolve's
|
||||
/// swept side, or a piece of Extrude & Bevel's walls and bevels.
|
||||
pub(crate) trait SurfaceFace {
|
||||
/// Where the face lies on the side unrolled, when it is a face of the side that shows its
|
||||
/// outside to the viewer.
|
||||
fn outer_cell(&self) -> Option<&vectorcraft_three_d::SurfaceCell>;
|
||||
/// The outline the face's parts are cut to, when it is not the polygon of its cell's corners:
|
||||
/// its curved outline, when its edges along an end are curved, or the outline of a piece cut
|
||||
/// from a larger face.
|
||||
fn curved(&self) -> Option<std::borrow::Cow<'_, PathData>>;
|
||||
fn rgb_light(&self) -> Option<vectorcraft_three_d::RgbGradient>;
|
||||
fn light(&self) -> [f64; 3];
|
||||
fn outline_path(&self) -> PathData;
|
||||
}
|
||||
|
||||
impl SurfaceFace for vectorcraft_three_d::Face {
|
||||
fn outer_cell(&self) -> Option<&vectorcraft_three_d::SurfaceCell> {
|
||||
self.surface.as_ref().filter(|c| c.outward && !self.cap)
|
||||
}
|
||||
fn curved(&self) -> Option<std::borrow::Cow<'_, PathData>> {
|
||||
self.outline.as_ref().map(std::borrow::Cow::Borrowed)
|
||||
}
|
||||
fn rgb_light(&self) -> Option<vectorcraft_three_d::RgbGradient> {
|
||||
self.rgb_gradient
|
||||
}
|
||||
fn light(&self) -> [f64; 3] {
|
||||
self.illumination
|
||||
}
|
||||
fn outline_path(&self) -> PathData {
|
||||
self.path()
|
||||
}
|
||||
}
|
||||
|
||||
impl SurfaceFace for Facet {
|
||||
fn outer_cell(&self) -> Option<&vectorcraft_three_d::SurfaceCell> {
|
||||
self.surface.as_ref().filter(|c| c.outward)
|
||||
}
|
||||
fn curved(&self) -> Option<std::borrow::Cow<'_, PathData>> {
|
||||
if let Some(outline) = &self.outline {
|
||||
return Some(std::borrow::Cow::Borrowed(outline));
|
||||
}
|
||||
// A piece of a stroke's face cut where it passes through a wall keeps its face's cell.
|
||||
let cut = self.surface.as_ref().is_some_and(|c| self.contours.len() != 1 || self.contours.first() != Some(&c.page));
|
||||
cut.then(|| std::borrow::Cow::Owned(self.path()))
|
||||
}
|
||||
fn rgb_light(&self) -> Option<vectorcraft_three_d::RgbGradient> {
|
||||
self.rgb_gradient
|
||||
}
|
||||
fn light(&self) -> [f64; 3] {
|
||||
self.illumination
|
||||
}
|
||||
fn outline_path(&self) -> PathData {
|
||||
self.path()
|
||||
}
|
||||
}
|
||||
|
||||
/// The parts of the graphics on `face` of `graphics` (the front of Revolve, Extrude & Bevel's side)
|
||||
/// that fall on each of `faces`, a side surface's faces in drawing order, for an object with id
|
||||
/// `id`: for each face, the nodes to draw right after it. Only faces of the side that show their
|
||||
/// outside to the viewer carry a part, so a graphic narrows toward the silhouette, is hidden past
|
||||
/// it and is covered by the nearer faces drawn after it. `shade` gives the paint of a solid color
|
||||
/// on a face, as the surface under it is shaded; the colors of gradients and patterns are
|
||||
/// multiplied by the face's light. A graphic whose symbol `doc` does not have, or that is past the
|
||||
/// limits of its art, draws nothing. `None` past [`MAX_ELEMENTS`] points together before they are
|
||||
/// cut at the faces, [`MAX_SURFACE_POINTS`] after, [`MAX_SURFACE_CUTS`] points cut, or when the
|
||||
/// copies of their paints in the parts take `copies`, the bytes of the copies of the object's
|
||||
/// graphics so far, past Revolve's budget for them: commands refuse such graphics, and a loaded
|
||||
/// file draws the surface without them.
|
||||
pub(crate) fn surface_parts<F: SurfaceFace>(
|
||||
doc: Option<&Document>,
|
||||
id: NodeId,
|
||||
graphics: &[MappedGraphic],
|
||||
faces: &[vectorcraft_three_d::Face],
|
||||
shade: &dyn Fn(&vectorcraft_three_d::Face, vectorcraft_doc::color::Color) -> Paint,
|
||||
(graphics, face): (&[MappedGraphic], PlanarFace),
|
||||
faces: &[F],
|
||||
shade: &dyn Fn(&F, vectorcraft_doc::color::Color) -> Paint,
|
||||
copies: &mut usize,
|
||||
) -> Option<Vec<Vec<Arc<Node>>>> {
|
||||
let mut out: Vec<Vec<Arc<Node>>> = vec![vec![]; faces.len()];
|
||||
let Some(doc) = doc else { return Some(out) };
|
||||
let pieces = unrolled(doc, graphics)?;
|
||||
let pieces = unrolled(doc, graphics, face)?;
|
||||
let Some(all) = pieces.iter().map(|p| p.bounds).reduce(|a, b| a.union(b)) else { return Some(out) };
|
||||
// Each piece listed in the buckets of the surface's x its bounds reach across.
|
||||
let width = (all.width() / SURFACE_BUCKETS as f64).max(1e-9);
|
||||
@@ -729,11 +790,12 @@ pub(crate) fn surface_parts(
|
||||
let mut cut_points = 0usize;
|
||||
let mut triangle_id = 0usize;
|
||||
for (face, parts) in faces.iter().zip(out.iter_mut()) {
|
||||
let Some(cell) = face.surface.as_ref().filter(|c| c.outward && !face.cap) else { continue };
|
||||
let Some(cell) = face.outer_cell() else { continue };
|
||||
if cell.uv.len() != cell.page.len() || !(3..=4).contains(&cell.uv.len()) {
|
||||
continue;
|
||||
}
|
||||
let triangles: &[[usize; 3]] = if cell.uv.len() == 3 { &[[0, 1, 2]] } else { &[[0, 1, 2], [0, 2, 3]] };
|
||||
let curved = face.curved();
|
||||
for corners in triangles {
|
||||
triangle_id += 1;
|
||||
let pick = |of: &[Point]| corners.iter().map(|k| of.get(*k).copied()).collect::<Option<Vec<Point>>>();
|
||||
@@ -744,7 +806,7 @@ pub(crate) fn surface_parts(
|
||||
// where the graphic runs past the end of the profile. A four-cornered face is cut into
|
||||
// two triangles along its diagonal from corner 0 to corner 2: each takes the part of
|
||||
// the outline on its own side of it.
|
||||
let window = if face.outline.is_some() { grown(window, 3.0) } else { window };
|
||||
let window = if curved.is_some() { grown(window, 3.0) } else { window };
|
||||
// The pieces are looked up over the whole of the window they are cut to.
|
||||
let Some(reach) = window.iter().map(|p| Rect::from_points(*p, *p)).reduce(|a, b| a.union(b)) else { continue };
|
||||
if reach.x1 < all.x0 || reach.x0 > all.x1 || reach.y1 < all.y0 || reach.y0 > all.y1 {
|
||||
@@ -771,7 +833,7 @@ pub(crate) fn surface_parts(
|
||||
}
|
||||
near.sort_unstable();
|
||||
let own = corners.iter().find(|k| **k != 0 && **k != 2).and_then(|k| cell.page.get(*k)).filter(|_| triangles.len() == 2);
|
||||
let rim = face.outline.as_ref().map(|outline| match (own, cell.page.first(), cell.page.get(2)) {
|
||||
let rim = curved.as_deref().map(|outline| match (own, cell.page.first(), cell.page.get(2)) {
|
||||
(Some(&toward), Some(&a), Some(&b)) => {
|
||||
let side = side_of(a, b, toward);
|
||||
vectorcraft_pathops::boolean(outline, FillRule::NonZero, &side, FillRule::NonZero, vectorcraft_pathops::BoolOp::Intersect)
|
||||
@@ -834,21 +896,21 @@ pub(crate) fn surface_parts(
|
||||
|
||||
/// The node of the part `path` (on the page, filled under `rule`) of `piece`, which `map` takes
|
||||
/// from the unrolled surface onto `face`.
|
||||
fn surface_piece(
|
||||
fn surface_piece<F: SurfaceFace>(
|
||||
id: NodeId,
|
||||
piece: &Unrolled,
|
||||
(path, rule): (BezPath, FillRule),
|
||||
map: Affine,
|
||||
face: &vectorcraft_three_d::Face,
|
||||
shade: &dyn Fn(&vectorcraft_three_d::Face, vectorcraft_doc::color::Color) -> Paint,
|
||||
face: &F,
|
||||
shade: &dyn Fn(&F, vectorcraft_doc::color::Color) -> Paint,
|
||||
) -> Node {
|
||||
let gradient_map = map * piece.place;
|
||||
// Under several lights a face's light varies across it in each channel: a solid color draws
|
||||
// as the face's own lit art in that color, clipped to the part. An opaque part also draws that
|
||||
// art clipped to a band of the seam stroke's width around its edges, as the other parts take
|
||||
// a stroke over their seams.
|
||||
if let (Some(c), Some(light)) = (piece.paint.color().filter(|_| matches!(piece.paint, Paint::Solid { .. })), face.rgb_gradient) {
|
||||
let lit = Arc::new(crate::lighting::rgb_gradient_art(id, &face.path(), &Paint::solid(c), light));
|
||||
if let (Some(c), Some(light)) = (piece.paint.color().filter(|_| matches!(piece.paint, Paint::Solid { .. })), face.rgb_light()) {
|
||||
let lit = Arc::new(crate::lighting::rgb_gradient_art(id, &face.outline_path(), &Paint::solid(c), light));
|
||||
let clipped = |area: &BezPath, rule: FillRule| {
|
||||
let mut clip = Node::path(id, PathData::from_bezpath(area), Appearance::default());
|
||||
if let NodeKind::Path { rule: r, .. } = &mut clip.kind {
|
||||
@@ -881,7 +943,7 @@ fn surface_piece(
|
||||
match solid {
|
||||
Some(c) => f.paint = shade(face, c),
|
||||
None => {
|
||||
vectorcraft_doc::recolor::map_paint(&mut f.paint, &|c| crate::lighting::shade(c, face.illumination));
|
||||
vectorcraft_doc::recolor::map_paint(&mut f.paint, &|c| crate::lighting::shade(c, face.light()));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -996,23 +1058,106 @@ pub(super) fn art_bounds(doc: &Document, name: &str) -> Option<Rect> {
|
||||
}
|
||||
|
||||
/// Where a 3D object's graphics are drawn: the bounds its solids are built with (the graphics'
|
||||
/// offsets are from their center) and the maps of its front and back faces, when it has them.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
/// offsets are from their center), the maps of its front and back faces, when it has them, and
|
||||
/// the visible part of its side unrolled, when it has graphics there.
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct GraphicFrame {
|
||||
pub bounds: Rect,
|
||||
front: Option<FaceMap>,
|
||||
back: Option<FaceMap>,
|
||||
side: Option<SideFrame>,
|
||||
}
|
||||
|
||||
/// The pieces of Extrude & Bevel's side that show their outside to the viewer, as the graphics are
|
||||
/// drawn on them ([`surface_parts`]): each piece's corners on the side unrolled and on the page, the
|
||||
/// outline its parts are cut to when that is not the polygon of its corners, and its depth (larger
|
||||
/// is nearer).
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct SideFrame {
|
||||
pieces: Vec<SidePiece>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
struct SidePiece {
|
||||
uv: Vec<Point>,
|
||||
page: Vec<Point>,
|
||||
outline: Option<BezPath>,
|
||||
depth: f64,
|
||||
}
|
||||
|
||||
impl SideFrame {
|
||||
/// The pieces of `facets` that carry where they lie on the side unrolled and show its outside.
|
||||
pub(super) fn of(facets: &[Facet]) -> Self {
|
||||
let pieces = facets
|
||||
.iter()
|
||||
.filter_map(|f| {
|
||||
let cell = f.outer_cell().filter(|c| c.uv.len() == c.page.len() && (3..=4).contains(&c.uv.len()))?;
|
||||
let outline = f.curved().map(|o| o.to_bezpath());
|
||||
Some(SidePiece { uv: cell.uv.clone(), page: cell.page.clone(), outline, depth: f.depth })
|
||||
})
|
||||
.collect();
|
||||
Self { pieces }
|
||||
}
|
||||
|
||||
/// Point `p` of the side unrolled mapped onto the page, or with `from_page` a page point mapped
|
||||
/// onto the side unrolled, through the nearest piece whose drawn part holds it: within the
|
||||
/// triangle of its corners on the same side of its diagonal from corner 0 to corner 2, grown and
|
||||
/// cut to its outline as [`surface_parts`] cuts the parts. `None` when no piece holds it.
|
||||
fn map(&self, p: Point, from_page: bool) -> Option<Point> {
|
||||
let inside = |t: &[Point; 3], q: Point| {
|
||||
let side = |a: Point, b: Point| (b - a).cross(q - a);
|
||||
let s = [side(t[0], t[1]), side(t[1], t[2]), side(t[2], t[0])];
|
||||
s.iter().all(|v| *v >= -1e-9) || s.iter().all(|v| *v <= 1e-9)
|
||||
};
|
||||
let mut best: Option<(Point, f64)> = None;
|
||||
for piece in &self.pieces {
|
||||
let (from, to) = if from_page { (&piece.page, &piece.uv) } else { (&piece.uv, &piece.page) };
|
||||
let triangles: &[[usize; 3]] = if from.len() == 3 { &[[0, 1, 2]] } else { &[[0, 1, 2], [0, 2, 3]] };
|
||||
for corners in triangles {
|
||||
let pick = |of: &[Point]| Some([*of.get(corners[0])?, *of.get(corners[1])?, *of.get(corners[2])?]);
|
||||
let (Some(a), Some(b)) = (pick(from), pick(to)) else { continue };
|
||||
let window = if piece.outline.is_some() { grown(a, 3.0) } else { a };
|
||||
if !inside(&window, p) {
|
||||
continue;
|
||||
}
|
||||
// A four-cornered piece's two triangles meet along its diagonal: each holds its side.
|
||||
if triangles.len() == 2
|
||||
&& let (Some(&d0), Some(&d2), Some(&own)) = (from.first(), from.get(2), from.get(if corners[1] == 1 { 1 } else { 3 }))
|
||||
{
|
||||
let across = |q: Point| (d2 - d0).cross(q - d0);
|
||||
if across(p) * across(own) < 0.0 {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
let Some(q) = triangle_map(&a, &b).map(|m| m * p).filter(|q| q.is_finite()) else { continue };
|
||||
let on_page = if from_page { p } else { q };
|
||||
if piece.outline.as_ref().is_some_and(|o| !o.contains(on_page)) {
|
||||
continue;
|
||||
}
|
||||
if best.is_none_or(|(_, depth)| piece.depth > depth) {
|
||||
best = Some((q, piece.depth));
|
||||
}
|
||||
}
|
||||
}
|
||||
best.map(|(q, _)| q)
|
||||
}
|
||||
}
|
||||
|
||||
impl GraphicFrame {
|
||||
pub(super) fn new(bounds: Rect, front: Option<FaceMap>, back: Option<FaceMap>) -> Self {
|
||||
Self { bounds, front, back }
|
||||
Self { bounds, front, back, side: None }
|
||||
}
|
||||
|
||||
/// The frame with the visible part of the side `side`, for its graphics' handles.
|
||||
pub(super) fn with_side(self, side: SideFrame) -> Self {
|
||||
Self { side: Some(side), ..self }
|
||||
}
|
||||
|
||||
pub fn map(&self, face: PlanarFace) -> Option<&FaceMap> {
|
||||
match face {
|
||||
PlanarFace::Front => self.front.as_ref(),
|
||||
PlanarFace::Back => self.back.as_ref(),
|
||||
PlanarFace::Side => None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1023,23 +1168,34 @@ impl GraphicFrame {
|
||||
match face {
|
||||
PlanarFace::Front => Point::new(c.x + x, c.y + y),
|
||||
PlanarFace::Back => Point::new(c.x - x, c.y + y),
|
||||
PlanarFace::Side => Point::new(x, y),
|
||||
}
|
||||
}
|
||||
|
||||
/// Where graphic `g`'s center lands on the page, and whether its face is turned toward the
|
||||
/// viewer. `None` when the object has no such face or the point has no page point.
|
||||
/// viewer. `None` when the object has no such face or the point has no page point. A graphic on
|
||||
/// the side lands where its center is on the part of the side the viewer sees, and is `None`
|
||||
/// elsewhere.
|
||||
pub fn handle(&self, g: &MappedGraphic) -> Option<(Point, bool)> {
|
||||
if g.face == PlanarFace::Side {
|
||||
return Some((self.side.as_ref()?.map(Point::new(g.x, g.y), false)?, true));
|
||||
}
|
||||
let map = self.map(g.face)?;
|
||||
Some((map.to_page(self.art_point(g.face, (g.x, g.y)))?, map.visible))
|
||||
}
|
||||
|
||||
/// The offset of a graphic on `face` whose center lands on page point `page`.
|
||||
/// The offset of a graphic on `face` whose center lands on page point `page`. On the side, only
|
||||
/// a point on the part of the side the viewer sees has one.
|
||||
pub fn offset_at(&self, face: PlanarFace, page: Point) -> Option<(f64, f64)> {
|
||||
let art = self.map(face)?.to_art(page)?;
|
||||
let art = match face {
|
||||
PlanarFace::Side => self.side.as_ref()?.map(page, true)?,
|
||||
_ => self.map(face)?.to_art(page)?,
|
||||
};
|
||||
let c = self.bounds.center();
|
||||
let (x, y) = match face {
|
||||
PlanarFace::Front => (art.x - c.x, art.y - c.y),
|
||||
PlanarFace::Back => (c.x - art.x, art.y - c.y),
|
||||
PlanarFace::Side => (art.x, art.y),
|
||||
};
|
||||
(x.abs() <= MAX_OFFSET && y.abs() <= MAX_OFFSET).then_some((x, y))
|
||||
}
|
||||
@@ -1047,11 +1203,17 @@ impl GraphicFrame {
|
||||
/// The scale (percent) at which art with bounds `art` fits inside the object's bounds, at most
|
||||
/// 100: where a newly mapped graphic starts.
|
||||
pub fn fitting_scale(&self, art: Rect) -> f64 {
|
||||
let fit = (self.bounds.width() / art.width().max(1e-9)).min(self.bounds.height() / art.height().max(1e-9));
|
||||
(fit * 100.0).clamp(SCALE_RANGE.0, 100.0)
|
||||
fitting(self.bounds.width(), self.bounds.height(), art)
|
||||
}
|
||||
}
|
||||
|
||||
/// The scale (percent) at which art with bounds `art` fits inside a `width` × `height` area, at
|
||||
/// most 100.
|
||||
pub fn fitting(width: f64, height: f64, art: Rect) -> f64 {
|
||||
let fit = (width / art.width().max(1e-9)).min(height / art.height().max(1e-9));
|
||||
(fit * 100.0).clamp(SCALE_RANGE.0, 100.0)
|
||||
}
|
||||
|
||||
/// The symbols the graphics of `n`'s 3D effects name (its own effects and its fills' and strokes').
|
||||
pub fn graphic_symbols(n: &Node) -> Vec<String> {
|
||||
appearance_graphic_symbols(&n.appearance)
|
||||
@@ -1135,3 +1297,7 @@ pub fn with_graphic(p: &Value, g: &MappedGraphic) -> Value {
|
||||
#[cfg(test)]
|
||||
#[path = "tests_graphics.rs"]
|
||||
mod tests;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "tests_graphics_side.rs"]
|
||||
mod tests_side;
|
||||
@@ -774,6 +774,7 @@ fn a_stroke_face_through_a_fill_wall_is_cut_where_their_depths_meet() {
|
||||
side: true,
|
||||
away: false,
|
||||
end: None,
|
||||
surface: None,
|
||||
plane: Some(DepthPlane { normal, offset, center: Point::ZERO, eye: None }),
|
||||
};
|
||||
let wall = facet(0.0, [0.0, 0.0, 1.0], 0.0);
|
||||
|
||||
@@ -531,12 +531,13 @@ fn graphics_are_checked() {
|
||||
let n = object(EXTRUDE, json!({}));
|
||||
let check = |id: &str, graphics: Value| validate_three_d_in(None, &n, id, &json!({"graphics": graphics}));
|
||||
assert!(check(EXTRUDE, json!([{"symbol": "Mark", "face": "back", "x": 3.0, "scale": 50.0, "rotation": -90.0}])).is_ok());
|
||||
assert!(check(EXTRUDE, json!([{"symbol": "Mark", "face": "side", "x": -40.0, "y": 5.0}])).is_ok());
|
||||
assert!(check(EXTRUDE, json!([])).is_ok());
|
||||
for bad in [
|
||||
json!("Mark"),
|
||||
json!([{"face": "front"}]),
|
||||
json!([{"symbol": ""}]),
|
||||
json!([{"symbol": "Mark", "face": "side"}]),
|
||||
json!([{"symbol": "Mark", "face": "top"}]),
|
||||
json!([{"symbol": "Mark", "scale": 0.0}]),
|
||||
json!([{"symbol": "Mark", "rotation": 400.0}]),
|
||||
json!([{"symbol": "Mark", "x": "1"}]),
|
||||
@@ -546,10 +547,12 @@ fn graphics_are_checked() {
|
||||
assert!(check(EXTRUDE, bad.clone()).is_err(), "{bad}");
|
||||
}
|
||||
assert!(check(ROTATE, json!([{"symbol": "Mark", "face": "back"}])).is_err());
|
||||
assert!(check(ROTATE, json!([{"symbol": "Mark", "face": "side"}])).is_err());
|
||||
assert!(check(INFLATE, json!([{"symbol": "Mark"}])).is_err());
|
||||
// Revolve takes graphics on its side, named the front; Revolve (Classic) takes none.
|
||||
assert!(validate_three_d_params(crate::REVOLVE, &json!({"graphics": [{"symbol": "Mark"}]})).is_ok());
|
||||
assert!(validate_three_d_params(crate::REVOLVE, &json!({"graphics": [{"symbol": "Mark", "face": "back"}]})).is_err());
|
||||
assert!(validate_three_d_params(crate::REVOLVE, &json!({"graphics": [{"symbol": "Mark", "face": "side"}]})).is_err());
|
||||
assert!(validate_three_d_params(crate::CLASSIC_REVOLVE, &json!({"graphics": [{"symbol": "Mark"}]})).is_err());
|
||||
// A loaded file's invalid entries are left out when drawn.
|
||||
assert_eq!(mapped_graphics(&json!({"graphics": [{"symbol": "Mark"}, {"face": "back"}, 3]})).len(), 1);
|
||||
@@ -569,10 +572,13 @@ fn the_frame_at_an_index_is_that_effects() {
|
||||
|
||||
#[test]
|
||||
fn a_change_to_a_plane_drops_the_back_caps_graphics() {
|
||||
let p = json!({"graphics": [{"symbol": "Mark", "face": "front"}, {"symbol": "Mark", "face": "back"}]});
|
||||
let p = json!({"graphics": [{"symbol": "Mark", "face": "front"}, {"symbol": "Mark", "face": "back"}, {"symbol": "Mark", "face": "side"}]});
|
||||
let plane = three_d_params_as(EXTRUDE, &p, ROTATE);
|
||||
assert_eq!(plane["graphics"], json!([{"symbol": "Mark", "face": "front"}]));
|
||||
assert!(validate_three_d_params(ROTATE, &plane).is_ok());
|
||||
// Revolve drops the side's graphics too; Extrude & Bevel keeps every face's.
|
||||
assert_eq!(three_d_params_as(EXTRUDE, &p, crate::REVOLVE)["graphics"], json!([{"symbol": "Mark", "face": "front"}]));
|
||||
assert_eq!(three_d_params_as(EXTRUDE, &p, EXTRUDE)["graphics"], p["graphics"]);
|
||||
// Back to Extrude & Bevel, the front's graphic stays.
|
||||
assert_eq!(three_d_params_as(ROTATE, &plane, EXTRUDE)["graphics"], plane["graphics"]);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,255 @@
|
||||
//! Graphics on Extrude & Bevel's side: its walls and bevels unrolled flat.
|
||||
|
||||
use serde_json::json;
|
||||
use vectorcraft_doc::color::Color;
|
||||
use vectorcraft_doc::{StrokeLayer, Symbol};
|
||||
use vectorcraft_geom::shapes;
|
||||
|
||||
use super::super::{EXTRUDE, graphic_frame, graphic_side_size, solid_art_in, validate_three_d_in};
|
||||
use super::*;
|
||||
|
||||
fn red() -> Color {
|
||||
Color::rgb(1.0, 0.0, 0.0)
|
||||
}
|
||||
|
||||
fn square(id: u64, r: Rect, paint: Paint) -> Node {
|
||||
Node::path(NodeId(id), shapes::rectangle(r), Appearance::basic(paint, Paint::None, 0.0))
|
||||
}
|
||||
|
||||
/// A document with symbol "Mark": a red 10 × 10 square.
|
||||
fn document() -> Document {
|
||||
let mut d = Document::new(1000.0, 1000.0);
|
||||
d.symbols.push(Symbol {
|
||||
dynamic: false,
|
||||
name: "Mark".into(),
|
||||
art: Arc::new(square(0, Rect::new(500.0, 500.0, 510.0, 510.0), Paint::solid(red()))),
|
||||
});
|
||||
d
|
||||
}
|
||||
|
||||
/// A gray 100 × 100 square at (0, 0), extruded 50 pt, seen from above (its top wall faces the
|
||||
/// viewer, its front edge at the bottom of the page), with `params` over that.
|
||||
fn object(params: Value) -> Node {
|
||||
let mut p = json!({"rotationX": -90.0, "rotationY": 0.0, "rotationZ": 0.0, "shade": false});
|
||||
if let (Some(p), Some(extra)) = (p.as_object_mut(), params.as_object()) {
|
||||
p.extend(extra.clone());
|
||||
}
|
||||
let mut n = square(7, Rect::new(0.0, 0.0, 100.0, 100.0), Paint::solid(Color::rgb(0.5, 0.5, 0.5)));
|
||||
n.appearance.effects.push(crate::new_effect(EXTRUDE, &p).unwrap());
|
||||
n
|
||||
}
|
||||
|
||||
fn is_red(p: &Paint) -> bool {
|
||||
p.color().is_some_and(|c| c.to_rgb()[0] > 0.3 && c.to_rgb()[1] < 0.1)
|
||||
}
|
||||
|
||||
/// The groups of a face and the parts of the side's graphics drawn on it, each part's outline.
|
||||
fn faces_with_parts(art: &Node) -> Vec<Vec<PathData>> {
|
||||
let mut out = vec![];
|
||||
art.walk(&mut |n| {
|
||||
if let NodeKind::Group { children, clip: false } = &n.kind
|
||||
&& let Some((face, parts)) = children.split_first()
|
||||
&& matches!(face.kind, NodeKind::Path { .. })
|
||||
&& !parts.is_empty()
|
||||
{
|
||||
let red: Vec<PathData> = parts
|
||||
.iter()
|
||||
.filter(|p| p.appearance.items.iter().any(|i| matches!(i, AppearanceItem::Fill(f) if is_red(&f.paint))))
|
||||
.filter_map(|p| p.path_data().cloned())
|
||||
.collect();
|
||||
if red.len() == parts.len() {
|
||||
out.push(red);
|
||||
}
|
||||
}
|
||||
});
|
||||
out
|
||||
}
|
||||
|
||||
fn bounds(parts: &[Vec<PathData>]) -> Rect {
|
||||
parts.iter().flatten().filter_map(PathData::bounds).reduce(|a, b| a.union(b)).unwrap()
|
||||
}
|
||||
|
||||
fn near(a: Rect, b: Rect) -> bool {
|
||||
[(a.x0, b.x0), (a.y0, b.y0), (a.x1, b.x1), (a.y1, b.y1)].iter().all(|(p, q)| (p - q).abs() < 1e-6)
|
||||
}
|
||||
|
||||
/// x runs along the outline from the top's middle, clockwise as the front is seen, and y from the
|
||||
/// middle of the side toward the back.
|
||||
#[test]
|
||||
fn a_side_graphic_lies_on_the_wall_at_its_offset() {
|
||||
let d = document();
|
||||
let n = object(json!({"graphics": [{"symbol": "Mark", "face": "side"}]}));
|
||||
let art = solid_art_in(Some(&d), &n).unwrap();
|
||||
let found = faces_with_parts(&art);
|
||||
assert_eq!(found.len(), 1, "drawn once, on the top wall");
|
||||
// Seen from above, the top wall runs from its front edge (page y 75) to its back (page y 25).
|
||||
assert!(near(bounds(&found), Rect::new(45.0, 45.0, 55.0, 55.0)), "{:?}", bounds(&found));
|
||||
let moved = object(json!({"graphics": [{"symbol": "Mark", "face": "side", "x": 20.0, "y": 10.0, "scale": 200.0}]}));
|
||||
let found = faces_with_parts(&solid_art_in(Some(&d), &moved).unwrap());
|
||||
assert!(near(bounds(&found), Rect::new(60.0, 30.0, 80.0, 50.0)), "{:?}", bounds(&found));
|
||||
// Without the document nothing is drawn; a graphic on the side leaves the caps without one.
|
||||
assert!(faces_with_parts(&solid_art_in(None, &n).unwrap()).is_empty());
|
||||
}
|
||||
|
||||
/// A graphic that reaches past a corner runs on around it onto the next wall.
|
||||
#[test]
|
||||
fn a_side_graphic_runs_around_a_corner() {
|
||||
let d = document();
|
||||
// x = 50 is the top's right end.
|
||||
let from_above = object(json!({"graphics": [{"symbol": "Mark", "face": "side", "x": 50.0}]}));
|
||||
let found = faces_with_parts(&solid_art_in(Some(&d), &from_above).unwrap());
|
||||
assert!(near(bounds(&found), Rect::new(95.0, 45.0, 100.0, 55.0)), "only the top's part shows: {:?}", bounds(&found));
|
||||
// Turned to show the top and the right, both walls draw their part.
|
||||
let turned = object(json!({"rotationX": -30.0, "rotationY": -40.0, "graphics": [{"symbol": "Mark", "face": "side", "x": 50.0}]}));
|
||||
assert_eq!(faces_with_parts(&solid_art_in(Some(&d), &turned).unwrap()).len(), 2);
|
||||
// Twist and taper carry the graphic; it stays on the side.
|
||||
let twisted =
|
||||
object(json!({"rotationX": -30.0, "rotationY": -40.0, "twist": 60.0, "taper": 50.0, "graphics": [{"symbol": "Mark", "face": "side"}]}));
|
||||
let found = faces_with_parts(&solid_art_in(Some(&d), &twisted).unwrap());
|
||||
assert!(!found.is_empty() && found.iter().flatten().all(|p| p.bounds().is_some_and(|b| [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.is_finite()))));
|
||||
}
|
||||
|
||||
/// The handle lands where the graphic's center is on the visible side, and a page point there
|
||||
/// gives back its offset; a graphic on a hidden wall has no handle.
|
||||
#[test]
|
||||
fn the_sides_handle_moves_the_graphic_on_its_visible_part() {
|
||||
let d = document();
|
||||
let g = MappedGraphic::from_value(&json!({"symbol": "Mark", "face": "side", "x": 10.0, "y": -5.0})).unwrap();
|
||||
let n = object(json!({"graphics": [g.to_value()]}));
|
||||
let frame = graphic_frame(Some(&d), &n, None).unwrap();
|
||||
let (at, visible) = frame.handle(&g).unwrap();
|
||||
assert!(visible && at.distance(Point::new(60.0, 55.0)) < 1e-6, "{at:?}");
|
||||
let (x, y) = frame.offset_at(PlanarFace::Side, Point::new(40.0, 45.0)).unwrap();
|
||||
assert!((x + 10.0).abs() < 1e-6 && (y - 5.0).abs() < 1e-6, "{x} {y}");
|
||||
// The bottom's middle, half way around, is hidden from above; so is a page point off the top.
|
||||
let hidden = MappedGraphic { x: 200.0, ..g.clone() };
|
||||
assert!(frame.handle(&hidden).is_none());
|
||||
assert!(frame.offset_at(PlanarFace::Side, Point::new(50.0, 90.0)).is_none());
|
||||
// Without a graphic on the side, the frame places no handle there.
|
||||
let caps = graphic_frame(Some(&d), &object(json!({"graphics": [{"symbol": "Mark"}]})), None).unwrap();
|
||||
assert!(caps.handle(&g).is_none());
|
||||
}
|
||||
|
||||
/// On a curved wall, whose pieces are cut to its curved outline, the handle sits on the graphic's
|
||||
/// center and a page point there gives back its offset.
|
||||
#[test]
|
||||
fn the_handle_follows_a_curved_side() {
|
||||
let d = document();
|
||||
let g = MappedGraphic::from_value(&json!({"symbol": "Mark", "face": "side", "x": 6.0, "y": 3.0})).unwrap();
|
||||
let mut n = object(json!({"rotationX": -60.0, "graphics": [g.to_value()]}));
|
||||
if let NodeKind::Path { path, .. } = &mut n.kind {
|
||||
*path = shapes::ellipse(Rect::new(0.0, 0.0, 100.0, 100.0));
|
||||
}
|
||||
let frame = graphic_frame(Some(&d), &n, None).unwrap();
|
||||
let (at, visible) = frame.handle(&g).unwrap();
|
||||
assert!(visible);
|
||||
let (x, y) = frame.offset_at(PlanarFace::Side, at).unwrap();
|
||||
assert!((x - 6.0).abs() < 1e-6 && (y - 3.0).abs() < 1e-6, "{x} {y}");
|
||||
}
|
||||
|
||||
/// A hollow object has no caps but takes graphics on its side; a stroke's solid, whose outline is
|
||||
/// the longest, takes them once.
|
||||
#[test]
|
||||
fn a_hollow_or_stroked_object_takes_a_side_graphic() {
|
||||
let d = document();
|
||||
let hollow = object(json!({"cap": false, "graphics": [{"symbol": "Mark", "face": "side"}, {"symbol": "Mark"}]}));
|
||||
let art = solid_art_in(Some(&d), &hollow).unwrap();
|
||||
assert!(near(bounds(&faces_with_parts(&art)), Rect::new(45.0, 45.0, 55.0, 55.0)));
|
||||
let mut stroked = object(json!({"graphics": [{"symbol": "Mark", "face": "side"}]}));
|
||||
stroked.appearance.items.push(AppearanceItem::Stroke(StrokeLayer::new(Paint::solid(Color::rgb(0.2, 0.2, 0.2)), 10.0)));
|
||||
let found = faces_with_parts(&solid_art_in(Some(&d), &stroked).unwrap());
|
||||
assert_eq!(found.len(), 1, "on the stroke's outer wall only");
|
||||
assert!(near(bounds(&found), Rect::new(45.0, 45.0, 55.0, 55.0)), "{:?}", bounds(&found));
|
||||
// The stroke's outer outline is 440 pt long, cut at a bottom corner 165 pt each way from the
|
||||
// top's middle: a new graphic fits the 330 pt about x = 0 and the depth.
|
||||
assert_eq!(graphic_side_size(Some(&d), &stroked, None, 0), Some((330.0, 50.0)));
|
||||
}
|
||||
|
||||
/// A stroke's face cut where it passes through a wall keeps the whole face's place on the side, and
|
||||
/// each piece draws only the part of the graphic within its own outline.
|
||||
#[test]
|
||||
fn a_piece_cut_from_a_face_draws_its_own_part() {
|
||||
let d = document();
|
||||
let facet = |x: f64, normal: [f64; 3], offset: f64| {
|
||||
let square = vec![Point::new(x, 0.0), Point::new(x + 10.0, 0.0), Point::new(x + 10.0, 10.0), Point::new(x, 10.0)];
|
||||
let uv = square.iter().map(|p| Point::new(p.x - x, p.y)).collect();
|
||||
Facet {
|
||||
contours: vec![square.clone()],
|
||||
depth: 0.0,
|
||||
brightness: 1.0,
|
||||
illumination: [1.0; 3],
|
||||
normal,
|
||||
rgb_gradient: None,
|
||||
outline: None,
|
||||
side: true,
|
||||
away: false,
|
||||
end: None,
|
||||
surface: Some(vectorcraft_three_d::SurfaceCell { page: square, uv, outward: true }),
|
||||
plane: Some(vectorcraft_three_d::DepthPlane { normal, offset, center: Point::ZERO, eye: None }),
|
||||
}
|
||||
};
|
||||
let wall = facet(0.0, [0.0, 0.0, 1.0], 0.0);
|
||||
// z = x - 8: behind the wall left of x = 8, in front of it right of it.
|
||||
let r = std::f64::consts::FRAC_1_SQRT_2;
|
||||
let mut stroke = vec![facet(5.0, [-r, 0.0, r], -8.0 * r)];
|
||||
super::super::cut_through(std::slice::from_ref(&wall), &mut stroke, &mut 10, &mut 0);
|
||||
assert_eq!(stroke.len(), 2, "cut where it passes through the wall");
|
||||
// The graphic covers the whole face, x 5 to 15 on the page.
|
||||
let graphics = mapped_graphics(&json!({"graphics": [{"symbol": "Mark", "face": "side", "x": 5.0, "y": 5.0}]}));
|
||||
let shade = |_: &Facet, c: Color| Paint::solid(c);
|
||||
let parts = surface_parts(Some(&d), NodeId(0), (&graphics, PlanarFace::Side), &stroke, &shade, &mut 0).unwrap();
|
||||
let drawn: Vec<Rect> =
|
||||
parts.iter().map(|on| on.iter().filter_map(|n| n.path_data().and_then(PathData::bounds)).reduce(|a, b| a.union(b)).unwrap()).collect();
|
||||
// Each piece draws its own side of x = 8 (where the wall cuts it), together the whole graphic.
|
||||
let (left, right) = (drawn[0].x0.min(drawn[1].x0), drawn[0].x1.max(drawn[1].x1));
|
||||
assert!((left - 5.0).abs() < 1e-6 && (right - 15.0).abs() < 1e-6, "{drawn:?}");
|
||||
assert!(drawn.iter().all(|b| (b.x0 - 8.0).abs() < 1e-6 || (b.x1 - 8.0).abs() < 1e-6), "{drawn:?}");
|
||||
}
|
||||
|
||||
/// Commands refuse a side graphic whose curves, cut into straight pieces on the side, pass the
|
||||
/// limit of points, though its own path elements are few; on a cap it is accepted.
|
||||
#[test]
|
||||
fn a_side_graphic_past_its_limits_is_refused() {
|
||||
let mut d = document();
|
||||
// 200 circles 200,000 pt across: a few elements each, hundreds of thousands of points cut.
|
||||
let mut subpaths = vec![];
|
||||
for k in 0..200 {
|
||||
let x = f64::from(k);
|
||||
subpaths.extend(shapes::ellipse(Rect::new(x, 0.0, x + 2e5, 2e5)).subpaths);
|
||||
}
|
||||
let rings = Node::path(NodeId(0), PathData::new(subpaths), Appearance::basic(Paint::solid(red()), Paint::None, 0.0));
|
||||
d.symbols.push(Symbol { dynamic: false, name: "Rings".into(), art: Arc::new(rings) });
|
||||
let n = object(json!({}));
|
||||
let side = json!({"rotationX": -90.0, "graphics": [{"symbol": "Rings", "face": "side"}]});
|
||||
assert!(validate_three_d_in(Some(&d), &n, EXTRUDE, &side).is_err());
|
||||
assert!(validate_three_d_in(Some(&d), &n, EXTRUDE, &json!({"rotationX": -90.0, "graphics": [{"symbol": "Rings"}]})).is_ok());
|
||||
assert!(validate_three_d_in(Some(&d), &n, EXTRUDE, &json!({"graphics": [{"symbol": "Mark", "face": "side"}]})).is_ok());
|
||||
}
|
||||
|
||||
/// With the shadow on, the solid that carries the side's graphics is built once, for both its faces
|
||||
/// and its shadow: the graphic keeps its place on the wall, and the shadow is the one the object
|
||||
/// casts without a graphic.
|
||||
#[test]
|
||||
fn a_side_graphic_keeps_its_place_with_the_shadow_on() {
|
||||
let d = document();
|
||||
let shadow = |art: &Node| {
|
||||
let first = &art.children().unwrap()[0];
|
||||
let [AppearanceItem::Fill(fill)] = first.appearance.items.as_slice() else { panic!("no shadow first: {first:?}") };
|
||||
assert!(fill.paint.color() == Some(Color::BLACK) && (fill.opacity - 0.5).abs() < 1e-6, "{fill:?}");
|
||||
first.path_data().and_then(PathData::bounds).unwrap()
|
||||
};
|
||||
let lit = json!({"shade": true, "lightHeight": 90.0, "shadow": true, "shadowDistance": 50.0});
|
||||
let mut with_graphic = lit.clone();
|
||||
with_graphic["graphics"] = json!([{"symbol": "Mark", "face": "side"}]);
|
||||
let n = object(with_graphic);
|
||||
super::super::SOLID_GEOMETRY_BUILT.with(|b| b.set(0));
|
||||
super::super::SOLIDS_BUILT.with(|b| b.set(0));
|
||||
let art = solid_art_in(Some(&d), &n).unwrap();
|
||||
let builds = (super::super::SOLID_GEOMETRY_BUILT.with(std::cell::Cell::get), super::super::SOLIDS_BUILT.with(std::cell::Cell::get));
|
||||
assert_eq!(builds, (1, 1), "one build for the faces and the shadow");
|
||||
let found = faces_with_parts(&art);
|
||||
assert_eq!(found.len(), 1, "drawn once, on the top wall");
|
||||
assert!(near(bounds(&found), Rect::new(45.0, 45.0, 55.0, 55.0)), "{:?}", bounds(&found));
|
||||
let without = solid_art_in(Some(&d), &object(lit)).unwrap();
|
||||
assert!(near(shadow(&art), shadow(&without)), "{:?} {:?}", shadow(&art), shadow(&without));
|
||||
}
|
||||
@@ -379,7 +379,7 @@ fn a_stroke_left_out_of_the_art_casts_no_shadow() {
|
||||
let p = crate::merged_params(id, &json!({"shadow": true}));
|
||||
let (parts, bounds) = solid_parts(&shapes, union_bounds(&shapes).unwrap());
|
||||
let mut built: Vec<Option<SolidFaces>> =
|
||||
built_solids_cast(id, &p, &parts, bounds, MAX_OBJECT_FACES, true).map(|r| r.unwrap().and_then(|(_, faces)| faces)).collect();
|
||||
built_solids_cast(id, &p, &parts, bounds, MAX_OBJECT_FACES, true, None).map(|r| r.unwrap().and_then(|(_, faces)| faces)).collect();
|
||||
let stroke = parts.iter().position(|(item, ..)| matches!(item, AppearanceItem::Stroke(_))).unwrap();
|
||||
assert!(built.len() == 2 && built.iter().all(Option::is_some), "{id}");
|
||||
let (both, _, cast) = cast_built(id, &p, &shapes, built.clone()).unwrap().unwrap();
|
||||
|
||||
@@ -1708,6 +1708,115 @@ fn twist_joins_its_pieces_smoothly() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn twist_boundary_handles_follow_the_inward_tangent() {
|
||||
let line = PathData::single(SubPath::polyline(&[Point::new(40.0, 30.0), Point::new(60.0, 30.0)], false));
|
||||
let bounds = Rect::new(40.0, 30.0, 60.0, 30.0);
|
||||
for angle in [90.0_f64, 400.0, -720.0] {
|
||||
let out = apply_geometry(&[fx("distort.twist", json!({"angle": angle}))], &line, bounds);
|
||||
let anchors = &out.subpaths[0].anchors;
|
||||
let start = anchors.first().unwrap();
|
||||
let end = anchors.last().unwrap();
|
||||
assert_eq!(start.p, Point::new(40.0, 30.0));
|
||||
assert_eq!(end.p, Point::new(60.0, 30.0));
|
||||
for (actual, expected) in [
|
||||
(start.h_out - start.p, vectorcraft_geom::Vec2::new(1.0, -angle.to_radians())),
|
||||
(end.h_in - end.p, vectorcraft_geom::Vec2::new(-1.0, angle.to_radians())),
|
||||
] {
|
||||
assert!(actual.hypot() > 1e-9);
|
||||
let error = (actual.x * expected.y - actual.y * expected.x).atan2(actual.dot(expected)).to_degrees().abs();
|
||||
assert!(error < 0.05, "{angle} degrees: boundary tangent differs by {error} degrees");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn twist_large_coordinate_joins_preserve_boundary_sides() {
|
||||
use vectorcraft_geom::Anchor;
|
||||
|
||||
let center = 1e16;
|
||||
for offset in [32.0, 64.0] {
|
||||
let p = Point::new(center + offset, 0.0);
|
||||
let line = PathData::single(SubPath::new(
|
||||
vec![
|
||||
Anchor::corner(Point::new(p.x - 18.0, 0.0)),
|
||||
Anchor::with_handles(p, Point::new(p.x - 6.0, 0.0), Point::new(p.x + 6.0, 0.0)),
|
||||
Anchor::corner(Point::new(p.x + 18.0, 0.0)),
|
||||
],
|
||||
false,
|
||||
));
|
||||
let out = crate::distort::twist(&line, Rect::new(center - 64.0, 0.0, center + 64.0, 0.0), 90.0, 3);
|
||||
let join = &out.subpaths[0].anchors[1];
|
||||
if offset == 64.0 {
|
||||
assert_eq!(join.h_out, Point::new(p.x + 6.0, 0.0));
|
||||
let actual = join.h_in - join.p;
|
||||
let expected = vectorcraft_geom::Vec2::new(-1.0, std::f64::consts::FRAC_PI_2);
|
||||
let error = actual.cross(expected).atan2(actual.dot(expected)).abs();
|
||||
assert!(error < 1e-9, "{actual:?}");
|
||||
} else {
|
||||
let incoming = join.p - join.h_in;
|
||||
let outgoing = join.h_out - join.p;
|
||||
assert!(incoming.cross(outgoing).abs() < 1e-9, "{incoming:?} {outgoing:?}");
|
||||
assert!(incoming.dot(outgoing) > 0.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn twist_fractional_boundary_handles_use_each_sides_derivative() {
|
||||
use vectorcraft_geom::Anchor;
|
||||
|
||||
for (bounds, step) in [(Rect::new(40.1, 30.0, 60.3, 30.0), 1.0), (Rect::new(-60.3, 30.0, -40.1, 30.0), 1.0)] {
|
||||
for x in [bounds.x0, bounds.x1] {
|
||||
for angle in [90.0_f64, 400.0, -720.0] {
|
||||
let p = Point::new(x, 30.0);
|
||||
let line = PathData::single(SubPath::new(
|
||||
vec![
|
||||
Anchor::corner(Point::new(x - 3.0 * step, 30.0)),
|
||||
Anchor::with_handles(p, Point::new(x - step, 30.0), Point::new(x + step, 30.0)),
|
||||
Anchor::corner(Point::new(x + 3.0 * step, 30.0)),
|
||||
],
|
||||
false,
|
||||
));
|
||||
let out = crate::distort::twist(&line, bounds, angle, 3);
|
||||
assert!(
|
||||
out.subpaths[0].anchors.iter().all(|a| a.p.is_finite() && a.h_in.is_finite() && a.h_out.is_finite()),
|
||||
"x={x} angle={angle}: {:?}",
|
||||
out.subpaths[0].anchors
|
||||
);
|
||||
let join = &out.subpaths[0].anchors[1];
|
||||
assert!(join.p.distance(p) < 1e-10, "{:?}", join.p);
|
||||
let a = angle.to_radians();
|
||||
let expected = if x == bounds.x0 { [(-1.0, 0.0), (1.0, -a)] } else { [(-1.0, a), (1.0, 0.0)] };
|
||||
for (actual, (dx, dy)) in [join.h_in - join.p, join.h_out - join.p].into_iter().zip(expected) {
|
||||
let expected = vectorcraft_geom::Vec2::new(dx, dy);
|
||||
let error = actual.cross(expected).atan2(actual.dot(expected)).abs();
|
||||
assert!(error < 1e-9, "x={x} angle={angle}: {actual:?}, join={join:?}, source={:?}", line.subpaths[0].anchors[1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let bounds = Rect::new(1e16, 30.0, 1e16 + 18.0, 30.0);
|
||||
let center = bounds.center();
|
||||
let line = PathData::single(SubPath::polyline(&[Point::new(center.x - 4.0, center.y), center, Point::new(center.x + 4.0, center.y)], false));
|
||||
let out = crate::distort::twist(&line, bounds, 90.0, 3);
|
||||
assert_eq!(out.subpaths[0].anchors[1].p, center);
|
||||
let bounds = Rect::new(0.0, 30.0, 2e16, 30.0);
|
||||
let p = Point::new(bounds.x1 - 8.0, 30.0);
|
||||
let line = PathData::single(SubPath::new(
|
||||
vec![
|
||||
Anchor::corner(Point::new(p.x - 12.0, p.y)),
|
||||
Anchor::with_handles(p, Point::new(p.x - 4.0, p.y), Point::new(p.x + 4.0, p.y)),
|
||||
Anchor::corner(Point::new(p.x + 12.0, p.y)),
|
||||
],
|
||||
false,
|
||||
));
|
||||
let out = crate::distort::twist(&line, bounds, 90.0, 3);
|
||||
let join = &out.subpaths[0].anchors[1];
|
||||
assert!(join.p.y - p.y > 10.0, "{:?}", join.p);
|
||||
assert!(join.h_out.y - join.p.y < -4.0, "{join:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn twist_fixes_the_outer_circle_and_rotates_inside() {
|
||||
let out = run("distort.twist", json!({"angle": 0}), &square());
|
||||
|
||||
@@ -543,3 +543,337 @@ fn raster_and_hidden_effects_leave_the_clip_as_it_is() {
|
||||
assert_eq!(bounds(&clipping_path(1, effects)), Rect::new(50.0, 50.0, 150.0, 150.0));
|
||||
}
|
||||
}
|
||||
|
||||
fn blue() -> Paint {
|
||||
Paint::solid(Color::rgb(0.0, 0.0, 1.0))
|
||||
}
|
||||
|
||||
fn green() -> Paint {
|
||||
Paint::solid(Color::rgb(0.0, 1.0, 0.0))
|
||||
}
|
||||
|
||||
/// "IIII" at 40 pt from (5, 60) in a test font built from the bundled Source Sans 3
|
||||
/// ([`vectorcraft_text::test_fonts::height_font`]), its characters filled blue when `fill` and
|
||||
/// stroked green 2 pt wide when `stroke`.
|
||||
fn painted_type(id: u64, fill: bool, stroke: bool) -> Node {
|
||||
use vectorcraft_doc::text::{CharStyle, TextObject};
|
||||
use vectorcraft_text::test_fonts::{HEIGHT_FAMILY, height_font};
|
||||
static FONT: std::sync::Once = std::sync::Once::new();
|
||||
FONT.call_once(|| {
|
||||
vectorcraft_text::FontDb::global().add_font(height_font(true).expect("the test font builds"));
|
||||
});
|
||||
let style = CharStyle {
|
||||
font_family: HEIGHT_FAMILY.into(),
|
||||
size: 40.0,
|
||||
fill: if fill { blue() } else { Paint::None },
|
||||
stroke: if stroke { green() } else { Paint::None },
|
||||
stroke_width: 2.0,
|
||||
..Default::default()
|
||||
};
|
||||
Node::new(NodeId(id), NodeKind::Text(Box::new(TextObject::point(vectorcraft_geom::Point::new(5.0, 60.0), "IIII", style))))
|
||||
}
|
||||
|
||||
/// Does `n` or an object in it have a blue fill (`fill`) or a green stroke?
|
||||
fn paints(n: &Node, fill: bool) -> bool {
|
||||
use vectorcraft_doc::AppearanceItem;
|
||||
let own = n.appearance.items.iter().any(|i| match i {
|
||||
AppearanceItem::Fill(f) => fill && f.paint == blue(),
|
||||
AppearanceItem::Stroke(s) => !fill && s.paint == green() && s.width > 0.0,
|
||||
});
|
||||
own || n.children().into_iter().flatten().any(|c| paints(c, fill))
|
||||
}
|
||||
|
||||
/// What the first clip group in `n` paints: the bounds of the region it clips to, the bounds of
|
||||
/// the blue fill art right after its clipping path (behind the clipped art), the bounds of the
|
||||
/// green stroke art right after the clip group (over it, outside the clip), and whether a green
|
||||
/// stroke paints inside the clip group.
|
||||
type Painted = (Rect, Option<Rect>, Option<Rect>, bool);
|
||||
|
||||
fn painted_clip(n: &Node) -> Option<Painted> {
|
||||
let ch = n.children()?;
|
||||
for (i, c) in ch.iter().enumerate() {
|
||||
if let NodeKind::Group { children, clip: true } = &c.kind {
|
||||
let region = clip_outline(children.first()?)?.0.bounding_box();
|
||||
let fill = children.get(1).filter(|f| paints(f, true)).and_then(|f| f.geometric_bounds());
|
||||
let stroke = ch.get(i + 1).filter(|s| paints(s, false)).and_then(|s| s.geometric_bounds());
|
||||
let inside = children.iter().skip(1).any(|m| paints(m, false));
|
||||
return Some((region, fill, stroke, inside));
|
||||
}
|
||||
if let Some(found) = painted_clip(c) {
|
||||
return Some(found);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn near_rect(a: Rect, b: Rect) -> bool {
|
||||
(a.x0 - b.x0).abs() < 0.5 && (a.y0 - b.y0).abs() < 0.5 && (a.x1 - b.x1).abs() < 0.5 && (a.y1 - b.y1).abs() < 0.5
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn painted_clipping_type_survives_enclosing_geometry_effect() {
|
||||
// Type that paints a fill, a stroke, both or neither clips a red square, in a group whose
|
||||
// Transform (moving everything 10 pt down, beside other type that stays type in the export) or
|
||||
// Offset Path reshapes its members: the canvas and the export keep the type's fill as art
|
||||
// behind the square inside the clip and its stroke as art over the clip group, both reshaped
|
||||
// with the clip.
|
||||
let plain = clip_outline(&painted_type(3, false, false)).expect("the type clips").0.bounding_box();
|
||||
assert!(plain.width() > 10.0 && plain.height() > 10.0, "the type has glyph outlines: {plain:?}");
|
||||
let effects = [fx("distort.transform", json!({"moveV": 10})), fx("path.offsetPath", json!({"offset": 1}))];
|
||||
for effect in effects {
|
||||
for (fill, stroke) in [(true, false), (false, true), (true, true), (false, false)] {
|
||||
let clipped = clip_group(2, painted_type(3, fill, stroke));
|
||||
let mut outer = Node::group(NodeId(1), vec![Arc::new(clipped), Arc::new(painted_type(5, true, false))]);
|
||||
outer.appearance.effects.push(effect.clone());
|
||||
let canvas = crate::evaluate_container(None, &outer).unwrap();
|
||||
let mut d = Document::new(400.0, 400.0);
|
||||
let layer = d.layers[0].id;
|
||||
d.insert(Some(layer), 0, outer).unwrap();
|
||||
let baked = bake_document(&d).unwrap();
|
||||
let exported = baked.layers.iter().find_map(|l| painted_clip(l));
|
||||
for (what, found) in [("canvas", painted_clip(&canvas)), ("export", exported)] {
|
||||
let case = format!("{what}, {}, fill {fill}, stroke {stroke}", effect.id);
|
||||
let (region, fills, strokes, inside) = found.unwrap_or_else(|| panic!("{case}: no clip group"));
|
||||
if effect.id == "distort.transform" {
|
||||
assert!((region.y0 - plain.y0 - 10.0).abs() < 0.5 && (region.x0 - plain.x0).abs() < 0.5, "{case}: {region:?} from {plain:?}");
|
||||
} else {
|
||||
let grown = Rect::new(plain.x0 - 1.0, plain.y0 - 1.0, plain.x1 + 1.0, plain.y1 + 1.0);
|
||||
assert!(near_rect(region, grown), "{case}: {region:?} is {plain:?} offset by 1 pt");
|
||||
}
|
||||
assert_eq!(fills.is_some(), fill, "{case}: fill art {fills:?}");
|
||||
assert_eq!(strokes.is_some(), stroke, "{case}: stroke art {strokes:?}");
|
||||
assert!(!inside, "{case}: the stroke paints outside the clip");
|
||||
for art in fills.into_iter().chain(strokes) {
|
||||
assert!(near_rect(art, region), "{case}: the paint {art:?} follows the clip {region:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The group in `n` that holds a clip group and then the green stroke art of its clipping type,
|
||||
/// with that clip group.
|
||||
fn stroke_wrapper(n: &Node) -> Option<(&Node, &Node)> {
|
||||
let ch = n.children()?;
|
||||
if let [inner, stroke, ..] = ch.as_slice()
|
||||
&& matches!(inner.kind, NodeKind::Group { clip: true, .. })
|
||||
&& !n.clips()
|
||||
&& paints(stroke, false)
|
||||
{
|
||||
return Some((n, inner));
|
||||
}
|
||||
ch.iter().find_map(|c| stroke_wrapper(c))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clipping_type_strokes_paint_over_a_knockout_clip_group() {
|
||||
// A clip group set to Knockout Group On, Off or neutral, clipped by type that strokes: its
|
||||
// clipped art knocks out as the clip group says, and the type's stroke paints over it without
|
||||
// knocking it out, as the canvas draws the live clip group. The type is reshaped by a group's
|
||||
// Transform around it, or by its own Offset Path.
|
||||
use vectorcraft_doc::Knockout;
|
||||
for (knockout, around) in [(Knockout::On, Knockout::Off), (Knockout::Off, Knockout::Off), (Knockout::Neutral, Knockout::Neutral)] {
|
||||
for own in [false, true] {
|
||||
let mut ty = painted_type(3, true, true);
|
||||
if own {
|
||||
ty.appearance.effects.push(fx("path.offsetPath", json!({"offset": 1})));
|
||||
}
|
||||
let mut clipped = clip_group(2, ty);
|
||||
clipped.knockout = knockout;
|
||||
let mut outer = Node::group(NodeId(1), vec![Arc::new(clipped)]);
|
||||
if !own {
|
||||
outer.appearance.effects.push(fx("distort.transform", json!({"moveV": 10})));
|
||||
}
|
||||
let mut d = Document::new(400.0, 400.0);
|
||||
let layer = d.layers[0].id;
|
||||
d.insert(Some(layer), 0, outer.clone()).unwrap();
|
||||
let baked = bake_document(&d).unwrap();
|
||||
let canvas = if own { None } else { crate::evaluate_container(None, &outer) };
|
||||
let exported = baked.layers.iter().find_map(|l| stroke_wrapper(l));
|
||||
for (what, found) in [("canvas", canvas.as_ref().and_then(stroke_wrapper)), ("export", exported)] {
|
||||
if own && what == "canvas" {
|
||||
continue;
|
||||
}
|
||||
let case = format!("{what}, own effect {own}, knockout {knockout:?}");
|
||||
let (wrapper, inner) = found.unwrap_or_else(|| panic!("{case}: no group around the clip"));
|
||||
assert_eq!(inner.knockout, knockout, "{case}: the clipped art knocks out as before");
|
||||
assert_eq!(wrapper.knockout, around, "{case}: the stroke does not knock out the clipped art");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_clip_groups_own_fill_stays_in_the_clip_when_its_clipping_type_strokes() {
|
||||
// A clip group with a yellow fill of its own and an Offset Path effect, clipped by type that
|
||||
// strokes: the group's fill still paints inside the clip, and the type's stroke over it.
|
||||
let yellow = Paint::solid(Color::rgb(1.0, 1.0, 0.0));
|
||||
let mut group = clip_group(2, painted_type(3, false, true));
|
||||
group.appearance =
|
||||
Appearance { effects: vec![fx("path.offsetPath", json!({"offset": 0}))], ..Appearance::basic(yellow.clone(), Paint::None, 0.0) }.into();
|
||||
let canvas = crate::evaluate_container(None, &group).unwrap();
|
||||
let (_, _, strokes, inside) = painted_clip(&Node::group(NodeId(9), vec![Arc::new(canvas.clone())])).unwrap();
|
||||
assert!(strokes.is_some() && !inside, "{canvas:?}");
|
||||
let NodeKind::Group { children, clip: false } = &canvas.kind else { panic!("not a group around the clip: {canvas:?}") };
|
||||
let NodeKind::Group { children: clipped, clip: true } = &children[0].kind else { panic!("no clip group first: {children:?}") };
|
||||
let yellow_in = |n: &Node| n.appearance.items.iter().any(|i| matches!(i, vectorcraft_doc::AppearanceItem::Fill(f) if f.paint == yellow));
|
||||
assert!(clipped.iter().skip(1).any(|c| yellow_in(c)), "the group's fill paints inside the clip: {clipped:?}");
|
||||
assert!(!children.iter().skip(1).any(|c| yellow_in(c)), "{children:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_clip_groups_own_gradient_spans_the_clip_when_its_clipping_type_strokes() {
|
||||
// A clip group with an unplaced linear gradient fill of its own and an Offset Path effect,
|
||||
// clipped by type with a stroke whose Transform effect moves it 60 pt right: the gradient
|
||||
// spans the region the clipping path clips to.
|
||||
use vectorcraft_color::{Gradient, GradientKind, GradientPaint, GradientStop};
|
||||
let stops = vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(1.0, Color::WHITE)];
|
||||
let unplaced = Paint::Gradient(Box::new(GradientPaint::new(Gradient::new(GradientKind::Linear, stops))));
|
||||
let mut ty = painted_type(3, false, false);
|
||||
ty.appearance = Appearance::basic(Paint::None, green(), 2.0).into();
|
||||
for item in &mut ty.appearance.items {
|
||||
if let vectorcraft_doc::AppearanceItem::Stroke(s) = item {
|
||||
s.effects.push(fx("distort.transform", json!({"moveH": 60})));
|
||||
}
|
||||
}
|
||||
let mut group = clip_group(2, ty);
|
||||
group.appearance =
|
||||
Appearance { effects: vec![fx("path.offsetPath", json!({"offset": 0}))], ..Appearance::basic(unplaced, Paint::None, 0.0) }.into();
|
||||
let canvas = crate::evaluate_container(None, &group).unwrap();
|
||||
let NodeKind::Group { children, clip: false } = &canvas.kind else { panic!("not a group around the clip: {canvas:?}") };
|
||||
let NodeKind::Group { children: clipped, clip: true } = &children[0].kind else { panic!("no clip group first: {children:?}") };
|
||||
let region = clip_outline(&clipped[0]).expect("the type clips").0.bounding_box();
|
||||
let fill = clipped.iter().skip(1).find_map(|c| match c.appearance.fill_paint() {
|
||||
Paint::Gradient(g) => g.geom,
|
||||
_ => None,
|
||||
});
|
||||
let geom = fill.unwrap_or_else(|| panic!("no gradient fill inside the clip: {clipped:?}"));
|
||||
let (left, right) = (geom.start.x.min(geom.end.x), geom.start.x.max(geom.end.x));
|
||||
assert!((left - region.x0).abs() < 0.5 && (right - region.x1).abs() < 0.5, "the gradient {geom:?} spans the clip {region:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_groups_own_fill_paints_only_the_clip_of_clipping_type_whose_stroke_moves() {
|
||||
// A group with a fill of its own (solid, or an unplaced linear gradient) and a Transform effect
|
||||
// (moving everything 10 pt down, or scaling it to half its width around its middle) holds a
|
||||
// clip group clipped by type whose stroke has a Transform effect moving it 60 pt right,
|
||||
// outside the clip. On the canvas and in the export, the clip region is the type's glyphs
|
||||
// reshaped by the group's effect, and the group's fill paints that region alone, its gradient
|
||||
// spanning it: the moved stroke adds nothing to the region, the fill or the box the group's
|
||||
// effect scales around.
|
||||
use vectorcraft_color::{Gradient, GradientKind, GradientPaint, GradientStop};
|
||||
let yellow = Paint::solid(Color::rgb(1.0, 1.0, 0.0));
|
||||
let stops = vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(1.0, Color::WHITE)];
|
||||
let unplaced = Paint::Gradient(Box::new(GradientPaint::new(Gradient::new(GradientKind::Linear, stops))));
|
||||
let mut ty = painted_type(3, false, false);
|
||||
ty.appearance = Appearance::basic(Paint::None, green(), 2.0).into();
|
||||
for item in &mut ty.appearance.items {
|
||||
if let vectorcraft_doc::AppearanceItem::Stroke(s) = item {
|
||||
s.effects.push(fx("distort.transform", json!({"moveH": 60})));
|
||||
}
|
||||
}
|
||||
let live = clip_outline(&ty).expect("the type clips").0.bounding_box();
|
||||
let moved = Rect::new(live.x0, live.y0 + 10.0, live.x1, live.y1 + 10.0);
|
||||
// Scaled to half its width around the middle of the clip, which the stroke does not move.
|
||||
let (mid, quarter) = ((live.x0 + live.x1) / 2.0, live.width() / 4.0);
|
||||
let narrowed = Rect::new(mid - quarter, live.y0, mid + quarter, live.y1);
|
||||
// The group's own fill art: every object outside the clip groups whose own fill is `paint`.
|
||||
fn own_fills<'a>(n: &'a Node, paint: &Paint, out: &mut Vec<&'a Node>) {
|
||||
let mine = n.appearance.items.iter().any(|i| match (i, paint) {
|
||||
(vectorcraft_doc::AppearanceItem::Fill(f), Paint::Gradient(_)) => matches!(f.paint, Paint::Gradient(_)),
|
||||
(vectorcraft_doc::AppearanceItem::Fill(f), p) => f.paint == *p,
|
||||
_ => false,
|
||||
});
|
||||
if mine {
|
||||
out.push(n);
|
||||
}
|
||||
for c in n.children().into_iter().flatten().filter(|c| !c.clips()) {
|
||||
own_fills(c, paint, out);
|
||||
}
|
||||
}
|
||||
let cases = [(json!({"moveV": 10}), moved), (json!({"scaleH": 50, "scaleV": 100}), narrowed)];
|
||||
for ((params, region), paint) in cases.iter().flat_map(|c| [yellow.clone(), unplaced.clone()].map(|p| (c.clone(), p))) {
|
||||
let mut outer = Node::group(NodeId(1), vec![Arc::new(clip_group(2, ty.clone()))]);
|
||||
outer.appearance =
|
||||
Appearance { effects: vec![fx("distort.transform", params.clone())], ..Appearance::basic(paint.clone(), Paint::None, 0.0) }.into();
|
||||
let canvas = crate::evaluate_container(None, &outer).unwrap();
|
||||
let mut d = Document::new(400.0, 400.0);
|
||||
let layer = d.layers[0].id;
|
||||
d.insert(Some(layer), 0, outer).unwrap();
|
||||
let baked = bake_document(&d).unwrap();
|
||||
let exported = baked.layers[0].children().and_then(|ch| ch.first()).cloned().expect("the export holds the group");
|
||||
for (what, art) in [("canvas", &canvas), ("export", &*exported)] {
|
||||
let case = format!("{what}, {params}, {}", if matches!(paint, Paint::Gradient(_)) { "gradient" } else { "solid" });
|
||||
let (clip, _, strokes, _) = painted_clip(art).unwrap_or_else(|| panic!("{case}: no clip group in {art:?}"));
|
||||
assert!(near_rect(clip, region), "{case}: the clip {clip:?} is the type's glyphs reshaped {region:?}");
|
||||
let strokes = strokes.unwrap_or_else(|| panic!("{case}: no stroke art"));
|
||||
assert!(strokes.x1 > region.x1 + 25.0, "{case}: the stroke {strokes:?} moves outside the clip {region:?}");
|
||||
let mut fills = vec![];
|
||||
own_fills(art, &paint, &mut fills);
|
||||
assert!(!fills.is_empty(), "{case}: no fill art of the group in {art:?}");
|
||||
let painted = fills.iter().filter_map(|f| f.geometric_bounds()).reduce(|a, b| a.union(b)).unwrap();
|
||||
assert!(near_rect(painted, region), "{case}: the group's fill {painted:?} paints the clip {region:?}");
|
||||
if let Paint::Gradient(_) = paint {
|
||||
for fill in fills {
|
||||
let geom = match fill.appearance.fill_paint() {
|
||||
Paint::Gradient(g) => g.geom,
|
||||
_ => None,
|
||||
};
|
||||
let geom = geom.unwrap_or_else(|| panic!("{case}: the gradient is not placed: {fill:?}"));
|
||||
let (left, right) = (geom.start.x.min(geom.end.x), geom.start.x.max(geom.end.x));
|
||||
assert!(
|
||||
(left - region.x0).abs() < 0.5 && (right - region.x1).abs() < 0.5,
|
||||
"{case}: the gradient {geom:?} spans the clip {region:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_clip_groups_placed_gradient_follows_free_distort_by_the_clip_when_its_clipping_type_strokes() {
|
||||
// A clip group with a placed linear gradient fill of its own, in a group with Free Distort,
|
||||
// clipped by type whose stroke has a Transform effect moving it 60 pt right, outside the clip:
|
||||
// the gradient moves and scales from the clip's bounds, as for the same clip group whose type
|
||||
// does not stroke. The moved stroke adds nothing to those bounds.
|
||||
use vectorcraft_color::{Gradient, GradientGeom, GradientKind, GradientPaint, GradientStop};
|
||||
let stops = vec![GradientStop::new(0.0, Color::BLACK), GradientStop::new(1.0, Color::WHITE)];
|
||||
let ramp = GradientPaint::new(Gradient::new(GradientKind::Linear, stops));
|
||||
let geom = GradientGeom { start: (10.0, 45.0).into(), end: (30.0, 45.0).into(), aspect: 1.0, focal: None };
|
||||
let placed = Paint::Gradient(Box::new(GradientPaint { geom: Some(geom), ..ramp }));
|
||||
fn placed_geom(n: &Node) -> Option<vectorcraft_color::GradientGeom> {
|
||||
if let Paint::Gradient(g) = n.appearance.fill_paint()
|
||||
&& g.geom.is_some()
|
||||
{
|
||||
return g.geom;
|
||||
}
|
||||
n.children().into_iter().flatten().find_map(|c| placed_geom(c))
|
||||
}
|
||||
let ends = |stroke: bool| {
|
||||
let mut ty = painted_type(3, false, false);
|
||||
if stroke {
|
||||
ty.appearance = Appearance::basic(Paint::None, green(), 2.0).into();
|
||||
for item in &mut ty.appearance.items {
|
||||
if let vectorcraft_doc::AppearanceItem::Stroke(s) = item {
|
||||
s.effects.push(fx("distort.transform", json!({"moveH": 60})));
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut group = clip_group(2, ty);
|
||||
group.appearance = Appearance::basic(placed.clone(), Paint::None, 0.0).into();
|
||||
let mut outer = Node::group(NodeId(1), vec![Arc::new(group)]);
|
||||
let corners = json!({"corners": [[1.0 / 3.0, 0.0], [4.0 / 3.0, 0.0], [1.0, 1.0], [0.0, 1.0]]});
|
||||
outer.appearance.effects.push(fx("distort.freeDistort", corners));
|
||||
let canvas = crate::evaluate_container(None, &outer).unwrap();
|
||||
if stroke {
|
||||
assert!(stroke_wrapper(&canvas).is_some(), "the type's stroke paints around the clip: {canvas:?}");
|
||||
}
|
||||
placed_geom(&canvas).unwrap_or_else(|| panic!("no placed gradient: {canvas:?}"))
|
||||
};
|
||||
let (plain, stroked) = (ends(false), ends(true));
|
||||
assert!(
|
||||
plain.start.distance(stroked.start) < 0.5 && plain.end.distance(stroked.end) < 0.5,
|
||||
"the gradient {stroked:?} follows the clip as {plain:?} does"
|
||||
);
|
||||
}
|
||||
@@ -71,7 +71,7 @@ pub fn seg_cubic(sp: &SubPath, i: usize) -> CubicBez {
|
||||
|
||||
/// Non-linear path mapping (shared with live envelopes in `vectorcraft-doc`), and the split of
|
||||
/// segments into pieces within an anchor budget.
|
||||
pub use vectorcraft_doc::live::{fit_piece, map_nonlinear_within, map_smooth_within, pieces};
|
||||
pub use vectorcraft_doc::live::{fit_piece, map_handles_within, map_nonlinear_within, pieces};
|
||||
|
||||
/// About how many lines the renderer flattens `path` into at 1 px/pt: one for a straight
|
||||
/// segment, and for a curve the count Wang's formula gives at vello's tolerance of 0.25 px,
|
||||
|
||||
@@ -59,6 +59,9 @@ chrono = { workspace = true }
|
||||
craft-xml = { workspace = true }
|
||||
# The compound file that holds a Word 97-2003 document placed as type (place/doc.rs).
|
||||
cfb = "0.15"
|
||||
# The Text Import Options character sets other than Unicode and ANSI (place/text.rs). Already in
|
||||
# Cargo.lock (vectorcraft-eps), so this adds no new crate.
|
||||
encoding_rs = { workspace = true }
|
||||
kurbo = { workspace = true }
|
||||
serde = { workspace = true }
|
||||
serde_json = { workspace = true }
|
||||
|
||||
@@ -0,0 +1,154 @@
|
||||
//! `cargo run --release -p vectorcraft-engine --example layer_select_bench` prints the time of a
|
||||
//! Shift-click in the Layers panel's selection column (`layer.selectAll {id, add: true}`) on a layer of
|
||||
//! 2,000, 20,000 and 50,000 rectangles, with all of its art selected (the click removes it) and with
|
||||
//! every other object selected (the click adds the rest). Each case is timed one id at a time (`old`,
|
||||
//! the loop the command used before, copied here) and in one pass (`new`), side by side in one
|
||||
//! process: first the whole command, then the selection step alone. Each case checks that both give
|
||||
//! the same selection and reply before it is timed.
|
||||
//! `ITERS` sets the runs per case (default 7); each row is the median wall time in ms, followed by
|
||||
//! every run of `old` and of `new`.
|
||||
// Example (dev tool): unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness).
|
||||
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||||
|
||||
use std::collections::HashSet;
|
||||
use std::hint::black_box;
|
||||
use std::time::Instant;
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_color::{Color, Paint};
|
||||
use vectorcraft_doc::{Appearance, Document, Node, NodeId, Selection};
|
||||
use vectorcraft_engine::Session;
|
||||
use vectorcraft_geom::{Anchor, PathData, Point, SubPath};
|
||||
|
||||
fn iters() -> usize {
|
||||
std::env::var("ITERS").ok().and_then(|v| v.parse().ok()).unwrap_or(7).max(1)
|
||||
}
|
||||
|
||||
fn median(ms: &[f64]) -> f64 {
|
||||
let mut ms = ms.to_vec();
|
||||
ms.sort_by(f64::total_cmp);
|
||||
ms[ms.len() / 2]
|
||||
}
|
||||
|
||||
/// A document whose first layer holds `n` 10 pt squares in a row → (document, layer, squares).
|
||||
fn squares(n: usize) -> (Document, NodeId, Vec<NodeId>) {
|
||||
let mut doc = Document::new(1600.0, 1200.0);
|
||||
let layer = doc.layers[0].id;
|
||||
let ids = (0..n)
|
||||
.map(|i| {
|
||||
let (x, y) = ((i % 100) as f64 * 12.0, (i / 100) as f64 * 12.0);
|
||||
let corners = [(x, y), (x + 10.0, y), (x + 10.0, y + 10.0), (x, y + 10.0)];
|
||||
let path = PathData::single(SubPath::new(corners.iter().map(|&(x, y)| Anchor::corner(Point::new(x, y))).collect(), true));
|
||||
let id = doc.alloc_id();
|
||||
doc.insert(Some(layer), usize::MAX, Node::path(id, path, Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 1.0))).unwrap();
|
||||
id
|
||||
})
|
||||
.collect();
|
||||
(doc, layer, ids)
|
||||
}
|
||||
|
||||
/// `layer.selectAll {id: layer, add: true}` before the change: the layer's art checked, removed or
|
||||
/// added one id at a time with [`Selection::contains`], [`Selection::remove`] and [`Selection::add`].
|
||||
fn old_command(s: &mut Session, layer: NodeId) -> Value {
|
||||
let st = s.doc().unwrap();
|
||||
let ids = st.doc.node(layer).unwrap().layer_art(true);
|
||||
let all_selected = !ids.is_empty() && ids.iter().all(|i| st.selection.contains(*i));
|
||||
let rows = st.layer_rows.clone();
|
||||
s.select(|_, sel| old_step(sel, &ids, all_selected)).unwrap();
|
||||
let st = s.doc_mut().unwrap();
|
||||
st.layer_rows = rows;
|
||||
json!({ "selected": st.selection.objects.iter().map(|i| i.0).collect::<Vec<_>>() })
|
||||
}
|
||||
|
||||
fn old_step(sel: &mut Selection, ids: &[NodeId], all_selected: bool) {
|
||||
for i in ids {
|
||||
if all_selected { sel.remove(*i) } else { sel.add(*i) }
|
||||
}
|
||||
}
|
||||
|
||||
fn new_command(s: &mut Session, layer: NodeId) -> Value {
|
||||
s.execute("layer.selectAll", &json!({"id": layer.0, "add": true})).unwrap()
|
||||
}
|
||||
|
||||
/// Every run of `old` and of `new`, run in turn, each from `prepare`'s state.
|
||||
fn time<S>(mut prepare: impl FnMut() -> S, old: impl Fn(&mut S), new: impl Fn(&mut S)) -> (Vec<f64>, Vec<f64>) {
|
||||
let run = |s: &mut S, f: &dyn Fn(&mut S)| {
|
||||
let t = Instant::now();
|
||||
f(s);
|
||||
t.elapsed().as_secs_f64() * 1000.0
|
||||
};
|
||||
let (mut olds, mut news) = (Vec::new(), Vec::new());
|
||||
for _ in 0..iters() {
|
||||
let mut s = prepare();
|
||||
olds.push(run(&mut s, &old));
|
||||
black_box(&s);
|
||||
let mut s = prepare();
|
||||
news.push(run(&mut s, &new));
|
||||
black_box(&s);
|
||||
}
|
||||
(olds, news)
|
||||
}
|
||||
|
||||
fn row(name: &str, (old, new): (Vec<f64>, Vec<f64>)) {
|
||||
let (o, n) = (median(&old), median(&new));
|
||||
let list = |ms: &[f64]| ms.iter().map(|m| format!("{m:.2}")).collect::<Vec<_>>().join(" ");
|
||||
println!(" {name:<40} {o:>12.3} ms {n:>12.3} ms {:>9.1}x", o / n.max(1e-9));
|
||||
println!(" old runs: {}", list(&old));
|
||||
println!(" new runs: {}", list(&new));
|
||||
}
|
||||
|
||||
fn main() {
|
||||
println!(" {:<40} {:>15} {:>15} {:>10}", "case", "old", "new", "speedup");
|
||||
for n in [2_000usize, 20_000, 50_000] {
|
||||
println!("{n} objects");
|
||||
let (doc, layer, ids) = squares(n);
|
||||
let mut s = Session::new();
|
||||
s.add_document(doc, None);
|
||||
let mut all = Selection::default();
|
||||
all.set(ids.iter().copied());
|
||||
let mut half = Selection::default();
|
||||
half.set(ids.iter().copied().step_by(2));
|
||||
for (name, start) in [("all selected (removes)", &all), ("half selected (adds)", &half)] {
|
||||
let reset = |s: &mut Session| {
|
||||
let st = s.doc_mut().unwrap();
|
||||
st.selection = start.clone();
|
||||
st.layer_rows.clear();
|
||||
};
|
||||
// Both ways give the same selection and reply.
|
||||
reset(&mut s);
|
||||
let old_reply = old_command(&mut s, layer);
|
||||
let old_sel = s.doc().unwrap().selection.clone();
|
||||
reset(&mut s);
|
||||
let new_reply = new_command(&mut s, layer);
|
||||
assert_eq!(s.doc().unwrap().selection, old_sel, "{name}: the same selection");
|
||||
assert_eq!(new_reply, old_reply, "{name}: the same reply");
|
||||
|
||||
let (mut olds, mut news) = (Vec::new(), Vec::new());
|
||||
for _ in 0..iters() {
|
||||
for (f, ms) in [(old_command as fn(&mut Session, NodeId) -> Value, &mut olds), (new_command, &mut news)] {
|
||||
reset(&mut s);
|
||||
let t = Instant::now();
|
||||
black_box(f(&mut s, layer));
|
||||
ms.push(t.elapsed().as_secs_f64() * 1000.0);
|
||||
}
|
||||
}
|
||||
row(&format!("command, {name}"), (olds, news));
|
||||
// The selection step alone, on a copy of the starting selection.
|
||||
let art = s.doc().unwrap().doc.node(layer).unwrap().layer_art(true);
|
||||
let selected: HashSet<NodeId> = start.objects.iter().copied().collect();
|
||||
let all_selected = art.iter().all(|i| selected.contains(i));
|
||||
let new_step = |sel: &mut Selection| {
|
||||
if all_selected {
|
||||
sel.remove_all(art.iter().copied());
|
||||
} else {
|
||||
sel.add_all(art.iter().copied());
|
||||
}
|
||||
};
|
||||
let (mut a, mut b) = (start.clone(), start.clone());
|
||||
old_step(&mut a, &art, all_selected);
|
||||
new_step(&mut b);
|
||||
assert_eq!(a, b, "{name}: the same selection step");
|
||||
row(&format!("selection step, {name}"), time(|| start.clone(), |sel| old_step(sel, &art, all_selected), new_step));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,217 @@
|
||||
//! `cargo run --release -p vectorcraft-engine --example link_colors_bench` prints the time
|
||||
//! `Document::map_solid_paints_in` takes to link the paints of selected objects to swatches, as Add Used
|
||||
//! Colors and New Color Group do for the selection with global swatches, on synthetic documents: 2,000 and
|
||||
//! 20,000 rectangles in one layer, and 5,000 rectangles in 1,000 groups of groups, selected with and
|
||||
//! without the groups that hold them. The fills and strokes use 50 colors, each with a swatch to link to.
|
||||
//! For each it times two ways of finding the selected objects that no other selected object holds: a
|
||||
//! search of the id list for each ancestor of each id, and a lookup of each ancestor in a set of the ids
|
||||
//! (as `map_solid_paints_in` does). Both then link the same paints in the same loop. It checks that both
|
||||
//! give the same count, visit the same paints in the same order and leave the same document as
|
||||
//! `map_solid_paints_in` before it times them.
|
||||
//! `ITERS` sets the runs per row (default 7); the two ways run in alternating order, each run links 10
|
||||
//! fresh copies of the document, and each row is the median time of one call. On Linux the times are the CPU time of the main thread, which runs
|
||||
//! everything, in ms; elsewhere they are wall times.
|
||||
// Example (dev tool): unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness).
|
||||
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||||
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::hint::black_box;
|
||||
use std::sync::Arc;
|
||||
use std::time::Instant;
|
||||
|
||||
use vectorcraft_color::{Color, Paint};
|
||||
use vectorcraft_doc::swatches::{LinkFn, map_node_solid_paints};
|
||||
use vectorcraft_doc::{Appearance, Document, Node, NodeId};
|
||||
use vectorcraft_geom::{Rect, shapes};
|
||||
|
||||
/// The colors the rectangles use, each with a swatch to link to.
|
||||
const COLORS: usize = 50;
|
||||
|
||||
/// The calls in each timed run; a row gives the time of one call.
|
||||
const REPS: usize = 10;
|
||||
|
||||
/// A way of finding the ids that no other listed id holds.
|
||||
type Roots = fn(&Document, &[NodeId]) -> Vec<NodeId>;
|
||||
|
||||
/// A way of applying a link function to the paints of the listed ids, returning the count changed.
|
||||
type Map<'a> = dyn FnMut(&mut Document, &[NodeId], &mut LinkFn) -> usize + 'a;
|
||||
|
||||
fn iters() -> usize {
|
||||
std::env::var("ITERS").ok().and_then(|v| v.parse().ok()).unwrap_or(7).max(1)
|
||||
}
|
||||
|
||||
fn median(mut ms: Vec<f64>) -> f64 {
|
||||
ms.sort_by(f64::total_cmp);
|
||||
ms[ms.len() / 2]
|
||||
}
|
||||
|
||||
/// The CPU time of the calling thread in ns, from `/proc/thread-self/schedstat` (Linux only).
|
||||
fn thread_cpu_ns() -> Option<u64> {
|
||||
std::fs::read_to_string("/proc/thread-self/schedstat").ok()?.split_whitespace().next()?.parse().ok()
|
||||
}
|
||||
|
||||
/// The time `f` takes, in ms: CPU time where the system reports it, wall time otherwise.
|
||||
fn measure(f: impl FnOnce()) -> f64 {
|
||||
match thread_cpu_ns() {
|
||||
Some(start) => {
|
||||
f();
|
||||
thread_cpu_ns().map_or(f64::NAN, |end| end.saturating_sub(start) as f64 / 1e6)
|
||||
}
|
||||
None => {
|
||||
let t = Instant::now();
|
||||
f();
|
||||
t.elapsed().as_secs_f64() * 1000.0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Color `i` of [`COLORS`]: each has its own red value.
|
||||
fn color(i: usize) -> Color {
|
||||
Color::rgb(i as f32 / COLORS as f32, 0.5, 0.25)
|
||||
}
|
||||
|
||||
/// The bits of a color's red value, which tell the colors of [`color`] apart; `u32::MAX` for other color models.
|
||||
fn red_bits(c: &Color) -> u32 {
|
||||
match c {
|
||||
Color::Rgb { r, .. } => r.to_bits(),
|
||||
_ => u32::MAX,
|
||||
}
|
||||
}
|
||||
|
||||
/// The ids in the order given, less those with an ancestor in the list: a search of the list for each ancestor.
|
||||
fn roots_by_search(d: &Document, ids: &[NodeId]) -> Vec<NodeId> {
|
||||
ids.iter().copied().filter(|id| !d.ancestry(*id).is_some_and(|a| a[..a.len() - 1].iter().any(|p| ids.contains(p)))).collect()
|
||||
}
|
||||
|
||||
/// [`roots_by_search`] with each ancestor looked up in a set of the ids.
|
||||
fn roots_by_set(d: &Document, ids: &[NodeId]) -> Vec<NodeId> {
|
||||
let listed: HashSet<NodeId> = ids.iter().copied().collect();
|
||||
ids.iter().copied().filter(|id| !d.ancestry(*id).is_some_and(|a| a[..a.len() - 1].iter().any(|p| listed.contains(p)))).collect()
|
||||
}
|
||||
|
||||
/// `f` applied to the paints of the subtrees of the ids `roots` finds, each node holding a changed
|
||||
/// paint put in place: the work of `map_solid_paints_in`.
|
||||
fn map_in(d: &mut Document, ids: &[NodeId], roots: Roots, f: &mut LinkFn) -> usize {
|
||||
let mut n = 0;
|
||||
for id in roots(d, ids) {
|
||||
let Some(mut node) = d.node(id).cloned() else { continue };
|
||||
let count = map_node_solid_paints(&mut node, f);
|
||||
if count > 0
|
||||
&& let Some(slot) = d.node_mut(id)
|
||||
{
|
||||
*slot = node;
|
||||
n += count;
|
||||
}
|
||||
}
|
||||
n
|
||||
}
|
||||
|
||||
/// Link every paint whose color has a swatch to that swatch, as Add Used Colors does for global
|
||||
/// swatches, recording each paint visited. Returns the count and the visits.
|
||||
fn link(d: &mut Document, ids: &[NodeId], map: &mut Map) -> (usize, Vec<(Color, Option<String>)>) {
|
||||
let names: HashMap<u32, String> = (0..COLORS).map(|i| (red_bits(&color(i)), format!("Swatch {i}"))).collect();
|
||||
let mut visits = vec![];
|
||||
let n = map(d, ids, &mut |c, s, _| {
|
||||
visits.push((*c, s.clone()));
|
||||
match names.get(&red_bits(c)) {
|
||||
Some(name) if s.is_none() => {
|
||||
*s = Some(name.clone());
|
||||
true
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
});
|
||||
(n, visits)
|
||||
}
|
||||
|
||||
fn rect(d: &mut Document, i: usize) -> Arc<Node> {
|
||||
let id = d.alloc_id();
|
||||
let (x, y) = ((i % 100) as f64 * 12.0, (i / 100) as f64 * 12.0);
|
||||
let r = shapes::rectangle(Rect::new(x, y, x + 10.0, y + 10.0));
|
||||
let a = Appearance::basic(Paint::solid(color(i % COLORS)), Paint::solid(color((i + 7) % COLORS)), 1.0);
|
||||
Arc::new(Node::path(id, r, a))
|
||||
}
|
||||
|
||||
/// `n` rectangles in the first layer, all selected.
|
||||
fn flat(n: usize) -> (Document, Vec<NodeId>) {
|
||||
let mut d = Document::new(1600.0, 1200.0);
|
||||
let l = d.layers[0].id;
|
||||
let mut ids = vec![];
|
||||
for i in 0..n {
|
||||
let node = rect(&mut d, i);
|
||||
ids.push(node.id);
|
||||
d.insert(Some(l), usize::MAX, Arc::unwrap_or_clone(node)).unwrap();
|
||||
}
|
||||
(d, ids)
|
||||
}
|
||||
|
||||
/// 1,000 groups in the first layer, each holding a group of 5 rectangles: the rectangles, and with
|
||||
/// `groups` the two groups above each of them too, listed first.
|
||||
fn nested(groups: bool) -> (Document, Vec<NodeId>) {
|
||||
let mut d = Document::new(1600.0, 1200.0);
|
||||
let l = d.layers[0].id;
|
||||
let (mut outer_ids, mut leaves) = (vec![], vec![]);
|
||||
for g in 0..1_000 {
|
||||
let rects: Vec<Arc<Node>> = (0..5).map(|i| rect(&mut d, g * 5 + i)).collect();
|
||||
leaves.extend(rects.iter().map(|r| r.id));
|
||||
let inner = Node::group(d.alloc_id(), rects);
|
||||
let outer = Node::group(d.alloc_id(), vec![Arc::new(inner.clone())]);
|
||||
if groups {
|
||||
outer_ids.extend([outer.id, inner.id]);
|
||||
}
|
||||
d.insert(Some(l), usize::MAX, outer).unwrap();
|
||||
}
|
||||
outer_ids.extend(leaves);
|
||||
(d, outer_ids)
|
||||
}
|
||||
|
||||
fn bench(name: &str, (doc, ids): (Document, Vec<NodeId>)) {
|
||||
let mut shipped = doc.clone();
|
||||
let want = link(&mut shipped, &ids, &mut |d, ids, f| d.map_solid_paints_in(ids, f));
|
||||
for roots in [roots_by_search as Roots, roots_by_set] {
|
||||
let mut d = doc.clone();
|
||||
let got = link(&mut d, &ids, &mut |d, ids, f| map_in(d, ids, roots, f));
|
||||
assert_eq!(got, want, "{name}: the same count and visits");
|
||||
assert_eq!(d.layers, shipped.layers, "{name}: the same document");
|
||||
}
|
||||
let (mut old, mut new, mut real) = (vec![], vec![], vec![]);
|
||||
let timed = |map: &mut Map| {
|
||||
let mut docs = vec![doc.clone(); REPS];
|
||||
measure(|| {
|
||||
for d in &mut docs {
|
||||
black_box(link(d, black_box(&ids), &mut *map));
|
||||
}
|
||||
}) / REPS as f64
|
||||
};
|
||||
for i in 0..iters() {
|
||||
let run = |roots: Roots, out: &mut Vec<f64>| out.push(timed(&mut |d, ids, f| map_in(d, ids, roots, f)));
|
||||
if i % 2 == 0 {
|
||||
run(roots_by_search, &mut old);
|
||||
run(roots_by_set, &mut new);
|
||||
} else {
|
||||
run(roots_by_set, &mut new);
|
||||
run(roots_by_search, &mut old);
|
||||
}
|
||||
real.push(timed(&mut |d, ids, f| d.map_solid_paints_in(ids, f)));
|
||||
}
|
||||
let (old, new, real) = (median(old), median(new), median(real));
|
||||
println!(" {name:<46} {:>7} {:>7} {old:>12.3} {new:>12.3} {real:>12.3} {:>8.1}x", ids.len(), want.0, old / new);
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let unit = if thread_cpu_ns().is_some() { "CPU ms" } else { "wall ms" };
|
||||
println!(
|
||||
" {:<46} {:>7} {:>7} {:>12} {:>12} {:>12} {:>9}",
|
||||
"document",
|
||||
"ids",
|
||||
"linked",
|
||||
format!("search, {unit}"),
|
||||
format!("set, {unit}"),
|
||||
format!("shipped, {unit}"),
|
||||
"speedup"
|
||||
);
|
||||
bench("2,000 rectangles in one layer", flat(2_000));
|
||||
bench("20,000 rectangles in one layer", flat(20_000));
|
||||
bench("5,000 rectangles in 1,000 groups of groups", nested(false));
|
||||
bench("the same with the 2,000 groups listed first", nested(true));
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
//! `cargo run --release -p vectorcraft-engine --example stroke_targets_bench` prints the time `stroke.set`
|
||||
//! takes to list its targets on documents of 2,000, 10,000 and 20,000 rectangles, all in one group. For
|
||||
//! each size it times, on the same leaves, the merge that checks each leaf against the growing list and
|
||||
//! the merge that checks it against a set, checks that the two lists are equal, and then times the whole
|
||||
//! `stroke.set {weight: 3}` command twice: once with the group named and once with every rectangle named.
|
||||
//! The whole-command rows include the document copy the command makes for undo; each run is undone
|
||||
//! before the next, outside the timed part.
|
||||
//! On Linux each row is the thread's CPU time, read from `/proc/thread-self/schedstat`; elsewhere
|
||||
//! it is wall time, and the first line says which. `ITERS` sets the runs per row (default 7); each
|
||||
//! row is the median in ms. A run of the two merge rows repeats the merge 1,000,000 / paths times
|
||||
//! and gives the time of one.
|
||||
// Example (dev tool): unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness).
|
||||
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
||||
|
||||
use std::collections::HashSet;
|
||||
use std::hint::black_box;
|
||||
use std::time::Instant;
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_color::Color;
|
||||
use vectorcraft_doc::{Document, NodeId};
|
||||
use vectorcraft_engine::Session;
|
||||
use vectorcraft_geom::Rect;
|
||||
use vectorcraft_testkit::fixtures::DocBuilder;
|
||||
|
||||
fn iters() -> usize {
|
||||
std::env::var("ITERS").ok().and_then(|v| v.parse().ok()).unwrap_or(7).max(1)
|
||||
}
|
||||
|
||||
/// The thread's CPU time in ns, or `None` where `/proc/thread-self/schedstat` cannot be read.
|
||||
fn cpu_ns() -> Option<u64> {
|
||||
std::fs::read_to_string("/proc/thread-self/schedstat").ok()?.split_whitespace().next()?.parse().ok()
|
||||
}
|
||||
|
||||
/// The time `f` takes in ms: CPU time when [`cpu_ns`] reads, wall time otherwise.
|
||||
fn ms(f: impl FnOnce()) -> f64 {
|
||||
let (cpu, wall) = (cpu_ns(), Instant::now());
|
||||
f();
|
||||
match (cpu, cpu_ns()) {
|
||||
(Some(a), Some(b)) => (b - a) as f64 / 1e6,
|
||||
_ => wall.elapsed().as_secs_f64() * 1000.0,
|
||||
}
|
||||
}
|
||||
|
||||
fn median(mut v: Vec<f64>) -> f64 {
|
||||
v.sort_by(f64::total_cmp);
|
||||
v[v.len() / 2]
|
||||
}
|
||||
|
||||
/// `n` 10 pt squares in one group, and the squares' ids in stacking order.
|
||||
fn document(n: usize) -> (Document, NodeId, Vec<NodeId>) {
|
||||
let mut b = DocBuilder::new(4000.0, 4000.0);
|
||||
let kids: Vec<_> = (0..n)
|
||||
.map(|i| {
|
||||
let (x, y) = ((i % 200) as f64 * 12.0, (i / 200) as f64 * 12.0);
|
||||
b.rect_node(Rect::new(x, y, x + 10.0, y + 10.0), Color::rgb(0.2, 0.4, 0.6))
|
||||
})
|
||||
.collect();
|
||||
let leaves = kids.iter().map(|k| k.id).collect();
|
||||
let group = b.group(kids, false);
|
||||
(b.build(), group, leaves)
|
||||
}
|
||||
|
||||
/// The merge that checks each leaf against the growing list.
|
||||
fn listed(mut out: Vec<NodeId>, leaves: Vec<NodeId>) -> Vec<NodeId> {
|
||||
for id in leaves {
|
||||
if !out.contains(&id) {
|
||||
out.push(id);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The merge that checks each leaf against a set seeded with `out`.
|
||||
fn with_set(mut out: Vec<NodeId>, leaves: Vec<NodeId>) -> Vec<NodeId> {
|
||||
let mut seen: HashSet<NodeId> = out.iter().copied().collect();
|
||||
for id in leaves {
|
||||
if seen.insert(id) {
|
||||
out.push(id);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn row(name: &str, ms: f64) {
|
||||
println!(" {name:<52} {ms:>10.3} ms");
|
||||
}
|
||||
|
||||
/// The median time of `stroke.set {weight: 3}` on `ids`, each run undone outside the timed part.
|
||||
fn whole_command(s: &mut Session, ids: &[NodeId], n: usize) -> f64 {
|
||||
let p: Value = json!({"ids": ids.iter().map(|id| id.0).collect::<Vec<_>>(), "weight": 3});
|
||||
let runs = (0..iters())
|
||||
.map(|_| {
|
||||
let mut r = Value::Null;
|
||||
let t = ms(|| r = black_box(s.execute("stroke.set", &p).unwrap()));
|
||||
assert_eq!(r["objects"], n, "{r}");
|
||||
s.execute("edit.undo", &json!({})).unwrap();
|
||||
t
|
||||
})
|
||||
.collect();
|
||||
median(runs)
|
||||
}
|
||||
|
||||
fn bench(n: usize) {
|
||||
println!("{n} paths in one group");
|
||||
let (doc, group, leaves) = document(n);
|
||||
|
||||
// Each run merges `reps` times, on copies made before the clock starts, and gives the time of one.
|
||||
let reps = (1_000_000 / n).max(1);
|
||||
let time = |f: fn(Vec<NodeId>, Vec<NodeId>) -> Vec<NodeId>| -> (f64, Vec<NodeId>) {
|
||||
let mut last = Vec::new();
|
||||
let runs = (0..iters())
|
||||
.map(|_| {
|
||||
let mut work: Vec<Vec<NodeId>> = (0..reps).map(|_| leaves.clone()).collect();
|
||||
let mut done = Vec::with_capacity(reps);
|
||||
let t = ms(|| {
|
||||
for input in &mut work {
|
||||
done.push(f(Vec::new(), black_box(std::mem::take(input))));
|
||||
}
|
||||
});
|
||||
last = done.pop().unwrap();
|
||||
t / reps as f64
|
||||
})
|
||||
.collect();
|
||||
(median(runs), last)
|
||||
};
|
||||
let (old, a) = time(listed);
|
||||
let (new, b) = time(with_set);
|
||||
assert_eq!(a, b, "both merges give the same list");
|
||||
assert_eq!(a, leaves);
|
||||
row("target merge, list search", old);
|
||||
row("target merge, set", new);
|
||||
println!(" {:<52} {:>10.1}x", "ratio", old / new);
|
||||
|
||||
let mut s = Session::new();
|
||||
s.add_document(doc, None);
|
||||
row("stroke.set, whole command, the group named", whole_command(&mut s, &[group], n));
|
||||
row("stroke.set, whole command, every path named", whole_command(&mut s, &leaves, n));
|
||||
}
|
||||
|
||||
fn main() {
|
||||
println!("{}", if cpu_ns().is_some() { "thread CPU time, median of runs" } else { "wall time, median of runs" });
|
||||
for n in [2_000, 10_000, 20_000] {
|
||||
bench(n);
|
||||
}
|
||||
}
|
||||
@@ -74,6 +74,7 @@ pub mod perspgrid;
|
||||
pub mod place;
|
||||
pub mod plugin;
|
||||
pub(crate) mod plugin_call;
|
||||
mod preflight;
|
||||
pub mod prefscmds;
|
||||
pub mod print;
|
||||
pub(crate) mod printadvanced;
|
||||
@@ -98,7 +99,6 @@ pub(crate) mod symboledit;
|
||||
pub mod symbollib;
|
||||
pub(crate) mod tabs;
|
||||
mod textedit;
|
||||
mod xmlattrs;
|
||||
|
||||
pub use textedit::effective_kerning;
|
||||
pub mod textstyles;
|
||||
@@ -382,6 +382,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
|
||||
v.extend(package::specs());
|
||||
v.extend(slices::specs());
|
||||
v.extend(print::specs());
|
||||
v.extend(preflight::specs());
|
||||
v.extend(recovery::specs());
|
||||
v.extend(fileio::dxfimport::specs());
|
||||
v.extend(webexport::specs());
|
||||
@@ -407,7 +408,18 @@ pub fn command_specs() -> &'static [CommandSpec] {
|
||||
/// The command `id`: a built-in one, or a command an installed plug-in adds
|
||||
/// ([`plugin::command_specs`]).
|
||||
pub fn find_command(id: &str) -> Option<&'static CommandSpec> {
|
||||
command_specs().iter().find(|c| c.id == id).or_else(|| plugin::find_spec(id))
|
||||
static INDEX: std::sync::OnceLock<std::collections::HashMap<&'static str, &'static CommandSpec>> = std::sync::OnceLock::new();
|
||||
INDEX.get_or_init(|| index_by_id(command_specs())).get(id).copied().or_else(|| plugin::find_spec(id))
|
||||
}
|
||||
|
||||
/// `specs` by id. An id that more than one spec has names the first of them, as a search of
|
||||
/// `specs` in order finds.
|
||||
pub(crate) fn index_by_id(specs: &[CommandSpec]) -> std::collections::HashMap<&'static str, &CommandSpec> {
|
||||
let mut index = std::collections::HashMap::with_capacity(specs.len());
|
||||
for spec in specs {
|
||||
index.entry(spec.id).or_insert(spec);
|
||||
}
|
||||
index
|
||||
}
|
||||
|
||||
/// Runs command `spec`'s implementation with `p`. A plug-in command's runs the plug-in
|
||||
@@ -821,12 +833,16 @@ pub(crate) fn unique_name_from(base: &str, next: &mut std::collections::HashMap<
|
||||
pub(crate) const MAX_IMPORTED_PRESETS: usize = 1000;
|
||||
|
||||
pub(crate) use addons::{DecodedImages, refresh_color_masks};
|
||||
/// Packaging Tools' blanks and the objects their print leaves out, for the Fold Preview window.
|
||||
pub use addons::{fold_source, print_hidden};
|
||||
/// Document Info's category titles and the Objects category's count labels.
|
||||
pub use docinfo::{CATEGORIES, OBJECT_LABELS};
|
||||
pub use docmenu::guide_indexes;
|
||||
pub(crate) use edit::{settle_interaction, typing_in_progress};
|
||||
pub(crate) use edit::{Unrecorded, settle_interaction, typing_in_progress};
|
||||
pub(crate) use object::bounds_rewrite;
|
||||
pub(crate) use object::{keep_aligned_in, refresh_pixel_aligned};
|
||||
/// The rules `object.scale`, `object.reflect` and `object.shear` check their params with.
|
||||
pub use object::{reflect_axis, scale_factors, shear_tangent};
|
||||
pub use plugin_call::{Location, ParamsPlace, key_location, location_in, location_keys};
|
||||
pub use select::SIMILAR;
|
||||
pub(crate) use vectorcraft_doc::range::parse_range;
|
||||
|
||||
@@ -17,6 +17,7 @@ mod typetools;
|
||||
mod units;
|
||||
|
||||
pub(crate) use image::{DecodedImages, refresh_color_masks};
|
||||
pub use packaging::{fold_source, print_hidden};
|
||||
pub(crate) use packaging::{role_swatch_edited, role_swatches_merged};
|
||||
|
||||
use super::CommandSpec;
|
||||
|
||||
@@ -6,8 +6,10 @@
|
||||
//! (Object › Plug-ins › Packaging Tools) and its Fold Lines panel are the UI's.
|
||||
|
||||
mod check;
|
||||
mod fold;
|
||||
mod roles;
|
||||
|
||||
pub use fold::{fold_source, print_hidden};
|
||||
pub(crate) use roles::{role_swatch_edited, role_swatches_merged};
|
||||
|
||||
use super::super::CommandSpec;
|
||||
@@ -15,6 +17,7 @@ use super::super::CommandSpec;
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
let mut v = roles::specs();
|
||||
v.extend(check::specs());
|
||||
v.extend(fold::specs());
|
||||
v
|
||||
}
|
||||
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
|
||||
use vectorcraft_geom::PathData;
|
||||
use vectorcraft_three_d::fold::{FoldLine, IssueCode, LineKind, MAX_SEGMENTS, blanks};
|
||||
use vectorcraft_three_d::fold::{Blank, FoldLine, Issue, IssueCode, LineKind, MAX_SEGMENTS, blanks};
|
||||
|
||||
use super::super::super::pathops::length_given;
|
||||
use super::super::super::{CommandSpec, bad, checked_ids_or_selection, cmd, has_doc, switch_or};
|
||||
@@ -14,7 +14,7 @@ use crate::{Result, Session};
|
||||
const CHECK: &str = "addon.packaging.check";
|
||||
|
||||
/// How far apart the ends of two lines may be and still be joined, in points.
|
||||
const TOLERANCE: (f64, f64, f64) = (0.01, 0.1, 10.0);
|
||||
pub(super) const TOLERANCE: (f64, f64, f64) = (0.01, 0.1, 10.0);
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
vec![cmd!(
|
||||
@@ -101,23 +101,44 @@ fn kind(role: Role) -> LineKind {
|
||||
}
|
||||
}
|
||||
|
||||
fn check(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let select = switch_or(p, "select", false, CHECK)?;
|
||||
let tolerance = match length_given(p, "tolerance", CHECK)? {
|
||||
None => TOLERANCE.1,
|
||||
Some(t) if (TOLERANCE.0..=TOLERANCE.2).contains(&t) => t,
|
||||
Some(_) => return Err(bad(CHECK, format!("`tolerance` must be from {} to {} pt", TOLERANCE.0, TOLERANCE.2))),
|
||||
};
|
||||
/// The fold lines a check or a fold reads: where they came from (`ids`, `selection` or
|
||||
/// `document`), the lines, and the ids of those on a non-printing layer.
|
||||
pub(super) struct Lines {
|
||||
pub scope: &'static str,
|
||||
pub lines: Vec<FoldLine>,
|
||||
pub non_printing: Vec<u64>,
|
||||
}
|
||||
|
||||
/// The tolerance `p` gives for `cmd`, or the default.
|
||||
pub(super) fn tolerance(p: &Value, cmd: &str) -> Result<f64> {
|
||||
match length_given(p, "tolerance", cmd)? {
|
||||
None => Ok(TOLERANCE.1),
|
||||
Some(t) if (TOLERANCE.0..=TOLERANCE.2).contains(&t) => Ok(t),
|
||||
Some(_) => Err(bad(cmd, format!("`tolerance` must be from {} to {} pt", TOLERANCE.0, TOLERANCE.2))),
|
||||
}
|
||||
}
|
||||
|
||||
/// The fold lines among the objects `p` names for `cmd` (`ids`, else the selection), or, while
|
||||
/// nothing is selected and `ids` is left out, every shown fold line of the document. Hidden lines
|
||||
/// are left out in every scope, members of a selected group included.
|
||||
pub(super) fn lines(s: &Session, p: &Value, cmd: &str) -> Result<Lines> {
|
||||
let given = p.get("ids").is_some_and(|v| !v.is_null());
|
||||
let roots = checked_ids_or_selection(s, p, CHECK)?;
|
||||
let roots = checked_ids_or_selection(s, p, cmd)?;
|
||||
let d = &s.doc()?.doc;
|
||||
// Hidden lines are left out in every scope, members of a selected group included.
|
||||
let shown = |ids: Vec<NodeId>| ids.into_iter().filter(|id| d.is_visible(*id)).collect::<Vec<_>>();
|
||||
let (scope, targets) = match (given, roots.is_empty()) {
|
||||
(true, _) => ("ids", shown(role_targets(d, &roots, false).0)),
|
||||
(false, false) => ("selection", shown(role_targets(d, &roots, false).0)),
|
||||
(false, true) => ("document", shown_targets(d)),
|
||||
};
|
||||
Ok(match (given, roots.is_empty()) {
|
||||
(true, _) => lines_of(d, "ids", shown(role_targets(d, &roots, false).0)),
|
||||
(false, false) => lines_of(d, "selection", shown(role_targets(d, &roots, false).0)),
|
||||
(false, true) => document_lines(d),
|
||||
})
|
||||
}
|
||||
|
||||
/// Every shown fold line of `d`.
|
||||
pub(super) fn document_lines(d: &Document) -> Lines {
|
||||
lines_of(d, "document", shown_targets(d))
|
||||
}
|
||||
|
||||
fn lines_of(d: &Document, scope: &'static str, targets: Vec<NodeId>) -> Lines {
|
||||
let table = RoleTable::of(d);
|
||||
let mut lines = vec![];
|
||||
let mut non_printing = vec![];
|
||||
@@ -136,12 +157,21 @@ fn check(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
segments = segments.saturating_add(path.subpaths.iter().map(|sp| sp.segment_count()).sum());
|
||||
lines.push(FoldLine { path, kind: kind(role), key: id.0 });
|
||||
}
|
||||
let (found, mut issues) = blanks(&lines, tolerance);
|
||||
if !non_printing.is_empty() {
|
||||
issues.push(vectorcraft_three_d::fold::Issue { code: IssueCode::NonPrinting, keys: non_printing, at: None });
|
||||
Lines { scope, lines, non_printing }
|
||||
}
|
||||
|
||||
/// The blanks `lines` make and their issues, the non-printing one last.
|
||||
pub(super) fn found(lines: &Lines, tolerance: f64) -> (Vec<Blank>, Vec<Issue>) {
|
||||
let (found, mut issues) = blanks(&lines.lines, tolerance);
|
||||
if !lines.non_printing.is_empty() {
|
||||
issues.push(Issue { code: IssueCode::NonPrinting, keys: lines.non_printing.clone(), at: None });
|
||||
}
|
||||
let ok = !issues.iter().any(|i| i.code.is_error());
|
||||
let rows: Vec<Value> = issues
|
||||
(found, issues)
|
||||
}
|
||||
|
||||
/// `issues` as the rows `addon.packaging.check` and `addon.packaging.fold` answer with.
|
||||
pub(super) fn issue_rows(issues: &[Issue], scope: &str) -> Vec<Value> {
|
||||
issues
|
||||
.iter()
|
||||
.map(|i| {
|
||||
let mut row = json!({
|
||||
@@ -155,7 +185,18 @@ fn check(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
row
|
||||
})
|
||||
.collect();
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn check(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let select = switch_or(p, "select", false, CHECK)?;
|
||||
let tolerance = tolerance(p, CHECK)?;
|
||||
let lines = lines(s, p, CHECK)?;
|
||||
let scope = lines.scope;
|
||||
let (found, issues) = found(&lines, tolerance);
|
||||
let d = &s.doc()?.doc;
|
||||
let ok = !issues.iter().any(|i| i.code.is_error());
|
||||
let rows = issue_rows(&issues, scope);
|
||||
if select {
|
||||
let mut ids: Vec<NodeId> = issues.iter().flat_map(|i| i.keys.iter().map(|k| NodeId(*k))).filter(|id| d.node(*id).is_some()).collect();
|
||||
ids.sort_unstable_by_key(|id| id.0);
|
||||
|
||||
@@ -0,0 +1,110 @@
|
||||
//! Fold Preview's model (`addon.packaging.fold`): a blank folded into its 3D shape by
|
||||
//! [`vectorcraft_three_d::fold::fold`], and what the Fold Preview window needs to draw it: the
|
||||
//! document's blanks ([`fold_source`]) and the objects its print leaves out ([`print_hidden`]).
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
|
||||
use vectorcraft_three_d::fold::{Blank, Issue, fold, pick};
|
||||
|
||||
use super::super::super::{CommandSpec, bad, cmd, finite_numbers, has_doc, number_or};
|
||||
use super::check::{TOLERANCE, document_lines, found, issue_rows, lines, tolerance};
|
||||
use super::roles::{RoleTable, can_carry};
|
||||
use crate::{Result, Session};
|
||||
|
||||
const FOLD: &str = "addon.packaging.fold";
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
vec![cmd!(
|
||||
query "addon.packaging.fold",
|
||||
"Fold",
|
||||
[],
|
||||
None,
|
||||
"{ids?: [id…] (default: the selection), base?: [x, y] (the panel under this point; default: the largest panel), amount?: 0..1 (1), tolerance?: pt 0.01..10 (0.1)} fold the blank that the fold lines among the objects make (as addon.packaging.check finds them; while nothing is selected and ids is left out, every fold line of the document) into its 3D shape. The base panel stays in place; every other panel turns about the hinges that join it to the base, each by its angle times amount: a Crease or a Perforation by 90° away from the printed side, a Partial Cut by 90° toward it. Hinges that close a loop of panels are not turned about: gap is how far apart their two placements end up when every hinge is folded all the way, whatever amount is, and closes is true within tolerance or 0.5% of the hinge's length. Changes nothing in the document → {ok (no error), blank (the index of the blank folded, or null when none is), blanks, base, panels: [{outline (SVG path data, document coordinates), frame: {x, y, z, origin} (where the flat blank's x and y directions, its printed side and its origin go, in points: x right, y up, z toward the printed side of the flat blank), parent (null for the base and loose panels), depth}], hinges: [{a, b, angle (degrees), kind: tree|closing, closes, gap}], collisions: [[a, b]] (panels that pass through each other; panels stacked in one plane do not), issues (as addon.packaging.check)}. Errors: a base point in no panel",
|
||||
has_doc,
|
||||
fold_command
|
||||
)]
|
||||
}
|
||||
|
||||
/// The blanks the shown fold lines of `d` make, and their issues (`addon.packaging.check` on the
|
||||
/// whole document): what the Fold Preview window folds.
|
||||
pub fn fold_source(d: &Document) -> (Vec<Blank>, Vec<Issue>) {
|
||||
found(&document_lines(d), TOLERANCE.1)
|
||||
}
|
||||
|
||||
/// The objects the print on a folded blank leaves out: the layers that do not print and, unless
|
||||
/// `fold_lines`, every object with a line role.
|
||||
pub fn print_hidden(d: &Document, fold_lines: bool) -> Vec<NodeId> {
|
||||
fn walk(n: &Node, table: &RoleTable, fold_lines: bool, out: &mut Vec<NodeId>) {
|
||||
match &n.kind {
|
||||
NodeKind::Layer { printable: false, .. } => out.push(n.id),
|
||||
NodeKind::Layer { children, .. } | NodeKind::Group { children, .. } => children.iter().for_each(|c| walk(c, table, fold_lines, out)),
|
||||
_ if !fold_lines && can_carry(n) && table.role_of(n).is_some() => out.push(n.id),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
let table = RoleTable::of(d);
|
||||
let mut out = vec![];
|
||||
d.layers.iter().for_each(|l| walk(l, &table, fold_lines, &mut out));
|
||||
out
|
||||
}
|
||||
|
||||
fn fold_command(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let tolerance = tolerance(p, FOLD)?;
|
||||
let amount = number_or(p, "amount", 1.0, FOLD)?;
|
||||
if !(0.0..=1.0).contains(&amount) {
|
||||
return Err(bad(FOLD, "`amount` must be from 0 to 1"));
|
||||
}
|
||||
let base = match p.get("base") {
|
||||
None | Some(Value::Null) => None,
|
||||
Some(v) => {
|
||||
let [x, y] = finite_numbers::<2>(v).ok_or_else(|| bad(FOLD, "`base` must be a point: [x, y]"))?;
|
||||
Some(vectorcraft_geom::Point::new(x, y))
|
||||
}
|
||||
};
|
||||
let lines = lines(s, p, FOLD)?;
|
||||
let (blanks, issues) = found(&lines, tolerance);
|
||||
let ok = !issues.iter().any(|i| i.code.is_error());
|
||||
let picked = pick(&blanks, base);
|
||||
if base.is_some() && picked.is_none() {
|
||||
return Err(bad(FOLD, "`base` is in no panel"));
|
||||
}
|
||||
let folded = picked.and_then(|(b, panel)| Some((b, blanks.get(b)?, fold(blanks.get(b)?, Some(panel), amount, tolerance)?)));
|
||||
let Some((index, blank, f)) = folded else {
|
||||
return Ok(json!({
|
||||
"ok": ok, "blank": null, "blanks": blanks.len(), "base": null, "panels": [], "hinges": [], "collisions": [],
|
||||
"issues": issue_rows(&issues, lines.scope),
|
||||
}));
|
||||
};
|
||||
let column = |m: &[[f64; 3]; 3], k: usize| json!([m[0][k], m[1][k], m[2][k]]);
|
||||
let panels: Vec<Value> = blank
|
||||
.panels
|
||||
.iter()
|
||||
.zip(&f.panels)
|
||||
.map(|(panel, placed)| {
|
||||
json!({
|
||||
"outline": panel.outline.to_bezpath().to_svg(),
|
||||
"frame": {"x": column(&placed.pose.m, 0), "y": column(&placed.pose.m, 1), "z": column(&placed.pose.m, 2), "origin": placed.pose.t},
|
||||
"parent": placed.parent,
|
||||
"depth": placed.depth,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
let hinges: Vec<Value> = f
|
||||
.hinges
|
||||
.iter()
|
||||
.map(|h| json!({"a": h.a, "b": h.b, "angle": h.angle, "kind": if h.tree { "tree" } else { "closing" }, "closes": h.closes, "gap": h.gap}))
|
||||
.collect();
|
||||
Ok(json!({
|
||||
"ok": ok,
|
||||
"blank": index,
|
||||
"blanks": blanks.len(),
|
||||
"base": f.base,
|
||||
"panels": panels,
|
||||
"hinges": hinges,
|
||||
"collisions": f.collisions.iter().map(|(a, b)| [a, b]).collect::<Vec<_>>(),
|
||||
"issues": issue_rows(&issues, lines.scope),
|
||||
}))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -0,0 +1,157 @@
|
||||
//! Tests for the Fold Preview's model: a blank drawn in a document folded into its 3D shape.
|
||||
|
||||
use serde_json::{Value, json};
|
||||
|
||||
use crate::*;
|
||||
|
||||
fn session() -> Session {
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", &json!({"width": 600, "height": 600})).unwrap();
|
||||
s
|
||||
}
|
||||
|
||||
fn path(s: &mut Session, d: &str) -> u64 {
|
||||
s.execute("path.create", &json!({ "d": d })).unwrap()["id"].as_u64().unwrap()
|
||||
}
|
||||
|
||||
fn role(s: &mut Session, role: &str, ids: &[u64]) {
|
||||
s.execute("addon.packaging.setRole", &json!({ "role": role, "ids": ids })).unwrap();
|
||||
}
|
||||
|
||||
fn fold(s: &mut Session, p: Value) -> Value {
|
||||
s.execute("addon.packaging.fold", &p).unwrap()
|
||||
}
|
||||
|
||||
/// A tray blank: a 100 pt base (x 140 to 240, y 140 to 240) with a 40 pt wall on each side →
|
||||
/// (outline, creases).
|
||||
fn tray(s: &mut Session) -> (u64, Vec<u64>) {
|
||||
let outline = path(s, "M140 100 L240 100 L240 140 L280 140 L280 240 L240 240 L240 280 L140 280 L140 240 L100 240 L100 140 L140 140 Z");
|
||||
let creases = vec![path(s, "M140 140 L240 140"), path(s, "M240 140 L240 240"), path(s, "M240 240 L140 240"), path(s, "M140 240 L140 140")];
|
||||
role(s, "cut", &[outline]);
|
||||
role(s, "crease", &creases);
|
||||
s.execute("select.none", &json!({})).unwrap();
|
||||
(outline, creases)
|
||||
}
|
||||
|
||||
fn vector(v: &Value) -> [f64; 3] {
|
||||
let a = v.as_array().unwrap();
|
||||
[a[0].as_f64().unwrap(), a[1].as_f64().unwrap(), a[2].as_f64().unwrap()]
|
||||
}
|
||||
|
||||
/// The middle of the bounds of the points of SVG path data `d` (absolute moves and lines only).
|
||||
fn middle(d: &str) -> [f64; 2] {
|
||||
let n: Vec<f64> = d.split(|c: char| !(c.is_ascii_digit() || c == '.' || c == '-')).filter_map(|t| t.parse().ok()).collect();
|
||||
let span = |k: usize| n.iter().skip(k).step_by(2).fold((f64::INFINITY, f64::NEG_INFINITY), |(lo, hi), &t| (lo.min(t), hi.max(t)));
|
||||
let ((x0, x1), (y0, y1)) = (span(0), span(1));
|
||||
[(x0 + x1) / 2.0, (y0 + y1) / 2.0]
|
||||
}
|
||||
|
||||
fn near(a: [f64; 3], b: [f64; 3]) -> bool {
|
||||
a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-9)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_tray_folds_its_walls_up_round_the_base() {
|
||||
let mut s = session();
|
||||
tray(&mut s);
|
||||
let steps = s.doc().unwrap().history.undo.len();
|
||||
let r = fold(&mut s, json!({}));
|
||||
assert_eq!((r["ok"].as_bool(), r["blank"].as_u64(), r["blanks"].as_u64()), (Some(true), Some(0), Some(1)), "{r}");
|
||||
let panels = r["panels"].as_array().unwrap();
|
||||
assert_eq!(panels.len(), 5);
|
||||
let base = r["base"].as_u64().unwrap() as usize;
|
||||
let frame = &panels[base]["frame"];
|
||||
assert!(
|
||||
near(vector(&frame["x"]), [1.0, 0.0, 0.0]) && near(vector(&frame["z"]), [0.0, 0.0, 1.0]) && near(vector(&frame["origin"]), [0.0; 3]),
|
||||
"{frame}"
|
||||
);
|
||||
assert!(panels[base]["parent"].is_null());
|
||||
assert!(panels[base]["outline"].as_str().unwrap().starts_with('M'), "SVG path data");
|
||||
for (i, p) in panels.iter().enumerate().filter(|(i, _)| *i != base) {
|
||||
assert_eq!((p["parent"].as_u64(), p["depth"].as_u64()), (Some(base as u64), Some(1)), "{p}");
|
||||
// Each wall stands square to the base, below it (away from the print), its print facing out:
|
||||
// away from the base's middle (190, 190), toward the side the wall lies on.
|
||||
let [cx, cy] = middle(p["outline"].as_str().unwrap());
|
||||
let (x, y, o) = (vector(&p["frame"]["x"]), vector(&p["frame"]["y"]), vector(&p["frame"]["origin"]));
|
||||
let placed: [f64; 3] = std::array::from_fn(|k| o[k] + x[k] * cx - y[k] * cy);
|
||||
let (dx, dy) = (cx - 190.0, 190.0 - cy);
|
||||
let out = if dx.abs() > dy.abs() { [dx.signum(), 0.0, 0.0] } else { [0.0, dy.signum(), 0.0] };
|
||||
assert!(near(vector(&p["frame"]["z"]), out), "wall {i}: {p}");
|
||||
assert!((placed[2] + 20.0).abs() < 1e-9, "wall {i}'s middle is 20 pt below the base: {placed:?}");
|
||||
}
|
||||
let hinges = r["hinges"].as_array().unwrap();
|
||||
assert_eq!(hinges.len(), 4);
|
||||
assert!(hinges.iter().all(|h| h["kind"] == "tree" && h["angle"] == 90.0 && h["closes"] == true), "{r}");
|
||||
assert_eq!(r["collisions"], json!([]));
|
||||
assert_eq!(s.doc().unwrap().history.undo.len(), steps, "a fold records no undo step");
|
||||
|
||||
// Flat, every frame is the flat blank's own.
|
||||
let r = fold(&mut s, json!({ "amount": 0 }));
|
||||
for p in r["panels"].as_array().unwrap() {
|
||||
assert!(near(vector(&p["frame"]["z"]), [0.0, 0.0, 1.0]) && near(vector(&p["frame"]["origin"]), [0.0; 3]), "{p}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_base_is_the_panel_under_a_point() {
|
||||
let mut s = session();
|
||||
tray(&mut s);
|
||||
// The left wall: x 100 to 140, y 140 to 240.
|
||||
let r = fold(&mut s, json!({ "base": [120, 190] }));
|
||||
let base = r["base"].as_u64().unwrap() as usize;
|
||||
let panels = r["panels"].as_array().unwrap();
|
||||
assert!(near(vector(&panels[base]["frame"]["z"]), [0.0, 0.0, 1.0]));
|
||||
// The tray's base is now a child of the wall, and the other walls its children.
|
||||
let depths: Vec<u64> = panels.iter().map(|p| p["depth"].as_u64().unwrap()).collect();
|
||||
let mut sorted = depths.clone();
|
||||
sorted.sort_unstable();
|
||||
assert_eq!(sorted, [0, 1, 2, 2, 2], "{depths:?}");
|
||||
let e = s.execute("addon.packaging.fold", &json!({ "base": [10, 10] })).unwrap_err().to_string();
|
||||
assert!(e.contains("`base` is in no panel"), "{e}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bad_values_are_refused() {
|
||||
let mut s = session();
|
||||
tray(&mut s);
|
||||
for (p, want) in [
|
||||
(json!({ "amount": 1.5 }), "`amount` must be from 0 to 1"),
|
||||
(json!({ "amount": -0.1 }), "`amount` must be from 0 to 1"),
|
||||
(json!({ "amount": "1" }), "`amount` must be a number"),
|
||||
(json!({ "base": [1] }), "`base` must be a point"),
|
||||
(json!({ "base": "middle" }), "`base` must be a point"),
|
||||
(json!({ "tolerance": 50 }), "`tolerance` must be from"),
|
||||
] {
|
||||
let e = s.execute("addon.packaging.fold", &p).unwrap_err().to_string();
|
||||
assert!(e.contains(want), "{p}: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn without_a_blank_nothing_is_folded_and_the_issues_say_why() {
|
||||
let mut s = session();
|
||||
let r = fold(&mut s, json!({}));
|
||||
assert_eq!((r["ok"].as_bool(), r["blank"].is_null(), r["blanks"].as_u64()), (Some(false), true, Some(0)), "{r}");
|
||||
assert_eq!(r["panels"], json!([]));
|
||||
assert_eq!(r["issues"][0]["code"], "noCut");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_print_leaves_out_fold_lines_and_layers_that_do_not_print() {
|
||||
let mut s = session();
|
||||
let (outline, creases) = tray(&mut s);
|
||||
let art = path(&mut s, "M150 150 L200 150 L200 200 Z");
|
||||
let notes = s.execute("layer.new", &json!({})).unwrap()["id"].as_u64().unwrap();
|
||||
s.execute("layer.setProps", &json!({"id": notes, "printable": false})).unwrap();
|
||||
let d = &s.doc().unwrap().doc;
|
||||
let hidden: Vec<u64> = cmd::print_hidden(d, false).into_iter().map(|id| id.0).collect();
|
||||
for id in creases.iter().chain([&outline, ¬es]) {
|
||||
assert!(hidden.contains(id), "{id} in {hidden:?}");
|
||||
}
|
||||
assert!(!hidden.contains(&art));
|
||||
let shown: Vec<u64> = cmd::print_hidden(d, true).into_iter().map(|id| id.0).collect();
|
||||
assert_eq!(shown, vec![notes], "with the fold lines shown, only the layer is left out");
|
||||
let (blanks, issues) = cmd::fold_source(d);
|
||||
assert_eq!((blanks.len(), blanks[0].panels.len()), (1, 5));
|
||||
assert!(issues.is_empty(), "{issues:?}");
|
||||
}
|
||||
@@ -3,8 +3,8 @@
|
||||
//! anchor edits, Split / Add Points at Crossings, Slide Anchor Along Path, the Corner Tool's corners
|
||||
//! ([`corners`]), the Parametric Shape Tool's shapes ([`shape`]), the Shared Edge Merge Tool's
|
||||
//! merges with Keep Shared Points Together ([`shared_edge`]), Divide into Dashes, Expand Dashes
|
||||
//! into Paths, Trim at Crossings ([`trim`]), Common Tangents ([`tangents`]), Smooth Bridge
|
||||
//! ([`bridge`]) and Tangent Circle
|
||||
//! into Paths, Trim at Crossings ([`trim`]), Smooth Bridge ([`bridge`]), Common Tangents
|
||||
//! ([`tangents`]) and Tangent Circle
|
||||
//! ([`tangent_circle`]).
|
||||
//! Its tools, panels and submenu (Object › Plug-ins › Path Precision Tools) are the tools crate's
|
||||
//! and the UI's.
|
||||
|
||||
@@ -99,7 +99,7 @@ fn tangent_circle(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if found.is_empty() {
|
||||
return Err(bad(COMMAND, "no circle touches these shapes"));
|
||||
}
|
||||
let chosen: Vec<pt::TangentCircle> = match pick {
|
||||
let chosen: Vec<pt::Circle> = match pick {
|
||||
0 => found.clone(),
|
||||
n => match found.get(n - 1) {
|
||||
Some(c) => vec![*c],
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
//! Common Tangents (`addon.pathtools.commonTangents`): the straight lines that touch two selected
|
||||
//! convex closed paths (ellipses at any rotation and scale, and convex Bézier paths) without
|
||||
//! crossing into either, added as separate open paths, with the line joining their centers if
|
||||
//! asked. The geometry is `vectorcraft_pathops::addons::pathtools::common_tangents`.
|
||||
//! asked. One of the two may be a point (a path of one anchor) instead: the lines then run from it
|
||||
//! to where they touch the path. The geometry is `vectorcraft_pathops::addons::pathtools::common_tangents`.
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -30,19 +31,24 @@ pub(super) fn specs() -> Vec<CommandSpec> {
|
||||
"Common Tangents",
|
||||
["Object", "Plug-ins", "Path Precision Tools"],
|
||||
None,
|
||||
"{tangents?: \"external\" (both paths on the same side of each line) | \"internal\" (the lines that run between them) | \"all\" (\"all\"), centerline?: bool (false: true also adds the line joining the two centers, an ellipse's center or a path's center of area), ids?: [id, id] (default: the selection)} add the common tangent lines of two convex closed paths as separate open paths, each from where it touches the first path to where it touches the second (the whole stretch where a straight side lies along it), stroked with the current stroke color and weight (black when the stroke is None) and unfilled, directly above the upper of the two, as one undo step; the new lines are selected. An ellipse drawn with the Ellipse tool, turned or scaled, is measured as an exact ellipse; any other path must be closed, have one outline, bend the same way all around and have at most 10000 segments. Separate paths have two external and two internal tangents; overlapping paths only external ones; one path inside the other has none. Paths that touch, from outside or from inside, share one tangent there instead: a line centered on the point where they touch and as long as the narrower path is wide along it; paths that meet at a corner or along a shared stretch of outline get one such line, at the middle of the directions that touch both. Paths count as touching when the gap between them is less than a billionth of the larger of their sizes and the distance between their centers. When there is no tangent of the kind asked for, nothing changes and the result has a `warning` → {ids, external, internal, centerline (its id or null), warning?}",
|
||||
"{tangents?: \"external\" (both paths on the same side of each line) | \"internal\" (the lines that run between them) | \"all\" (\"all\"), centerline?: bool (false: true also adds the line joining the two centers, an ellipse's center or a path's center of area), ids?: [id, id] (default: the selection)} add the common tangent lines of two convex closed paths as separate open paths, each from where it touches the first path to where it touches the second (the whole stretch where a straight side lies along it), stroked with the current stroke color and weight (black when the stroke is None) and unfilled, directly above the upper of the two, as one undo step; the new lines are selected. An ellipse drawn with the Ellipse tool, turned or scaled, is measured as an exact ellipse; any other path must be closed, have one outline, bend the same way all around and have at most 10000 segments. Separate paths have two external and two internal tangents; overlapping paths only external ones; one path inside the other has none. Paths that touch, from outside or from inside, share one tangent there instead: a line centered on the point where they touch and as long as the narrower path is wide along it; paths that meet at a corner or along a shared stretch of outline get one such line, at the middle of the directions that touch both. Paths count as touching when the gap between them is less than a billionth of the larger of their sizes and the distance between their centers. One of the two may be a point (a path of one anchor): the lines then run from the point to where they touch the path, two when the point lies outside it (one that lies along a straight side covers the whole side), one when the point lies on its outline, that is, less than the touching tolerance from it, with the point's distance from the path's center in place of the distance between centers (centered on the point and as long as the path is wide along it, or the whole straight side the point lies on), none when it lies inside; every `tangents` value gives the same lines, counted as internal when `tangents` is \"internal\" and as external otherwise, and the centerline runs from the point to the path's center; two points are refused. When there is no tangent of the kind asked for, nothing changes and the result has a `warning` → {ids, external, internal, centerline (its id or null), warning?}",
|
||||
has_selection,
|
||||
common_tangents
|
||||
)]
|
||||
}
|
||||
|
||||
/// The outline of path `id` as the geometry takes it: an exact ellipse for a whole live ellipse,
|
||||
/// else the path's one closed convex subpath.
|
||||
/// The outline of path `id` as the geometry takes it: a point for a path of one anchor, an exact
|
||||
/// ellipse for a whole live ellipse, else the path's one closed convex subpath.
|
||||
fn outline_of(d: &Document, id: NodeId) -> Result<pt::Outline> {
|
||||
const C: &str = COMMON_TANGENTS;
|
||||
let n = d.node(id).ok_or(EngineError::NoNode(id))?;
|
||||
let NodeKind::Path { path, live, .. } = &n.kind else { return Err(bad(C, "select two closed paths")) };
|
||||
let [sp] = path.subpaths.as_slice() else { return Err(bad(C, "select two closed paths")) };
|
||||
if sp.anchors.len() == 1
|
||||
&& let Some(only) = sp.anchors.first()
|
||||
{
|
||||
return pt::Outline::point(only.p).map_err(refusal);
|
||||
}
|
||||
if let Some(LiveShape::Ellipse { w, h, pie, xf }) = live.as_deref() {
|
||||
let span = (pie.1 - pie.0).rem_euclid(360.0);
|
||||
if span < 1e-9 || 360.0 - span < 1e-9 {
|
||||
@@ -74,17 +80,36 @@ fn common_tangents(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let ordered = d.paint_order(roots.iter().copied());
|
||||
let [first, second] = ordered.as_slice() else { return Err(bad(C, "select two closed paths")) };
|
||||
let (a, b) = (outline_of(d, *first)?, outline_of(d, *second)?);
|
||||
if a.is_point() && b.is_point() {
|
||||
return Err(bad(C, "select two closed paths"));
|
||||
}
|
||||
// A point goes first, so that each line runs from it to where it touches the path.
|
||||
let point = a.is_point() || b.is_point();
|
||||
let (a, b) = if b.is_point() { (b, a) } else { (a, b) };
|
||||
let all = pt::common_tangents(&a, &b).map_err(|_| bad(C, "the two paths have the same outline"))?;
|
||||
let external = all.iter().filter(|t| t.kind == pt::TangentKind::External).count();
|
||||
let keep = |t: &&pt::Tangent| match kinds {
|
||||
"external" => t.kind == pt::TangentKind::External,
|
||||
"internal" => t.kind == pt::TangentKind::Internal,
|
||||
_ => true,
|
||||
// A point's external and internal tangents are the same lines: every kind keeps them.
|
||||
let keep = |t: &&pt::Tangent| {
|
||||
point
|
||||
|| match kinds {
|
||||
"external" => t.kind == pt::TangentKind::External,
|
||||
"internal" => t.kind == pt::TangentKind::Internal,
|
||||
_ => true,
|
||||
}
|
||||
};
|
||||
let kept: Vec<&pt::Tangent> = all.iter().filter(keep).collect();
|
||||
let count = |kind: pt::TangentKind| kept.iter().filter(|t| t.kind == kind).count();
|
||||
let (external_kept, internal_kept) = (count(pt::TangentKind::External), count(pt::TangentKind::Internal));
|
||||
let (external_kept, internal_kept) = match (point, kinds) {
|
||||
(true, "internal") => (0, kept.len()),
|
||||
(true, _) => (kept.len(), 0),
|
||||
_ => (count(pt::TangentKind::External), count(pt::TangentKind::Internal)),
|
||||
};
|
||||
let lines: Vec<(Point, Point)> = kept.iter().map(|t| (t.from, t.to)).collect();
|
||||
if lines.is_empty() && point {
|
||||
// Written as `EngineError::Other` so that the i18n message scan finds it.
|
||||
let warning = EngineError::Other("The point lies inside the path, so it has no tangents".into());
|
||||
return Ok(json!({ "ids": [], "external": 0, "internal": 0, "centerline": null, "warning": warning.to_string() }));
|
||||
}
|
||||
if lines.is_empty() {
|
||||
// Written as `EngineError::Other` so that the i18n message scan finds them. Exactly one
|
||||
// external tangent means one path lies inside the other and touches it there; paths that
|
||||
|
||||
@@ -248,6 +248,84 @@ fn nested_and_overlapping_paths_change_nothing_and_say_why() {
|
||||
assert_eq!((r["external"].as_u64(), r["internal"].as_u64()), (Some(1), Some(0)), "{r}");
|
||||
}
|
||||
|
||||
fn point(s: &mut Session, x: f64, y: f64) -> NodeId {
|
||||
id_of(&s.execute("path.create", &json!({"anchors": [{"x": x, "y": y}]})).unwrap())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_point_and_an_ellipse_get_the_two_lines_from_the_point_and_the_centerline() {
|
||||
let mut s = session();
|
||||
// The point is drawn after the oval, so it is the upper object; the lines still start at it.
|
||||
let oval = id_of(&s.execute("shape.ellipse", &json!({"x": 260, "y": 170, "width": 80, "height": 60})).unwrap());
|
||||
let dot = point(&mut s, 100.0, 200.0);
|
||||
select(&mut s, &[oval, dot]);
|
||||
let before = steps(&s);
|
||||
let r = s.execute(C, &json!({"centerline": true})).unwrap();
|
||||
assert_eq!((r["external"].as_u64(), r["internal"].as_u64()), (Some(2), Some(0)), "{r}");
|
||||
assert_eq!(steps(&s), before + 1);
|
||||
let found = lines(&s, &r);
|
||||
assert_eq!(found.len(), 3, "two tangents and the centerline");
|
||||
let (p, c) = (Point::new(100.0, 200.0), Point::new(300.0, 200.0));
|
||||
// From (-200, 0) to an ellipse with semi-axes 40 and 30 about the origin: the touching points
|
||||
// are x = -a²/200 = -8, y = ±b √(1 - x²/a²).
|
||||
let y = 30.0 * (1.0f64 - (8.0f64 / 40.0).powi(2)).sqrt();
|
||||
for sy in [1.0, -1.0] {
|
||||
let touch = c + Vec2::new(-8.0, sy * y);
|
||||
assert!(found[..2].iter().any(|(a, b)| near(*a, p) && near(*b, touch)), "{touch:?} in {found:?}");
|
||||
}
|
||||
assert_eq!(r["centerline"], r["ids"][2]);
|
||||
assert!(near(found[2].0, p) && near(found[2].1, c), "{:?}", found[2]);
|
||||
// Every `tangents` value gives the same two lines.
|
||||
for (kind, external, internal) in [("external", 2, 0), ("internal", 0, 2)] {
|
||||
let r = s.execute(C, &json!({"ids": [oval.0, dot.0], "tangents": kind})).unwrap();
|
||||
assert_eq!((r["external"].as_u64(), r["internal"].as_u64()), (Some(external), Some(internal)), "{kind}: {r}");
|
||||
assert_eq!(lines(&s, &r).len(), 2, "{kind}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_point_below_the_path_still_starts_the_lines() {
|
||||
let mut s = session();
|
||||
// The point is drawn first, so it is the lower object and needs no swap.
|
||||
let dot = point(&mut s, 100.0, 200.0);
|
||||
let round = circle(&mut s, 300.0, 200.0, 50.0);
|
||||
let r = s.execute(C, &json!({"ids": [round.0, dot.0], "centerline": true})).unwrap();
|
||||
assert_eq!((r["external"].as_u64(), r["internal"].as_u64()), (Some(2), Some(0)), "{r}");
|
||||
let found = lines(&s, &r);
|
||||
assert_eq!(found.len(), 3, "two tangents and the centerline");
|
||||
let p = Point::new(100.0, 200.0);
|
||||
assert!(found.iter().all(|(a, _)| near(*a, p)), "every line starts at the point: {found:?}");
|
||||
// From 200 away to a circle of radius 50, each tangent is √(200² - 50²) long.
|
||||
let length = (200.0f64 * 200.0 - 50.0 * 50.0).sqrt();
|
||||
assert!(found[..2].iter().all(|(a, b)| (a.distance(*b) - length).abs() < 1e-6), "{found:?}");
|
||||
assert!(near(found[2].1, Point::new(300.0, 200.0)), "{:?}", found[2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_point_on_or_inside_a_path_and_two_points() {
|
||||
let mut s = session();
|
||||
let round = circle(&mut s, 200.0, 200.0, 50.0);
|
||||
// On the circle: one line, centered on the point and as long as the circle is wide.
|
||||
let on = point(&mut s, 250.0, 200.0);
|
||||
let r = s.execute(C, &json!({"ids": [round.0, on.0]})).unwrap();
|
||||
assert_eq!(r["external"].as_u64(), Some(1), "{r}");
|
||||
let (p, q) = lines(&s, &r)[0];
|
||||
assert!((p.x - 250.0).abs() < 1e-5 && (q.x - 250.0).abs() < 1e-5 && (p.distance(q) - 100.0).abs() < 1e-5, "{p:?} {q:?}");
|
||||
// Inside: nothing changes, and the warning says why.
|
||||
let inside = point(&mut s, 210.0, 190.0);
|
||||
let before = (steps(&s), s.doc().unwrap().doc.node_count());
|
||||
let r = s.execute(C, &json!({"ids": [round.0, inside.0], "centerline": true})).unwrap();
|
||||
assert_eq!(r["ids"], json!([]));
|
||||
assert!(r["warning"].as_str().unwrap().contains("point lies inside the path"), "{r}");
|
||||
assert_eq!((steps(&s), s.doc().unwrap().doc.node_count()), before, "nothing changes");
|
||||
// Two points, or a point and an open path, are refused.
|
||||
let err = |s: &mut Session, p: Value| s.execute(C, &p).unwrap_err().to_string();
|
||||
assert!(err(&mut s, json!({"ids": [on.0, inside.0]})).contains("select two closed paths"));
|
||||
let open = id_of(&s.execute("path.create", &json!({"anchors": [{"x": 0, "y": 0}, {"x": 50, "y": 0}, {"x": 50, "y": 50}]})).unwrap());
|
||||
assert!(err(&mut s, json!({"ids": [open.0, on.0]})).contains("open"));
|
||||
assert_eq!((steps(&s), s.doc().unwrap().doc.node_count()), (before.0 + 1, before.1 + 1), "only the open path was added");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bad_selections_and_params_are_refused() {
|
||||
let mut s = session();
|
||||
|
||||
@@ -172,6 +172,7 @@ pub const BUILTIN: &[BuiltinBrushLibrary] = &[
|
||||
BuiltinBrushLibrary { id: "art-ribbons", name: "Art Ribbons", make: art_ribbons },
|
||||
BuiltinBrushLibrary { id: "ink-and-wash", name: "Ink and Wash", make: ink_and_wash },
|
||||
BuiltinBrushLibrary { id: "calligraphic-nibs", name: "Calligraphic Nibs", make: calligraphic_nibs },
|
||||
BuiltinBrushLibrary { id: "pressure-sensitive", name: "Pressure Sensitive", make: pressure_sensitive },
|
||||
BuiltinBrushLibrary { id: "bristle-brushes", name: "Bristle Brushes", make: bristle_brushes },
|
||||
BuiltinBrushLibrary { id: "pattern-borders", name: "Pattern Borders", make: pattern_borders },
|
||||
BuiltinBrushLibrary { id: "scatter-shapes", name: "Scatter Shapes", make: scatter_shapes },
|
||||
@@ -374,6 +375,47 @@ fn bristle(name: &str, shape: BristleShape, [size, length, density, thickness, o
|
||||
Brush { name: name.into(), kind: BrushKind::Bristle(Bristle { shape, size, length, density, thickness, opacity, stiffness }) }
|
||||
}
|
||||
|
||||
/// Pressure Sensitive: four original marks whose art width or nib size responds to recorded pen
|
||||
/// pressure. Mouse paths keep the engine's neutral middle-pressure rendering.
|
||||
fn pressure_sensitive() -> BrushLibrary {
|
||||
let flex = black(band(100.0, 5.0, 48, |x| 0.5 * (x / 100.0 * std::f64::consts::TAU).sin()));
|
||||
let pulse = group(vec![
|
||||
black(band(100.0, 2.8, 64, |x| 1.4 * (x / 100.0 * 2.0 * std::f64::consts::TAU).sin())),
|
||||
black(shapes::ellipse(Rect::new(46.0, -2.2, 54.0, 2.2))),
|
||||
]);
|
||||
let art_pressure = |name: &str, art: Node, light: f64, heavy: f64| Brush {
|
||||
name: name.into(),
|
||||
kind: BrushKind::Art(ArtBrush {
|
||||
art,
|
||||
width: light,
|
||||
width_mode: Some(Variation::Pressure),
|
||||
width_max: Some(heavy),
|
||||
colorization: Colorization::Tints,
|
||||
..Default::default()
|
||||
}),
|
||||
};
|
||||
let nib_pressure = |name: &str, angle: f64, roundness: f64, size: f64, variation: f64| Brush {
|
||||
name: name.into(),
|
||||
kind: BrushKind::Calligraphic(Calligraphic {
|
||||
angle,
|
||||
roundness,
|
||||
size,
|
||||
variation: [0.0, 0.0, variation],
|
||||
modes: Some([Variation::Fixed, Variation::Fixed, Variation::Pressure]),
|
||||
}),
|
||||
};
|
||||
built(
|
||||
"Pressure Sensitive",
|
||||
Document::new(100.0, 100.0),
|
||||
vec![
|
||||
art_pressure("Flex Ribbon", flex, 35.0, 250.0),
|
||||
art_pressure("Pulse Stroke", pulse, 45.0, 280.0),
|
||||
nib_pressure("Round Flow", 0.0, 100.0, 7.0, 5.0),
|
||||
nib_pressure("Chisel Flow", 35.0, 25.0, 9.0, 7.0),
|
||||
],
|
||||
)
|
||||
}
|
||||
|
||||
/// Bristle Brushes: one bristle brush for each tip shape, from a fine liner to wide fans for
|
||||
/// blending and texture.
|
||||
fn bristle_brushes() -> BrushLibrary {
|
||||
|
||||
@@ -165,7 +165,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Brush Options…",
|
||||
[],
|
||||
None,
|
||||
"{name, params?: {…fields to change (brush.get shows them; values outside their ranges are clamped). calligraphic: angle −180..180° (counter-clockwise from level), roundness 0..100%, size 0..1296 pt, variation: [angle°, roundness%, size pt], modes: [fixed|random|pressure|tilt|bearing|rotation for angle, roundness, size] (pressure goes from value − variation at the lightest pen pressure to value + variation at the heaviest; tilt from value − variation with the pen lying flat to value + variation with it upright; bearing and rotation add variation × the pen's bearing (which way it leans, counter-clockwise from leaning right) or its barrel's counter-clockwise rotation over 180°; the angle turns on past ±180°). scatter: size [a, b] 1..10000%, spacing [a, b] 1..10000%, scatter [a, b] −1000..1000%, rotation [a, b] −180..180° (counter-clockwise), modes: [fixed|random|pressure|tilt|bearing|rotation for size, spacing, scatter, rotation] (fixed: a; random: between a and b; pressure: a at the lightest pen pressure to b at the heaviest; tilt: a with the pen lying flat to b upright; bearing and rotation: a at −180° to b at 180°), rotation_relative_to_path. art: width 1..1000%, width_mode: null (fixed)|pressure|tilt|bearing|rotation, width_max 1..1000% (pressure: width at the lightest pen pressure to width_max at the heaviest; tilt: width with the pen lying flat to width_max upright; bearing and rotation: width at −180° to width_max at 180°; half way on a stroke drawn without that input), scale: {mode: proportional|stretch|betweenGuides, start, end: 0..1 of the art length}, direction: leftToRight|rightToLeft|topToBottom|bottomToTop, flip_along, flip_across, overlap. pattern: scale 1..10000%, spacing 0..10000%, fit: stretch|addSpace|approximate, flip_along, flip_across, outer_corner and inner_corner: corner tile art (drawn as the corner that joins a side tile on its right to one below it) or null, outer_source and inner_source: what that kind of corner draws without its art: none|autoCentered|autoBetween|autoSliced|autoOverlap (a tile made from the side tile), or null (the other kind of corner's art); side_tile, outer_corner_tile, inner_corner_tile, start_tile, end_tile: a document pattern name, original, or none (side refuses none); corner tiles also take autoCentered|autoBetween|autoSliced|autoOverlap. Each tile also accepts {pattern: name} to select a swatch whose name is a reserved choice. scatter, art and pattern: colorization: {method: none|tints|tintsAndShades|hueShift, key: colour (hueShift: the art colour that becomes the stroke colour; without a key: the solid color the art's fills and strokes use most, black when they use none)}; colorization and the art brush's scale change only the fields given}, newName? (trimmed; blank: the name is kept; a new bristle brush name has at most 31 characters, and a longer name the brush has is kept)} edit a brush definition (strokes using it update) → {name}",
|
||||
"{name, params?: {…fields to change (brush.get shows them; values outside their ranges are clamped). calligraphic: angle −180..180° (counter-clockwise from level), roundness 0..100%, size 0..1296 pt, variation: [angle°, roundness%, size pt], modes: [fixed|random|pressure|tilt|bearing|rotation for angle, roundness, size] (pressure goes from value − variation at the lightest pen pressure to value + variation at the heaviest; tilt from value − variation with the pen lying flat to value + variation with it upright; bearing and rotation add variation × the pen's bearing (which way it leans, counter-clockwise from leaning right) or its barrel's counter-clockwise rotation over 180°; the angle turns on past ±180°). scatter: size [a, b] 1..10000%, spacing [a, b] 1..10000%, scatter [a, b] −1000..1000%, rotation [a, b] −180..180° (counter-clockwise), modes: [fixed|random|pressure|tilt|bearing|rotation for size, spacing, scatter, rotation] (fixed: a; random: between a and b; pressure: a at the lightest pen pressure to b at the heaviest; tilt: a with the pen lying flat to b upright; bearing and rotation: a at −180° to b at 180°), rotation_relative_to_path, hue_jitter 0..180° (each copy turns the hue of its solid colors, after the colorization, by its own amount up to this far either way, the same on every redraw; colors without a hue stay; 0: off). art: width 1..1000%, width_mode: null (fixed)|pressure|tilt|bearing|rotation, width_max 1..1000% (pressure: width at the lightest pen pressure to width_max at the heaviest; tilt: width with the pen lying flat to width_max upright; bearing and rotation: width at −180° to width_max at 180°; half way on a stroke drawn without that input), scale: {mode: proportional|stretch|betweenGuides, start, end: 0..1 of the art length}, direction: leftToRight|rightToLeft|topToBottom|bottomToTop, flip_along, flip_across, overlap. pattern: scale 1..10000%, spacing 0..10000%, fit: stretch|addSpace|approximate, flip_along, flip_across, outer_corner and inner_corner: corner tile art (drawn as the corner that joins a side tile on its right to one below it) or null, outer_source and inner_source: what that kind of corner draws without its art: none|autoCentered|autoBetween|autoSliced|autoOverlap (a tile made from the side tile), or null (the other kind of corner's art); side_tile, outer_corner_tile, inner_corner_tile, start_tile, end_tile: a document pattern name, original, or none (side refuses none); corner tiles also take autoCentered|autoBetween|autoSliced|autoOverlap. Each tile also accepts {pattern: name} to select a swatch whose name is a reserved choice. scatter, art and pattern: colorization: {method: none|tints|tintsAndShades|hueShift, key: colour (hueShift: the art colour that becomes the stroke colour; without a key: the solid color the art's fills and strokes use most, black when they use none)}; colorization and the art brush's scale change only the fields given}, newName? (trimmed; blank: the name is kept; a new bristle brush name has at most 31 characters, and a longer name the brush has is kept)} edit a brush definition (strokes using it update) → {name}",
|
||||
has_doc,
|
||||
brush_options
|
||||
),
|
||||
@@ -211,7 +211,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"New Symbol…",
|
||||
[],
|
||||
None,
|
||||
"{name?, ids?|id?, registration?: 0..8 (9-point grid, 4 = centre; Symbol Options › Registration), exportType?: movieClip (default)|graphic, nineSlice?: bool, nineSliceGuides?: array, type?: static (default)|dynamic (Symbol Options › Symbol Type), alignToPixelGrid?: bool (default false; Symbol Options › Align to Pixel Grid)} make a symbol from the selection and replace it with an instance; a frame of threaded text in the selection leaves its thread with the text it shows, which the symbol's art holds; nineSlice is Symbol Options › Enable Guides for 9-Slice Scaling, nineSliceGuides [left, top, right, bottom] as fractions of the natural size in from each edge, each -16..16 (below 0 or above 1 puts a guide outside the art), with left + right < 1 and top + bottom < 1 (default a quarter each); an instance of a symbol with guides keeps its corners' size when scaled, its edges stretch along their length and its center in both directions; alignToPixelGrid keeps the symbol's instances on the pixel grid as symbol.options describes → {name, id, registration, exportType, nineSlice, type, alignToPixelGrid}",
|
||||
"{name?, ids?|id?, registration?: 0..8 (9-point grid, 4 = centre; Symbol Options › Registration), exportType?: movieClip (default)|graphic, nineSlice?: bool, nineSliceGuides?: array, type?: static (default)|dynamic (Symbol Options › Symbol Type), alignToPixelGrid?: bool (default false; Symbol Options › Align to Pixel Grid), keepArt?: false} make a symbol from the selection and replace it with an instance, or with keepArt: true leave the selection as ordinary art where it is, still selected, with id null; a frame of threaded text in the selection that becomes an instance leaves its thread with the text it shows, which the symbol's art holds; nineSlice is Symbol Options › Enable Guides for 9-Slice Scaling, nineSliceGuides [left, top, right, bottom] as fractions of the natural size in from each edge, each -16..16 (below 0 or above 1 puts a guide outside the art), with left + right < 1 and top + bottom < 1 (default a quarter each); an instance of a symbol with guides keeps its corners' size when scaled, its edges stretch along their length and its center in both directions; alignToPixelGrid keeps the symbol's instances on the pixel grid as symbol.options describes → {name, id, registration, exportType, nineSlice, type, alignToPixelGrid}",
|
||||
has_selection,
|
||||
symbol_new
|
||||
),
|
||||
@@ -265,7 +265,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Redefine Symbol",
|
||||
[],
|
||||
None,
|
||||
"{name, ids?|id?} replace the symbol's art with the selection (instances update, keeping their appearance changes to the objects at paths the new art still has; the selection becomes an instance; a frame of threaded text in the selection leaves its thread with the text it shows, which the symbol's art holds) → {name, id}",
|
||||
"{name, ids?|id?, keepArt?: false} replace the symbol's art with the selection (instances update, keeping their appearance changes to the objects at paths the new art still has; the selection becomes an instance, or with keepArt: true stays ordinary art where it is, still selected, and id is null; a frame of threaded text in the selection that becomes an instance leaves its thread with the text it shows, which the symbol's art holds; art that holds an instance of the symbol (opacity masks included), directly or through the symbols it nests, is refused) → {name, id}",
|
||||
has_selection,
|
||||
symbol_update
|
||||
),
|
||||
|
||||
@@ -32,7 +32,12 @@ pub(super) fn brush_list(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
pub(super) fn brush_get(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let name = name_param(p, "brush.get")?;
|
||||
let b = brush::find(&s.doc()?.doc, name).ok_or_else(|| EngineError::Other(format!("no brush named `{name}`")))?;
|
||||
Ok(serde_json::to_value(b).unwrap_or_default())
|
||||
let mut v = serde_json::to_value(&b).unwrap_or_default();
|
||||
// A scatter brush saves its hue jitter only when it is not 0; brush.get shows it either way.
|
||||
if let (BrushKind::Scatter(sc), Some(o)) = (&b.kind, v.as_object_mut()) {
|
||||
o.entry("hue_jitter").or_insert(json!(sc.hue_jitter));
|
||||
}
|
||||
Ok(v)
|
||||
}
|
||||
|
||||
/// The art `brush.new` takes from `ids` or `id`, else from the selection ([`selection_art`]).
|
||||
|
||||
@@ -253,6 +253,9 @@ pub(super) fn symbol_new(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let nine = nine_slice_param(p, C, None)?.flatten();
|
||||
let dynamic = type_param(p, C)?.unwrap_or(false);
|
||||
let pixel = pixel_grid_param(p, C)?.unwrap_or(false);
|
||||
// `keepArt` leaves the art as ordinary art instead of replacing it with an instance.
|
||||
let keep_art = switch_or(p, "keepArt", false, C)?;
|
||||
let iso = s.doc()?.isolation;
|
||||
// Keep the art where it was: the geometric centre stays at `c`, whatever the registration is.
|
||||
let place = place_xf(c + reg.offset_from_center(size.0, size.1), size, reg);
|
||||
let id = s.edit("New Symbol", |d, sel| {
|
||||
@@ -264,13 +267,20 @@ pub(super) fn symbol_new(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
d.set_symbol_export_type(&name, export);
|
||||
d.set_symbol_nine_slice(&name, nine);
|
||||
d.set_symbol_pixel_aligned(&name, pixel);
|
||||
if keep_art {
|
||||
// The art stays where it is and stays selected, apart from art that is hidden or
|
||||
// locked, in a hidden or locked group or layer, or on a locked artboard.
|
||||
let locks = d.locked_artboards();
|
||||
sel.set(ids.iter().copied().filter(|i| crate::cmd::select::is_selectable(d, iso, &locks, *i)));
|
||||
return Ok(None);
|
||||
}
|
||||
let id = instance_in_place(d, &ids, &name, place)?;
|
||||
sel.set([id]);
|
||||
Ok(id)
|
||||
Ok(Some(id))
|
||||
})?;
|
||||
Ok(json!({
|
||||
"name": name,
|
||||
"id": id.0,
|
||||
"id": id.map(|i| i.0),
|
||||
"registration": reg.0,
|
||||
"exportType": export.id(),
|
||||
"nineSlice": nine.map_or(Value::Null, SymbolNineSlice::to_value),
|
||||
@@ -612,6 +622,8 @@ pub(super) fn symbol_update(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
// Redefining the symbol being edited leaves symbol editing mode in the same step.
|
||||
let session = s.doc()?.doc.symbol_edit.clone().filter(|e| e.symbol == name);
|
||||
// `keepArt` leaves the art as ordinary art instead of replacing it with an instance.
|
||||
let keep_art = switch_or(p, "keepArt", false, C)?;
|
||||
if session.is_some() {
|
||||
crate::cmd::settle_interaction(s)?;
|
||||
s.end_text_edit();
|
||||
@@ -625,10 +637,20 @@ pub(super) fn symbol_update(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
}
|
||||
let mut art = selection_art(s, p)?.ok_or_else(|| EngineError::Other("nothing selected".into()))?;
|
||||
// Nor can art that holds an instance of it, directly or through the symbols it nests.
|
||||
if crate::cmd::symboledit::holds_symbol(&s.doc()?.doc, &art, &name, &mut Default::default()) {
|
||||
return Err(EngineError::Other("a symbol can't hold an instance of itself".into()));
|
||||
}
|
||||
crate::cmd::threads::keep_shown_text(&s.doc()?.doc, &mut art);
|
||||
let (art, size, c) = normalize(art)?;
|
||||
let old = natural_size(&s.doc()?.doc, &name);
|
||||
let editing = session.is_some();
|
||||
// The isolation the kept art is selected in: the one from before symbol editing mode when
|
||||
// the step leaves it.
|
||||
let iso = match &session {
|
||||
Some(se) => se.back_isolation,
|
||||
None => s.doc()?.isolation,
|
||||
};
|
||||
let id = s.edit("Redefine Symbol", |d, sel| {
|
||||
if editing {
|
||||
crate::cmd::symboledit::finish(d, sel);
|
||||
@@ -647,15 +669,22 @@ pub(super) fn symbol_update(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
// Each instance keeps its appearance changes to the objects the new art still has.
|
||||
fit_overrides(d, &instances);
|
||||
if keep_art {
|
||||
// The art stays where it is and stays selected, apart from art that is hidden or
|
||||
// locked, in a hidden or locked group or layer, or on a locked artboard.
|
||||
let locks = d.locked_artboards();
|
||||
sel.set(ids.iter().copied().filter(|i| crate::cmd::select::is_selectable(d, iso, &locks, *i)));
|
||||
return Ok(None);
|
||||
}
|
||||
let reg = d.symbol_registration(&name);
|
||||
let id = instance_in_place(d, &ids, &name, place_xf(c + reg.offset_from_center(size.0, size.1), size, reg))?;
|
||||
sel.set([id]);
|
||||
Ok(id)
|
||||
Ok(Some(id))
|
||||
})?;
|
||||
if let Some(se) = &session {
|
||||
crate::cmd::symboledit::leave_editing(s, se)?;
|
||||
}
|
||||
Ok(json!({ "name": name, "id": id.0 }))
|
||||
Ok(json!({ "name": name, "id": id.map(|i| i.0) }))
|
||||
}
|
||||
|
||||
/// How many levels of nested instances Delete Symbol expands before it gives up.
|
||||
|
||||
@@ -121,7 +121,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Separations Preview",
|
||||
[],
|
||||
None,
|
||||
"{on?: bool, plates?: [names], toggle?: plate, only?: plate} Separations Preview: show the chosen plates (one plate = greyscale ink coverage) → {on, plates: [{name, spot, visible, rgb}]}",
|
||||
"{on?: bool, plates?: [names], toggle?: plate, only?: plate, soloToggle?: plate (only that plate, or every plate when it is the only one shown)} Separations Preview: show the chosen plates (one plate = grayscale ink coverage) → {on, plates: [{name, spot, visible, rgb}]}",
|
||||
always,
|
||||
separations
|
||||
),
|
||||
@@ -1055,6 +1055,13 @@ fn separations(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if let Some(n) = text_param(p, "only", C)? {
|
||||
v.separations = Some(vec![check(n)?]);
|
||||
}
|
||||
// The panel's Alt-click on a plate's eye: that plate alone, or every plate when it already
|
||||
// shows alone among the active document's plates.
|
||||
if let Some(n) = text_param(p, "soloToggle", C)? {
|
||||
let n = check(n)?;
|
||||
let alone = v.separations.as_ref().is_some_and(|vis| all.iter().filter(|a| vis.contains(a)).eq([&n]));
|
||||
v.separations = Some(if alone { all.clone() } else { vec![n] });
|
||||
}
|
||||
if let Some(n) = text_param(p, "toggle", C)? {
|
||||
let n = check(n)?;
|
||||
let vis = v.separations.get_or_insert_with(|| all.clone());
|
||||
|
||||
@@ -62,7 +62,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Circle Through Points",
|
||||
[],
|
||||
None,
|
||||
"{points?: [[x, y], [x, y], [x, y]] (left out: the three selected anchor points, where a path selected whole counts all its anchors and selected segments' ends do not count)} → {id, cx, cy, radius}: a circle with the current paint whose edge passes through the three points, not pixel-aligned even while Align New Objects to Pixel Grid is on; two points that are the same or three on one line are an error, and nothing is drawn",
|
||||
"{points?: [[x, y], [x, y]] or [[x, y], [x, y], [x, y]] (two: the ends of a diameter; left out: the two or three selected anchor points, where a path selected whole counts all its anchors and selected segments' ends do not count)} → {id, cx, cy, radius}: a circle with the current paint whose edge passes through the points, not pixel-aligned even while Align New Objects to Pixel Grid is on; two points that are the same, three on one line, or a circle reaching past the canvas are an error, and nothing is drawn",
|
||||
has_doc,
|
||||
circle_through_points
|
||||
),
|
||||
@@ -126,7 +126,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Create Text",
|
||||
[],
|
||||
None,
|
||||
"{x, y, text, rotation?: deg clockwise about x, y (0: level), vertical?: bool = false, size?: pt 0.1..1296 (outside it: an error, and no type is made), font?: family, style? (default Regular, or the family's closest style when it has no Regular), color? (#rrggbbaa and #rgba are refused), keepModel?: bool (as paint.setFill), area?: {width, height, fit?: none|autoHeight|shrinkText|block, fitMinPercent?, wordGap?, lineGap? (as text.areaOptions)}, placeholder?: bool (fill it with placeholder text instead, as the Type tools do with prefs placeholderText), justify?: \"auto\" (default: the start of each paragraph's direction)|\"left\"|\"center\"|\"right\"|\"justifyAll\" (point type: aligned on x, so \"center\" centres each line on the point and \"right\" ends it there; text.setStyle changes it later), leadingModel?: \"romanBaseline\"|\"emBoxTop\", charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\"|\"icfTop\"|\"icfBottom\" (default: emBoxTop and emBoxCenter while the interface is in Japanese, else romanBaseline)} → {id, bounds: {x, y, width, height} (the new type's box as document.inspect reports it, after justify), overflow?: [id] (area type whose text doesn't fit its frame: the lines past it aren't drawn; left out when it fits), warning?: text (the font or style given isn't available: the type is drawn in the fallback font or the family's closest style)}; new area type gets Auto Size (fit autoHeight) when the autoSizeAreaType preference is on",
|
||||
"{x, y, text, rotation?: deg clockwise about x, y (0: level), vertical?: bool = false, size?: pt 0.1..1296 (outside it: an error, and no type is made), font?: family, style? (default Regular, or the family's closest style when it has no Regular), color? (#rrggbbaa and #rgba are refused; size, font, style and color left out come from [Normal Character Style], the defaults unless the document redefined it), keepModel?: bool (as paint.setFill), area?: {width, height, fit?: none|autoHeight|shrinkText|block, fitMinPercent?, wordGap?, lineGap? (as text.areaOptions)}, placeholder?: bool (fill it with placeholder text instead, as the Type tools do with prefs placeholderText), justify?: \"auto\" (default: the start of each paragraph's direction)|\"left\"|\"center\"|\"right\"|\"justifyAll\" (point type: aligned on x, so \"center\" centres each line on the point and \"right\" ends it there; text.setStyle changes it later), leadingModel?: \"romanBaseline\"|\"emBoxTop\", charAlign?: \"romanBaseline\"|\"emBoxTop\"|\"emBoxCenter\"|\"emBoxBottom\"|\"icfTop\"|\"icfBottom\" (default: emBoxTop and emBoxCenter while the interface is in Japanese, else romanBaseline)} → {id, bounds: {x, y, width, height} (the new type's box as document.inspect reports it, after justify), overflow?: [id] (area type whose text doesn't fit its frame: the lines past it aren't drawn; left out when it fits), warning?: text (the font or style given isn't available: the type is drawn in the fallback font or the family's closest style)}; new area type gets Auto Size (fit autoHeight) when the autoSizeAreaType preference is on",
|
||||
has_doc,
|
||||
text_create
|
||||
),
|
||||
@@ -413,16 +413,16 @@ fn ellipse(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
add_art_turned(s, "Ellipse", path_kind(live.to_path(), Some(live)), rotation)
|
||||
}
|
||||
|
||||
/// A live ellipse whose edge passes through three points: `points`, or the three selected anchor
|
||||
/// points ([`selected_anchor_points`]). One undo step, named as an Ellipse tool drag is.
|
||||
/// A live ellipse whose edge passes through two or three points: `points`, or the two or three
|
||||
/// selected anchor points ([`selected_anchor_points`]). Two points are the ends of a diameter. One
|
||||
/// undo step, named as an Ellipse tool drag is.
|
||||
fn circle_through_points(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
const C: &str = "shape.circleThroughPoints";
|
||||
let points = match p.get("points").filter(|v| !v.is_null()) {
|
||||
Some(v) => three_points(v).ok_or_else(|| bad(C, "`points` must be three [x, y] pairs of numbers"))?,
|
||||
None => selected_anchor_points(s)?.ok_or_else(|| bad(C, "direct-select three anchor points, or give `points`"))?,
|
||||
Some(v) => two_or_three_points(v).ok_or_else(|| bad(C, "`points` must be two or three [x, y] pairs of numbers"))?,
|
||||
None => selected_anchor_points(s)?.ok_or_else(|| bad(C, "direct-select two or three anchor points, or give `points`"))?,
|
||||
};
|
||||
let [a, b, c] = points;
|
||||
let (center, radius) = shapes::circle_through(a, b, c)
|
||||
let (center, radius) = shapes::circle_through_points(&points)
|
||||
.ok_or_else(|| bad(C, "no circle passes through these points: two are the same or all three lie on one line"))?;
|
||||
let r = Rect::new(center.x - radius, center.y - radius, center.x + radius, center.y + radius);
|
||||
let live = LiveShape::Ellipse { w: r.width(), h: r.height(), pie: (0.0, 360.0), xf: Affine::translate(r.origin().to_vec2()) };
|
||||
@@ -434,24 +434,25 @@ fn circle_through_points(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The three points `[[x, y], [x, y], [x, y]]` holds, each pair two finite numbers.
|
||||
fn three_points(v: &Value) -> Option<[Point; 3]> {
|
||||
/// The two or three points `[[x, y], [x, y]]` or `[[x, y], [x, y], [x, y]]` holds, each pair two
|
||||
/// finite numbers.
|
||||
fn two_or_three_points(v: &Value) -> Option<Vec<Point>> {
|
||||
let pair = |v: &Value| match v.as_array().map(Vec::as_slice) {
|
||||
Some([x, y]) => x.as_f64().zip(y.as_f64()).filter(|(x, y)| x.is_finite() && y.is_finite()).map(|(x, y)| Point::new(x, y)),
|
||||
_ => None,
|
||||
};
|
||||
match v.as_array().map(Vec::as_slice) {
|
||||
Some([a, b, c]) => Some([pair(a)?, pair(b)?, pair(c)?]),
|
||||
match v.as_array() {
|
||||
Some(pairs) if matches!(pairs.len(), 2 | 3) => pairs.iter().map(pair).collect(),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The positions of the selected anchor points, when there are exactly three. They are counted as
|
||||
/// The positions of the selected anchor points, when there are two or three. They are counted as
|
||||
/// the other anchor commands count them ([`super::path::anchor_targets`]): a selected path with
|
||||
/// anchors picked by Direct Selection gives those, and a path selected whole gives all of its own.
|
||||
/// A selected segment's ends are not selected anchor points, so a selection with segments gives
|
||||
/// none; so does a selection holding an object that is not a path, or an anchor that is gone.
|
||||
fn selected_anchor_points(s: &Session) -> Result<Option<[Point; 3]>> {
|
||||
fn selected_anchor_points(s: &Session) -> Result<Option<Vec<Point>>> {
|
||||
let st = s.doc()?;
|
||||
if st.selection.segments.values().any(|set| !set.is_empty()) {
|
||||
return Ok(None);
|
||||
@@ -472,10 +473,7 @@ fn selected_anchor_points(s: &Session) -> Result<Option<[Point; 3]>> {
|
||||
return Ok(None);
|
||||
}
|
||||
}
|
||||
Ok(match points.as_slice() {
|
||||
&[a, b, c] => Some([a, b, c]),
|
||||
_ => None,
|
||||
})
|
||||
Ok(matches!(points.len(), 2 | 3).then_some(points))
|
||||
}
|
||||
|
||||
/// The whole-number count `p` gives for `key` (`5` or `5.0`), or `default` when it is left out or
|
||||
@@ -942,7 +940,13 @@ fn text_create(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let id = made.get("id").and_then(Value::as_u64).map(NodeId);
|
||||
let made = super::typecmd::with_bounds(s, id, made);
|
||||
let mut made = super::typecmd::with_overflow(s, id.as_slice(), made);
|
||||
if p.get("font").is_some() || p.get("style").is_some() {
|
||||
// A face from a redefined [Normal Character Style] is checked too, as one given here is.
|
||||
let normal_face = s
|
||||
.doc()
|
||||
.ok()
|
||||
.and_then(|d| super::textstyles::style_attrs(&d.doc, false, super::textstyles::NORMAL_CHAR))
|
||||
.is_some_and(|m| m.contains_key("font_family") || m.contains_key("font_style"));
|
||||
if p.get("font").is_some() || p.get("style").is_some() || normal_face {
|
||||
let runs = match id.and_then(|i| s.doc().ok()?.doc.node(i)).map(|n| &n.kind) {
|
||||
Some(NodeKind::Text(t)) => t.runs.iter().flat_map(super::fonts::run_fonts).collect(),
|
||||
_ => Default::default(),
|
||||
@@ -970,8 +974,9 @@ pub(crate) fn new_type_para() -> vectorcraft_doc::ParaStyle {
|
||||
|
||||
/// The paragraph alignment, leading model and character alignment new type starts with (`t`'s
|
||||
/// paragraph and runs): `justify` from `p` (else as [`new_type_para`] left it), `leadingModel`
|
||||
/// and `charAlign` from `p`, else em box top to top and em box centre while the
|
||||
/// interface is in Japanese (#432), else the Roman baseline for both. Noted in the journal, so a
|
||||
/// and `charAlign` from `p` (`charAlign` else from a redefined `[Normal Character Style]` that
|
||||
/// sets it), else em box top to top and em box centre while the interface is in Japanese (#432),
|
||||
/// else the Roman baseline for both. Noted in the journal, so a
|
||||
/// replay sets the same whatever the interface.
|
||||
pub(crate) fn new_type_alignment(s: &mut Session, p: &Value, cmd: &str, t: &mut TextObject) -> Result<()> {
|
||||
use vectorcraft_doc::{CharAlign, LeadingModel};
|
||||
@@ -991,7 +996,14 @@ pub(crate) fn new_type_alignment(s: &mut Session, p: &Value, cmd: &str, t: &mut
|
||||
l
|
||||
}
|
||||
};
|
||||
let align = match super::textedit::char_align_param(p, cmd)? {
|
||||
// A redefined [Normal Character Style] that sets Character Alignment gives it to new type.
|
||||
let normal_align = s
|
||||
.doc()
|
||||
.ok()
|
||||
.and_then(|d| super::textstyles::style_attrs(&d.doc, false, super::textstyles::NORMAL_CHAR))
|
||||
.filter(|m| m.contains_key("charAlign"))
|
||||
.and(t.runs.first().map(|r| r.style.char_align));
|
||||
let align = match super::textedit::char_align_param(p, cmd)?.or(normal_align) {
|
||||
Some(a) => a,
|
||||
None => {
|
||||
let a = if japanese { CharAlign::EmBoxCenter } else { CharAlign::RomanBaseline };
|
||||
@@ -1019,17 +1031,25 @@ pub(crate) fn new_area_fit(s: &Session, p: &Value, c: &str, t: &mut TextObject)
|
||||
}
|
||||
|
||||
/// The character style new type gets: `size`, `font`, `style` and `color` from `p` (an RGB
|
||||
/// `color` in a CMYK document as [`super::paint::new_color`] stores it), else the defaults,
|
||||
/// filled as `[Normal Character Style]` is (black unless redefined; never the current fill,
|
||||
/// #7975), in the document's
|
||||
/// language. A `size` outside [`super::typecmd::TYPE_SIZES`] is an error.
|
||||
/// `color` in a CMYK document as [`super::paint::new_color`] stores it), else
|
||||
/// `[Normal Character Style]`'s (the default font, size and black fill unless redefined;
|
||||
/// never the current fill, #7975), in the style's language, else the document's. A `size` outside
|
||||
/// [`super::typecmd::TYPE_SIZES`] is an error.
|
||||
pub(crate) fn new_type_style(s: &Session, p: &Value, cmd: &str) -> Result<CharStyle> {
|
||||
let mut style = CharStyle::default();
|
||||
let mut style = s.doc().map_or_else(|_| CharStyle::default(), |d| super::textstyles::normal_char_style(&d.doc));
|
||||
if let Some(sz) = p.get("size").and_then(Value::as_f64) {
|
||||
style.size = super::typecmd::given_type_size(sz, cmd)?;
|
||||
}
|
||||
if str_param(p, "font").is_some() || str_param(p, "style").is_some() {
|
||||
// A face given to the command takes its own version and axis settings, as a font change
|
||||
// does, not those [Normal Character Style] gave another face.
|
||||
style.font_version = None;
|
||||
style.font_axes.clear();
|
||||
}
|
||||
if let Some(f) = str_param(p, "font") {
|
||||
style.font_family = f.to_string();
|
||||
// A family alone starts in Regular, whatever style [Normal Character Style] has.
|
||||
style.font_style = CharStyle::default().font_style;
|
||||
}
|
||||
if let Some(f) = str_param(p, "style") {
|
||||
style.font_style = f.to_string();
|
||||
@@ -1039,12 +1059,15 @@ pub(crate) fn new_type_style(s: &Session, p: &Value, cmd: &str) -> Result<CharSt
|
||||
}
|
||||
style.fill = match p.get("color").and_then(color_value) {
|
||||
Some(c) => vectorcraft_color::Paint::solid(super::paint::new_color(s, p, c)),
|
||||
None => s.doc().map_or_else(|_| CharStyle::default().fill, |d| super::textstyles::normal_char_fill(&d.doc)),
|
||||
None => style.fill,
|
||||
};
|
||||
// In the language Document Setup chose, else Preferences › Hyphenation › Default Language; none
|
||||
// for the default. Type already in a document keeps its own.
|
||||
let chosen = |name: &str| vectorcraft_doc::setup::char_language(name).ok().flatten();
|
||||
let document = s.doc().ok().and_then(|d| chosen(&d.doc.setup.language));
|
||||
style.language = document.or_else(|| chosen(&s.prefs.hyphenation_language)).map(str::to_string);
|
||||
// In the language a redefined [Normal Character Style] gives, else the one Document Setup chose,
|
||||
// else Preferences › Hyphenation › Default Language; none for the default. Type already in a
|
||||
// document keeps its own.
|
||||
if style.language.is_none() {
|
||||
let chosen = |name: &str| vectorcraft_doc::setup::char_language(name).ok().flatten();
|
||||
let document = s.doc().ok().and_then(|d| chosen(&d.doc.setup.language));
|
||||
style.language = document.or_else(|| chosen(&s.prefs.hyphenation_language)).map(str::to_string);
|
||||
}
|
||||
Ok(style)
|
||||
}
|
||||
@@ -3,10 +3,8 @@ use super::{CommandSpec, EngineError, Result, Session, cmd, has_doc};
|
||||
use serde_json::{Value, json};
|
||||
use std::sync::Arc;
|
||||
use vectorcraft_color::{Color, Paint};
|
||||
use vectorcraft_doc::dimension::{
|
||||
ArrowStyle, Dimension, DimensionMode, DimensionOptions, DimensionSource, LineType, Orientation, TextAlignment, TextPosition,
|
||||
};
|
||||
use vectorcraft_doc::{Appearance, Arrowhead, CharStyle, ColorMode, Dash, Document, Node, NodeId, NodeKind, TextObject};
|
||||
use vectorcraft_doc::dimension::{Dimension, DimensionMode, DimensionOptions, DimensionSource, LineType, Orientation, TextAlignment, TextPosition};
|
||||
use vectorcraft_doc::{Appearance, CharStyle, ColorMode, Dash, Document, Node, NodeId, NodeKind, TextObject};
|
||||
use vectorcraft_geom::{Affine, BezPath, PathData, Point, Vec2};
|
||||
|
||||
pub fn specs() -> Vec<CommandSpec> {
|
||||
@@ -567,12 +565,7 @@ fn appearance(o: &DimensionOptions, mode: ColorMode, ext: bool, arrows: bool) ->
|
||||
LineType::Solid => None,
|
||||
};
|
||||
if arrows {
|
||||
let head = match o.arrow_style {
|
||||
ArrowStyle::Filled => Some(Arrowhead::Triangle),
|
||||
ArrowStyle::Open => Some(Arrowhead::TriangleOpen),
|
||||
ArrowStyle::Tick => Some(Arrowhead::Slash),
|
||||
ArrowStyle::None => None,
|
||||
};
|
||||
let head = o.arrow_style.arrowhead();
|
||||
st.start_arrow = head.clone();
|
||||
st.end_arrow = head;
|
||||
st.arrow_scale = (o.arrow_scale, o.arrow_scale);
|
||||
|
||||
@@ -16,7 +16,7 @@ use vectorcraft_tools::distort::{PinSet, arap, collect_points, mesh_for, project
|
||||
use super::edit::{duplicate_in, outermost, refuse_symbol_part, selected_roots};
|
||||
use super::{
|
||||
CommandSpec, Result, Session, bad, check_numbers, check_switches, cmd, f64_or, f64_req, finite_numbers, has_doc, has_selection, matrix_param,
|
||||
named_id, named_ids, number_or, object_param, ok, point_indices, point_param, str_param, switch_or, targets,
|
||||
named_id, named_ids, number_or, object_param, ok, point_indices, point_param, str_param, switch_or, targets, text_param, u64_req,
|
||||
};
|
||||
use crate::EngineError;
|
||||
|
||||
@@ -35,7 +35,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Width Point",
|
||||
[],
|
||||
None,
|
||||
"{id, t: 0..1 (fraction of the path length), left, right: side widths in pt, index?: width point to edit or move, adjustAdjoining?: bool (the nearest points either side change their widths in proportion, using the sampled widths for a new point)} → {index}. Without index a point already at t is replaced; a point moved onto another one's t joins it as a discontinuous point (on the side it came from), so the width steps there. Creates a uniform profile first if needed",
|
||||
"{id, t: 0..1 (fraction of the path length), left, right: side widths in pt, index?: width point to edit or move, adjustAdjoining?: bool (the nearest points either side change their widths in proportion, using the sampled widths for a new point), outIndex?, outLeft, outRight: the outgoing half of the discontinuous point whose incoming half is index, single?: \"incoming\" | \"outgoing\"} → {index}. Without index a point already at t is replaced; a point moved onto another one's t joins it as a discontinuous point (on the side it came from), so the width steps there. With outIndex both halves change in one step and keep their place (t must be theirs); adjustAdjoining then changes the nearest point before from the incoming half and the nearest point after from the outgoing half. single keeps only that half's widths, leaving one continuous point. Creates a uniform profile first if needed",
|
||||
has_doc,
|
||||
width_point_set
|
||||
),
|
||||
@@ -214,6 +214,15 @@ fn uniform() -> WidthProfile {
|
||||
/// Width points closer than this (in t) are at the same place: a discontinuous point.
|
||||
const SAME_T: f64 = 1e-6;
|
||||
|
||||
/// The outgoing half of the discontinuous width point whose incoming half is point `a`: point `a`
|
||||
/// and the next one are the two halves when they are the only points within 1e-6 (in t) of `a`'s
|
||||
/// place. None when `a` is out of range or not such an incoming half.
|
||||
pub fn width_point_pair(points: &[(f64, f64, f64)], a: usize) -> Option<usize> {
|
||||
let t = points.get(a)?.0;
|
||||
let at: Vec<usize> = (0..points.len()).filter(|i| (points[*i].0 - t).abs() <= SAME_T).collect();
|
||||
(at == [a, a + 1]).then_some(a + 1)
|
||||
}
|
||||
|
||||
/// The stroke of `id` that width point commands edit (a compound path's for its members).
|
||||
fn stroke_mut(d: &mut Document, id: NodeId) -> Result<&mut vectorcraft_doc::StrokeLayer> {
|
||||
let id = stroke_owner(d, id);
|
||||
@@ -265,9 +274,9 @@ fn place(points: &mut Vec<(f64, f64, f64)>, mut pt: (f64, f64, f64), from_below:
|
||||
}
|
||||
|
||||
/// Adjust Adjoining Width Points: point `i` changes from `old` to `new` widths, and the nearest
|
||||
/// points at other positions either side change in proportion (by the same amount from zero).
|
||||
fn adjust_adjoining(points: &mut [(f64, f64, f64)], i: usize, old: (f64, f64, f64), new: (f64, f64, f64)) {
|
||||
let t = points[i].0;
|
||||
/// points farther than [`SAME_T`] from place `t` on the sides `sides` names (before, after)
|
||||
/// change in proportion (by the same amount from zero).
|
||||
fn adjust_adjoining(points: &mut [(f64, f64, f64)], i: usize, t: f64, old: (f64, f64, f64), new: (f64, f64, f64), sides: [bool; 2]) {
|
||||
let scale = |v: f64, o: f64, n: f64| {
|
||||
let width = if o > 1e-9 {
|
||||
let product = v * n;
|
||||
@@ -284,8 +293,8 @@ fn adjust_adjoining(points: &mut [(f64, f64, f64)], i: usize, old: (f64, f64, f6
|
||||
};
|
||||
width.max(0.0)
|
||||
};
|
||||
let before = (0..i).rev().find(|j| (points[*j].0 - t).abs() > SAME_T);
|
||||
let after = (i + 1..points.len()).find(|j| (points[*j].0 - t).abs() > SAME_T);
|
||||
let before = (0..i).rev().find(|j| (points[*j].0 - t).abs() > SAME_T).filter(|_| sides[0]);
|
||||
let after = (i + 1..points.len()).find(|j| (points[*j].0 - t).abs() > SAME_T).filter(|_| sides[1]);
|
||||
for j in before.into_iter().chain(after) {
|
||||
let q = &mut points[j];
|
||||
(q.1, q.2) = (scale(q.1, old.1, new.1), scale(q.2, old.2, new.2));
|
||||
@@ -303,6 +312,46 @@ fn same_points(a: Option<&WidthProfile>, b: Option<&WidthProfile>) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
/// Set both halves of the discontinuous point whose incoming half is `i` and outgoing half `j` to
|
||||
/// the widths of `inc` and `out` (their places are ignored: the point keeps its place). With
|
||||
/// `single` (`true` for the outgoing half) only that half's widths remain, as one continuous point.
|
||||
/// With `adjust`, the nearest point before changes with the incoming half and the nearest point after
|
||||
/// with the outgoing half, once each. → the index of the point (its incoming half).
|
||||
fn set_pair(
|
||||
points: &mut Vec<(f64, f64, f64)>,
|
||||
(i, inc): (usize, (f64, f64, f64)),
|
||||
(j, out): (usize, (f64, f64, f64)),
|
||||
adjust: bool,
|
||||
single: Option<bool>,
|
||||
) -> Result<usize> {
|
||||
const C: &str = "stroke.widthPoint.set";
|
||||
if width_point_pair(points, i) != Some(j) {
|
||||
return Err(bad(C, "`index` and `outIndex` must be the two halves of one discontinuous width point"));
|
||||
}
|
||||
let at = points[i].0;
|
||||
let (old_in, old_out) = (points[i], points[j]);
|
||||
if (old_in.0 - inc.0).abs() > SAME_T {
|
||||
return Err(bad(C, "a discontinuous width point keeps its place"));
|
||||
}
|
||||
let (new_in, new_out) = match single {
|
||||
None => ((old_in.0, inc.1, inc.2), (old_out.0, out.1, out.2)),
|
||||
Some(false) => ((old_in.0, inc.1, inc.2), (old_in.0, inc.1, inc.2)),
|
||||
Some(true) => ((old_in.0, out.1, out.2), (old_in.0, out.1, out.2)),
|
||||
};
|
||||
// Both halves measure their neighbors from the point's place, so a point within SAME_T of the
|
||||
// outgoing half but not of that place is the point after the pair.
|
||||
if adjust {
|
||||
adjust_adjoining(points, i, at, old_in, new_in, [true, false]);
|
||||
adjust_adjoining(points, j, at, old_out, new_out, [false, true]);
|
||||
}
|
||||
points[i] = new_in;
|
||||
points[j] = new_out;
|
||||
if single.is_some() {
|
||||
points.remove(j);
|
||||
}
|
||||
Ok(i)
|
||||
}
|
||||
|
||||
fn width_point_set(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
const C: &str = "stroke.widthPoint.set";
|
||||
let id = object_param(p, "id", C)?.ok_or_else(|| bad(C, "missing id"))?;
|
||||
@@ -312,6 +361,25 @@ fn width_point_set(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
return Err(bad(C, "left/right must be non-negative widths"));
|
||||
}
|
||||
let adjust = switch_or(p, "adjustAdjoining", false, C)?;
|
||||
let single = match text_param(p, "single", C)? {
|
||||
None => None,
|
||||
Some(side @ ("incoming" | "outgoing")) => Some(side == "outgoing"),
|
||||
Some(_) => return Err(bad(C, "`single` must be `incoming` or `outgoing`")),
|
||||
};
|
||||
// The outgoing half of a discontinuous point: its index and side widths (points).
|
||||
// `single`, `outLeft` or `outRight` without `outIndex` is refused as a missing `outIndex`.
|
||||
let out_widths = ["outLeft", "outRight"].iter().any(|k| p.get(*k).is_some_and(|v| !v.is_null()));
|
||||
let out = match p.get("outIndex") {
|
||||
None | Some(Value::Null) if single.is_none() && !out_widths => None,
|
||||
_ => {
|
||||
let j = usize::try_from(u64_req(p, "outIndex", C)?).map_err(|_| bad(C, "no such width point"))?;
|
||||
let (l, r) = (f64_req(p, "outLeft", C)?, f64_req(p, "outRight", C)?);
|
||||
if !(l.is_finite() && r.is_finite()) || l < 0.0 || r < 0.0 || l.max(r) > 1.0e5 {
|
||||
return Err(bad(C, "left/right must be non-negative widths"));
|
||||
}
|
||||
Some((j, l, r))
|
||||
}
|
||||
};
|
||||
// When the profile comes out as it was, within a rounding error (1e-9), the document and its undo
|
||||
// history stay as they are.
|
||||
let mut pos = 0;
|
||||
@@ -324,11 +392,19 @@ fn width_point_set(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
return Err(bad(C, "width factors must be finite"));
|
||||
}
|
||||
let mut prof = st.profile.take().unwrap_or_else(uniform);
|
||||
pos = match point_index(p, &prof, C)? {
|
||||
Some(i) => {
|
||||
pos = match (point_index(p, &prof, C)?, out) {
|
||||
(None, Some(_)) => return Err(bad(C, "missing index")),
|
||||
(Some(i), Some((j, l, r))) => {
|
||||
let out = (t, l / half, r / half);
|
||||
if !out.1.is_finite() || !out.2.is_finite() {
|
||||
return Err(bad(C, "width factors must be finite"));
|
||||
}
|
||||
set_pair(&mut prof.points, (i, pt), (j, out), adjust, single)?
|
||||
}
|
||||
(Some(i), None) => {
|
||||
let old = prof.points[i];
|
||||
if adjust {
|
||||
adjust_adjoining(&mut prof.points, i, old, pt);
|
||||
adjust_adjoining(&mut prof.points, i, old.0, old, pt, [true, true]);
|
||||
}
|
||||
if (old.0 - t).abs() <= SAME_T {
|
||||
// Widths only: it keeps its place (and its side of a discontinuous point).
|
||||
@@ -339,12 +415,12 @@ fn width_point_set(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
place(&mut prof.points, pt, old.0 < t)
|
||||
}
|
||||
}
|
||||
None => {
|
||||
(None, None) => {
|
||||
let old = adjust.then(|| prof.at(t));
|
||||
prof.points.retain(|q| (q.0 - t).abs() > SAME_T);
|
||||
let i = place(&mut prof.points, pt, true);
|
||||
if let Some((left, right)) = old {
|
||||
adjust_adjoining(&mut prof.points, i, (t, left, right), pt);
|
||||
adjust_adjoining(&mut prof.points, i, pt.0, (t, left, right), pt, [true, true]);
|
||||
}
|
||||
i
|
||||
}
|
||||
|
||||
@@ -238,7 +238,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Move Guide",
|
||||
[],
|
||||
None,
|
||||
"{index, pos: pt} | {dx?, dy?: pt, copy?: bool} put ruler guide `index` at `pos`, or move the selected guides (vertical ones by dx, horizontal ones by dy); copy leaves them and selects the moved copies",
|
||||
"{index, pos: pt} | {dx?, dy?: pt, copy?: bool, interpolate?: bool (with art selected too: as object.move's)} put ruler guide `index` at `pos`, or move the selected guides (vertical ones by dx, horizontal ones by dy); copy leaves them and selects the moved copies",
|
||||
guides_unlocked,
|
||||
guide_move
|
||||
),
|
||||
@@ -990,6 +990,7 @@ pub(crate) fn guide_move(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let dx = number_or(p, "dx", 0.0, "guide.move")?;
|
||||
let dy = number_or(p, "dy", 0.0, "guide.move")?;
|
||||
let copy = switch_or(p, "copy", false, "guide.move")?;
|
||||
switch_or(p, "interpolate", false, "guide.move")?;
|
||||
if !s.doc()?.selection.is_empty() {
|
||||
let ids = super::edit::selected_roots(s)?;
|
||||
return super::object::apply_transform(
|
||||
|
||||
@@ -11,7 +11,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Pencil",
|
||||
[],
|
||||
None,
|
||||
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] (pen pressure 0..1: the stroke keeps it, for Calligraphic and Scatter brushes with Pressure variation; a point without one presses fully. Pen tilt in degrees, each −90..90, x positive leaning right and y leaning down the page, and barrel rotation in degrees clockwise, 0..360: the stroke keeps how far the pen leaned, which way and how far its barrel turned, for brushes with Tilt, Bearing and Rotation variation; null for what a point lacks. A pressure, tilt or rotation outside its range, or a point array of more than six numbers, is an error), fidelity?: pt (1.5; from 0.000015625 (0.01 / 640) to 100 / 0.0313 (about 3194.89), the Pencil's and the Paintbrush's 0.01 to 100 px Fidelity at the highest and the lowest zoom; a value outside that range is an error. The tools send their Fidelity in pixels divided by the zoom, kept within the range), fit?: bool (true; false: the points are joined by straight segments, as the Pencil previews a stroke with Live curve fitting off), closed?, style?: \"pencil\" (default) | \"brush\", fill?: bool, keepSelected?: bool (true: the drawn or continued path is selected; false: a new path leaves nothing selected, and a continued or redrawn one is deselected while the rest of the selection stays), extend?: {id, end?: \"end\" (default) | \"start\"}, connect?: {id, end: \"start\"|\"end\"}, redraw?: {id, within?: pt (12)}} fit a freehand stroke → {id}. extend continues the path from that end, and closes it when `closed` is true (left out, when the stroke ends within four Fidelities of the path's other end, 6 to 400 pt); with connect, the stroke ends on that end of another path's last open subpath and joins it on, in one path with the extended path's appearance (the other path is removed when nothing of it is left); redraw (Edit Selected Paths) replaces the section of the path between where the stroke starts and ends, each within `within` of one subpath (the shorter way round a closed one), and draws a new path when the stroke doesn't end on it. Any other style, extend end or connect end is an error, and nothing changes",
|
||||
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] (pen pressure 0..1: the stroke keeps it, for Calligraphic and Scatter brushes with Pressure variation; a point without one presses fully. Pen tilt in degrees, each −90..90, x positive leaning right and y leaning down the page, and barrel rotation in degrees clockwise, 0..360: the stroke keeps how far the pen leaned, which way and how far its barrel turned, for brushes with Tilt, Bearing and Rotation variation; null for what a point lacks. A pressure, tilt or rotation outside its range, or a point array of more than six numbers, is an error), fidelity?: pt (1.5; from 0.000015625 (0.01 / 640) to 100 / 0.0313 (about 3194.89), the Pencil's and the Paintbrush's 0.01 to 100 px Fidelity at the highest and the lowest zoom; a value outside that range is an error. The tools send their Fidelity in pixels divided by the zoom, kept within the range), fit?: bool (true; false: the points are joined by straight segments, as the Pencil previews a stroke with Live curve fitting off), closed?, style?: \"pencil\" (default) | \"brush\", fill?: bool, keepSelected?: bool (true: the drawn or continued path is selected; false: a new path leaves nothing selected, and a continued or redrawn one is deselected while the rest of the selection stays), extend?: {id, end?: \"end\" (default) | \"start\"}, connect?: {id, end: \"start\"|\"end\"} (only with extend), redraw?: {id, within?: pt (12)}} fit a freehand stroke → {id}. extend continues the path from that end, and closes it when `closed` is true (left out, when the stroke ends within four Fidelities of the path's other end, 6 to 400 pt); with connect, the stroke ends on that end of another path's last open subpath and joins it on, in one path with the extended path's appearance (the other path is removed when nothing of it is left); redraw (Edit Selected Paths) replaces the section of the path between where the stroke starts and ends, each within `within` of one subpath (the shorter way round a closed one), and draws a new path when the stroke doesn't end on it. Any other style, extend end or connect end, connect without extend, and a connect that names no other path with an open end are errors, a stroke of one point included, and nothing changes",
|
||||
has_doc,
|
||||
freehand
|
||||
),
|
||||
@@ -92,7 +92,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Eraser",
|
||||
[],
|
||||
None,
|
||||
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] (pen pressure 0..1, tilt −90..90°, barrel rotation 0..360° clockwise; pen values are checked as path.freehand checks them), size?: pt (10; from 0.1 to 1000), angle?: ° (0, −180–180: the tip's long axis counter-clockwise from level), roundness?: % (100, 1–100), angleMode?, roundnessMode?, sizeMode?: \"fixed\" (default) | \"random\" | \"pressure\" | \"tilt\" | \"bearing\" | \"rotation\" (Eraser Tool Options' variation menus; a varied angle turns either way, clockwise or counter-clockwise), angleVariation?: ° (0–180, default 0, either way: clockwise or counter-clockwise), roundnessVariation?: % (0–100, default 0), sizeVariation?: pt (0–1000, default 0)} or {rect: [x, y, width, height] (pt; the Eraser's Alt-drag marquee)} erase the stroke of an elliptical tip from paths (selected, or all) → {ids}. The tip is `size` across its long axis, which runs at `angle` counter-clockwise from horizontal; its short axis is `roundness` percent of the long one. A value whose mode is not fixed varies by up to its variation either way: random draws one value for the drag; pressure goes from the value less the variation where the pen presses lightest to the value plus it where it presses hardest (size on pressure as path.blob); tilt from less with the pen lying flat to more with it upright; bearing and rotation from less at −180° to more at 180° of the pen's lean direction or barrel turn. A drag without that pen reading (a mouse) erases at the value itself. An angle or roundness outside its range, an unknown mode, or a variation below 0 or past its range is refused with an error and erases nothing. `rect` in place of `points` erases everything inside the rectangle: closed paths lose its area, and open paths are cut where they cross its edges; the tip's size, angle, roundness and variations do not apply. A width or height of 0 or less, a value that is not a finite number, or `points` and `rect` together is an error. When nothing is erased, no undo step is added",
|
||||
"{points: [[x,y]…] or [[x,y,pressure]…] or [[x,y,pressure,tiltX,tiltY,rotation]…] (pen pressure 0..1, tilt −90..90°, barrel rotation 0..360° clockwise; pen values are checked as path.freehand checks them), size?: pt (10; from 0.1 to 1000), angle?: ° (0, −180–180: the tip's long axis counter-clockwise from level), roundness?: % (100, 1–100), angleMode?, roundnessMode?, sizeMode?: \"fixed\" (default) | \"random\" | \"pressure\" | \"tilt\" | \"bearing\" | \"rotation\" (Eraser Tool Options' variation menus; a varied angle turns either way, clockwise or counter-clockwise), angleVariation?: ° (0–180, default 0, either way: clockwise or counter-clockwise), roundnessVariation?: % (0–100, default 0), sizeVariation?: pt (0–1000, default 0)} or {rect: [x, y, width, height] (pt; the Eraser's Alt-drag marquee)} erase the stroke of an elliptical tip from paths (selected, or all) → {ids}. The tip is `size` across its long axis, which runs at `angle` counter-clockwise from horizontal; its short axis is `roundness` percent of the long one. A value whose mode is not fixed varies by up to its variation either way: random draws one value for the drag; pressure goes from the value less the variation where the pen presses lightest to the value plus it where it presses hardest (size on pressure as path.blob); tilt from less with the pen lying flat to more with it upright; bearing and rotation from less at −180° to more at 180° of the pen's lean direction or barrel turn. A drag without that pen reading (a mouse) erases at the value itself. An angle or roundness outside its range, an unknown mode, or a variation below 0 or past its range is refused with an error and erases nothing. `rect` in place of `points` erases everything inside the rectangle: closed paths and filled open paths without a visible painted stroke lose its area, and other open paths are cut where they cross its edges; the tip's size, angle, roundness and variations do not apply. A width or height of 0 or less, a value that is not a finite number, or `points` and `rect` together is an error. When nothing is erased, no undo step is added",
|
||||
has_doc,
|
||||
erase_region
|
||||
),
|
||||
|
||||
@@ -345,18 +345,46 @@ pub(super) fn target_paths(doc: &Document, sel: &Selection, area: Rect) -> Vec<N
|
||||
out
|
||||
}
|
||||
|
||||
/// Any visible non-None fill, including one below a topmost None.
|
||||
pub(super) fn has_fill(n: &Node) -> bool {
|
||||
n.appearance.items.iter().any(|item| item.is_fill() && item.visible() && !item.paint().is_none())
|
||||
}
|
||||
|
||||
/// A visible painted stroke keeps open paths on the existing outline-erasure route.
|
||||
pub(super) fn has_painted_stroke(n: &Node) -> bool {
|
||||
n.appearance.items.iter().any(
|
||||
|item| matches!(item, vectorcraft_doc::AppearanceItem::Stroke(stroke) if stroke.visible && !stroke.paint.is_none() && stroke.width > 0.0),
|
||||
)
|
||||
}
|
||||
|
||||
/// A container stroke that paints this target's open geometry. A clipping container's own
|
||||
/// paint follows its clipping outline, and a compound shape paints its combined area instead.
|
||||
/// Neither makes its descendants' implicit fill-closing edges into new stroked edges.
|
||||
pub(super) fn has_painted_ancestor_stroke(doc: &Document, id: NodeId) -> bool {
|
||||
doc.ancestry(id)
|
||||
.unwrap_or_default()
|
||||
.into_iter()
|
||||
.rev()
|
||||
.skip(1)
|
||||
.filter_map(|id| doc.node(id))
|
||||
.take_while(|node| !node.clips() && !node.is_compound_shape())
|
||||
.any(|node| matches!(node.kind, NodeKind::Group { .. } | NodeKind::Layer { .. }) && has_painted_stroke(node))
|
||||
}
|
||||
|
||||
/// [`target_paths`] for the tools that cut fills, with each target's geometry and fill rule: the
|
||||
/// members of a compound path whose members are all closed paths give the compound path itself,
|
||||
/// once, so its fill (holes included) is cut as one shape under its own fill rule.
|
||||
pub(super) fn fill_targets(doc: &Document, sel: &Selection, area: Rect) -> Result<Vec<(NodeId, PathData, FillRule)>> {
|
||||
let closed_compound = |n: &Node| {
|
||||
/// With `open_fills`, an open compound with a visible fill and no painted visible stroke does too.
|
||||
pub(super) fn fill_targets(doc: &Document, sel: &Selection, area: Rect, open_fills: bool) -> Result<Vec<(NodeId, PathData, FillRule)>> {
|
||||
let area_compound = |n: &Node| {
|
||||
let filled = open_fills && has_fill(n) && !has_painted_stroke(n) && !has_painted_ancestor_stroke(doc, n.id);
|
||||
matches!(&n.kind, NodeKind::Compound { children, .. }
|
||||
if children.iter().all(|c| matches!(&c.kind, NodeKind::Path { path, .. } if path.is_closed())))
|
||||
if children.iter().all(|c| matches!(&c.kind, NodeKind::Path { path, .. } if path.is_closed() || filled)))
|
||||
};
|
||||
let editable = doc.editable();
|
||||
let mut out: Vec<(NodeId, PathData, FillRule)> = vec![];
|
||||
for id in target_paths(doc, sel, area) {
|
||||
let compound = doc.parent_of(id).and_then(|p| doc.node(p)).filter(|p| closed_compound(p) && editable(p.id));
|
||||
let compound = doc.parent_of(id).and_then(|p| doc.node(p)).filter(|p| area_compound(p) && editable(p.id));
|
||||
let target = compound.map_or(id, |c| c.id);
|
||||
if out.iter().any(|t| t.0 == target) {
|
||||
continue;
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
use super::common::{
|
||||
PenRecord, SIZE_VARIATIONS, SIZES, Sample, center_strokes, dist_to_polyline, fill_targets, ids_json, path_mut, path_of, points_param,
|
||||
poly_bounds, pressure_region, ranged, replace_with_pieces, samples_param, sibling_with, size_pressure, target_paths, usize_opt,
|
||||
PenRecord, SIZE_VARIATIONS, SIZES, Sample, center_strokes, dist_to_polyline, fill_targets, has_fill, has_painted_ancestor_stroke,
|
||||
has_painted_stroke, ids_json, path_mut, path_of, points_param, poly_bounds, pressure_region, ranged, replace_with_pieces, samples_param,
|
||||
set_geometry, sibling_with, size_pressure, target_paths, usize_opt,
|
||||
};
|
||||
use super::{
|
||||
Anchor, AnchorKind, Beside, BezPath, BoolOp, Cap, EngineError, FillRule, Join, NodeId, Paint, ParamCurve, PathData, Point, Rect, Result, Session,
|
||||
SubPath, Value, Vec2, bad, eraser_area, eraser_tip, f64_or, fill_contains, json, number_or, object_param, po,
|
||||
Anchor, AnchorKind, Beside, BezPath, BoolOp, Cap, Document, EngineError, FillRule, Join, NodeId, NodeKind, Paint, ParamCurve, PathData, Point,
|
||||
Rect, Result, Session, SubPath, Value, Vec2, bad, eraser_area, eraser_tip, f64_or, fill_contains, json, number_or, object_param, po,
|
||||
};
|
||||
use kurbo::{CubicBez, Line, PathSeg};
|
||||
use vectorcraft_brush::{Brush, BrushKind, Calligraphic, Variation};
|
||||
@@ -266,7 +267,7 @@ pub(super) fn knife(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let st = s.doc()?;
|
||||
let strip = po::outline_stroke(&PathData::single(SubPath::polyline(&pts, false)), KNIFE_GAP, Cap::Butt, Join::Round, 4.0);
|
||||
let mut plan: Vec<(NodeId, Vec<PathData>)> = vec![];
|
||||
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, 1.0))? {
|
||||
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, 1.0), false)? {
|
||||
if !pd.is_closed() {
|
||||
continue;
|
||||
}
|
||||
@@ -340,8 +341,9 @@ pub(super) fn erase_region(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
None => dist_to_polyline(&round, squash * q) <= r,
|
||||
};
|
||||
let mut plan: Vec<(NodeId, Vec<PathData>)> = vec![];
|
||||
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, reach))? {
|
||||
if pd.is_closed() {
|
||||
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, reach), true)? {
|
||||
if erase_as_area(&st.doc, id, &pd) {
|
||||
let pd = eraser_fill_operand(pd);
|
||||
if po::area(&po::boolean(&pd, rule, ®ion, FillRule::NonZero, BoolOp::Intersect), FillRule::NonZero) <= 1e-6 {
|
||||
continue;
|
||||
}
|
||||
@@ -353,6 +355,34 @@ pub(super) fn erase_region(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
apply_plan(s, "Eraser", plan)
|
||||
}
|
||||
|
||||
/// Whether the target is erased as filled area rather than as an open outline.
|
||||
fn erase_as_area(doc: &Document, id: NodeId, pd: &PathData) -> bool {
|
||||
// An unaggregated compound member keeps the outline route: its own appearance does not
|
||||
// paint it. Eligible fill-only compounds were collected as one parent target above.
|
||||
let compound_member =
|
||||
doc.parent_of(id).and_then(|parent| doc.node(parent)).is_some_and(|parent| matches!(parent.kind, NodeKind::Compound { .. }));
|
||||
let filled_open =
|
||||
!compound_member && !has_painted_ancestor_stroke(doc, id) && doc.node(id).is_some_and(|node| has_fill(node) && !has_painted_stroke(node));
|
||||
pd.is_closed() || filled_open
|
||||
}
|
||||
|
||||
/// Close only Eraser's temporary fill operand, preserving an open path's straight closing edge.
|
||||
fn eraser_fill_operand(mut pd: PathData) -> PathData {
|
||||
for sp in &mut pd.subpaths {
|
||||
if !sp.closed {
|
||||
// These endpoint handles are unused by an open path. Closing it must not activate them.
|
||||
if let Some(first) = sp.anchors.first_mut() {
|
||||
first.h_in = first.p;
|
||||
}
|
||||
if let Some(last) = sp.anchors.last_mut() {
|
||||
last.h_out = last.p;
|
||||
}
|
||||
sp.closed = true;
|
||||
}
|
||||
}
|
||||
pd
|
||||
}
|
||||
|
||||
/// `path.eraseRegion`'s `rect: [x, y, width, height]`: four finite numbers, with a width and a
|
||||
/// height above 0.
|
||||
fn marquee_param(v: &Value, cmd: &str) -> Result<Rect> {
|
||||
@@ -369,7 +399,7 @@ fn marquee_param(v: &Value, cmd: &str) -> Result<Rect> {
|
||||
}
|
||||
|
||||
/// `path.eraseRegion` with a marquee: everything inside `r` is erased from the paths (selected, or
|
||||
/// all). Closed paths lose the rectangle's area, and open paths are cut where they cross its edges.
|
||||
/// all). Closed paths and fill-only open paths lose the rectangle's area; other open paths are cut where they cross its edges.
|
||||
fn erase_rect(s: &mut Session, r: Rect) -> Result<Value> {
|
||||
let region =
|
||||
PathData::single(SubPath::polyline(&[Point::new(r.x0, r.y0), Point::new(r.x1, r.y0), Point::new(r.x1, r.y1), Point::new(r.x0, r.y1)], true));
|
||||
@@ -392,8 +422,9 @@ fn erase_rect(s: &mut Session, r: Rect) -> Result<Value> {
|
||||
};
|
||||
let st = s.doc()?;
|
||||
let mut plan: Vec<(NodeId, Vec<PathData>)> = vec![];
|
||||
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, r)? {
|
||||
if pd.is_closed() {
|
||||
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, r, true)? {
|
||||
if erase_as_area(&st.doc, id, &pd) {
|
||||
let pd = eraser_fill_operand(pd);
|
||||
if po::area(&po::boolean(&pd, rule, ®ion, FillRule::NonZero, BoolOp::Intersect), FillRule::NonZero) <= 1e-6 {
|
||||
continue;
|
||||
}
|
||||
@@ -492,8 +523,9 @@ fn erase_varied(s: &mut Session, samples: &[Sample], tip: [f64; 3], vary: [(Vari
|
||||
let short = low(2).max(MIN_BRUSH_SIZE) * low(1).clamp(1.0, 100.0) / 100.0;
|
||||
let reach = (size + sv) / 2.0;
|
||||
let mut plan: Vec<(NodeId, Vec<PathData>)> = vec![];
|
||||
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, reach))? {
|
||||
if pd.is_closed() {
|
||||
for (id, pd, rule) in fill_targets(&st.doc, &st.selection, poly_bounds(&pts, reach), true)? {
|
||||
if erase_as_area(&st.doc, id, &pd) {
|
||||
let pd = eraser_fill_operand(pd);
|
||||
if po::area(&po::boolean(&pd, rule, ®ion, FillRule::NonZero, BoolOp::Intersect), FillRule::NonZero) <= 1e-6 {
|
||||
continue;
|
||||
}
|
||||
@@ -510,10 +542,36 @@ fn apply_plan(s: &mut Session, label: &str, plan: Vec<(NodeId, Vec<PathData>)>)
|
||||
return Ok(json!({ "ids": [] }));
|
||||
}
|
||||
let ids = s.edit(label, |d, sel| {
|
||||
// Measure every original painting owner before any geometry or appearance changes.
|
||||
// This includes a Compound above a Path Eraser target and containers above live art.
|
||||
let owners: std::collections::BTreeSet<_> = plan.iter().flat_map(|(id, _)| d.ancestry(*id).unwrap_or_default()).collect();
|
||||
let pinned: Vec<_> = owners
|
||||
.into_iter()
|
||||
.filter_map(|id| {
|
||||
let node = d.node(id)?;
|
||||
if !node.appearance.has_unplaced_gradient() {
|
||||
return None;
|
||||
}
|
||||
vectorcraft_render::pinned_appearance_for_geometry_edit(d, node).map(|appearance| (id, appearance))
|
||||
})
|
||||
.collect();
|
||||
for (id, appearance) in pinned {
|
||||
if let Some(node) = d.node_mut(id) {
|
||||
node.appearance = appearance.into();
|
||||
}
|
||||
}
|
||||
let mut all = vec![];
|
||||
let mut cut = Beside::replacing(d, &plan.iter().map(|(id, _)| *id).collect::<Vec<_>>());
|
||||
for (id, pieces) in plan {
|
||||
all.extend(replace_with_pieces(d, &mut cut, id, pieces)?);
|
||||
let clipping_path = d.position(id).is_some_and(|(parent, i, _)| i == 0 && parent.and_then(|p| d.node(p)).is_some_and(|p| p.clips()));
|
||||
if clipping_path {
|
||||
// Keep every clipping contour in its original first child slot. An empty mask
|
||||
// must also stay there so the clipped artwork cannot become the new mask.
|
||||
set_geometry(d, id, PathData::new(pieces.into_iter().flat_map(|p| p.subpaths).collect()))?;
|
||||
all.push(id);
|
||||
} else {
|
||||
all.extend(replace_with_pieces(d, &mut cut, id, pieces)?);
|
||||
}
|
||||
}
|
||||
cut.finish(d)?;
|
||||
sel.set(all.iter().copied());
|
||||
|
||||
@@ -213,7 +213,11 @@ pub(crate) fn freehand_brushed(s: &mut Session, p: &Value, brush_name: Option<&s
|
||||
let label = if brush || brush_name.is_some() { "Paintbrush" } else { "Pencil" };
|
||||
let keep_selected = switch_or(p, "keepSelected", true, C)?;
|
||||
let filled = switch_or(p, "fill", false, C)?;
|
||||
if let Some(ext) = p.get("extend").filter(|v| !v.is_null()) {
|
||||
let extend = p.get("extend").filter(|v| !v.is_null());
|
||||
if extend.is_none() && p.get("connect").is_some_and(|v| !v.is_null()) {
|
||||
return Err(bad(C, "connect needs extend"));
|
||||
}
|
||||
if let Some(ext) = extend {
|
||||
let id = object_param(ext, "id", C)?.ok_or_else(|| bad(C, "extend needs id"))?;
|
||||
let at_start = match ext.get("end").filter(|v| !v.is_null()).map(Value::as_str) {
|
||||
None | Some(Some("end")) => false,
|
||||
@@ -238,26 +242,9 @@ pub(crate) fn freehand_brushed(s: &mut Session, p: &Value, brush_name: Option<&s
|
||||
};
|
||||
let Some(p0) = pts.first_mut() else { return Err(bad(C, "needs points")) };
|
||||
*p0 = end;
|
||||
if pts.len() < 2 {
|
||||
// No stroke to add: the brush alone changes, when it is not the path's already, and the
|
||||
// path is selected or deselected as a longer continuation leaves it.
|
||||
if let Some(name) = brush_name
|
||||
&& s.doc()?.doc.node(target).and_then(|n| n.appearance.stroke()).is_some_and(|st| st.brush.as_deref() != Some(name))
|
||||
{
|
||||
s.edit("Paintbrush", |d, sel| {
|
||||
set_brush(d, target, name);
|
||||
if keep_selected {
|
||||
sel.set([id]);
|
||||
} else {
|
||||
sel.remove(id);
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
}
|
||||
return Ok(json!({ "id": id.0 }));
|
||||
}
|
||||
// A stroke that ends on an open end of another path connects the two: (that path, its last
|
||||
// open subpath, that subpath starting at the end the stroke ends on, it ends at its end).
|
||||
// It is checked before a stroke of one point returns, so a bad `connect` is refused there too.
|
||||
let connect = match p.get("connect").filter(|v| !v.is_null()) {
|
||||
Some(cn) => {
|
||||
let other = object_param(cn, "id", C)?.ok_or_else(|| bad(C, "connect needs id"))?;
|
||||
@@ -280,6 +267,24 @@ pub(crate) fn freehand_brushed(s: &mut Session, p: &Value, brush_name: Option<&s
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
if pts.len() < 2 {
|
||||
// No stroke to add: the brush alone changes, when it is not the path's already, and the
|
||||
// path is selected or deselected as a longer continuation leaves it.
|
||||
if let Some(name) = brush_name
|
||||
&& s.doc()?.doc.node(target).and_then(|n| n.appearance.stroke()).is_some_and(|st| st.brush.as_deref() != Some(name))
|
||||
{
|
||||
s.edit("Paintbrush", |d, sel| {
|
||||
set_brush(d, target, name);
|
||||
if keep_selected {
|
||||
sel.set([id]);
|
||||
} else {
|
||||
sel.remove(id);
|
||||
}
|
||||
Ok(())
|
||||
})?;
|
||||
}
|
||||
return Ok(json!({ "id": id.0 }));
|
||||
}
|
||||
// `closed`, when given, says whether the stroke closes the path: the Pencil and the
|
||||
// Paintbrush send it, by their Close Paths When Ends Are Within and Alt at the release.
|
||||
// Left out, an extending stroke that ends within four Fidelities of the path's other end
|
||||
|
||||
@@ -6,6 +6,7 @@ use std::sync::Arc;
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_doc::{Document, Node, NodeId, NodeKind, RulerMode, Unit};
|
||||
use vectorcraft_geom::{Affine, Point, Vec2};
|
||||
use vectorcraft_tools::distort::perspective::{PerspectiveGrid, Plane};
|
||||
|
||||
use super::clipboard::SwatchChoices;
|
||||
use super::{
|
||||
@@ -713,6 +714,85 @@ pub(crate) fn settle_interaction(s: &mut Session) -> Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The document state that commands also change without an undo step: the perspective grid's view
|
||||
/// options (whether it shows, Lock Grid, Lock Station Point, Snap to Grid and Show Rulers), its
|
||||
/// active plane, the grid preferences, the export settings, and the current brush and symbol. Each
|
||||
/// undo and redo step keeps it as the document on its other side had it
|
||||
/// ([`crate::HistoryEntry::unrecorded`]).
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub(crate) struct Unrecorded {
|
||||
grid: vectorcraft_doc::GridPrefs,
|
||||
export_settings: serde_json::Map<String, Value>,
|
||||
brush: Option<Value>,
|
||||
symbol: Option<Value>,
|
||||
options: [bool; 5],
|
||||
plane: Plane,
|
||||
}
|
||||
|
||||
impl Unrecorded {
|
||||
pub(crate) fn of(d: &Document) -> Self {
|
||||
let g = PerspectiveGrid::current(d);
|
||||
Unrecorded {
|
||||
grid: d.grid.clone(),
|
||||
export_settings: d.export_settings.clone(),
|
||||
brush: d.unknown.get(vectorcraft_brush::CURRENT_KEY).cloned(),
|
||||
symbol: d.unknown.get(super::brushsym::CURRENT_SYMBOL).cloned(),
|
||||
options: [g.visible, g.locked, g.lock_station, g.snap, g.rulers],
|
||||
plane: g.plane,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Undo and redo bring back `d`; `step` is that state as the document on the step's other side had
|
||||
/// it. A part the step did not change (`d` has it as `step` does) stays as it is in `now`, the
|
||||
/// document before the undo or redo, since it changed after the step without an undo step. A part
|
||||
/// the step changed comes back with `d`. A current brush or symbol that `d` does not hold also
|
||||
/// comes back with `d`. The point Automatic Plane Positioning holds comes back with `d`, and is let go when the
|
||||
/// active plane kept is not the one it holds.
|
||||
fn keep_unrecorded(now: &Document, step: &Unrecorded, d: &mut Arc<Document>) {
|
||||
fn pick<T: Clone + PartialEq>(back: &T, step: &T, now: &T) -> T {
|
||||
if back == step { now.clone() } else { back.clone() }
|
||||
}
|
||||
let back = Unrecorded::of(d);
|
||||
let cur = Unrecorded::of(now);
|
||||
let mut want = Unrecorded {
|
||||
grid: pick(&back.grid, &step.grid, &cur.grid),
|
||||
export_settings: pick(&back.export_settings, &step.export_settings, &cur.export_settings),
|
||||
brush: pick(&back.brush, &step.brush, &cur.brush),
|
||||
symbol: pick(&back.symbol, &step.symbol, &cur.symbol),
|
||||
options: std::array::from_fn(|i| pick(&back.options[i], &step.options[i], &cur.options[i])),
|
||||
plane: pick(&back.plane, &step.plane, &cur.plane),
|
||||
};
|
||||
if want.brush != back.brush && want.brush.as_ref().and_then(Value::as_str).is_some_and(|n| vectorcraft_brush::find(d, n).is_none()) {
|
||||
want.brush = back.brush.clone();
|
||||
}
|
||||
if want.symbol != back.symbol && want.symbol.as_ref().and_then(Value::as_str).is_some_and(|n| !d.symbols.iter().any(|s| s.name == n)) {
|
||||
want.symbol = back.symbol.clone();
|
||||
}
|
||||
if want == back {
|
||||
return;
|
||||
}
|
||||
let m = Arc::make_mut(d);
|
||||
for (key, v) in [(vectorcraft_brush::CURRENT_KEY, &want.brush), (super::brushsym::CURRENT_SYMBOL, &want.symbol)] {
|
||||
match v {
|
||||
Some(v) => m.unknown.insert(key.into(), v.clone()),
|
||||
None => m.unknown.remove(key),
|
||||
};
|
||||
}
|
||||
if (want.options, want.plane) != (back.options, back.plane) {
|
||||
let mut g = PerspectiveGrid::current(m);
|
||||
[g.visible, g.locked, g.lock_station, g.snap, g.rulers] = want.options;
|
||||
if g.plane != want.plane {
|
||||
g.plane = want.plane;
|
||||
g.inferred = None;
|
||||
}
|
||||
g.keep_positioning_valid();
|
||||
super::distortcmds::store_grid(m, &g);
|
||||
}
|
||||
m.grid = want.grid;
|
||||
m.export_settings = want.export_settings;
|
||||
}
|
||||
|
||||
fn undo(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
settle_interaction(s)?;
|
||||
let menu = s.menu.clone();
|
||||
@@ -723,6 +803,7 @@ fn undo(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
let editing = st.doc.mask_edit.map(|m| m.layer);
|
||||
let editing_symbol = st.doc.symbol_edit.clone();
|
||||
let doc = std::mem::replace(&mut st.doc, e.doc);
|
||||
keep_unrecorded(&doc, &e.unrecorded, &mut st.doc);
|
||||
let selection = std::mem::replace(&mut st.selection, Arc::unwrap_or_clone(e.selection));
|
||||
let selection = shared_selection(selection, st.history.redo.last());
|
||||
let mut turned = crate::HistoryEntry::turned(e.label, doc, selection, &st.doc, costs);
|
||||
@@ -758,6 +839,7 @@ fn redo(s: &mut Session, _: &Value) -> Result<Value> {
|
||||
let editing = st.doc.mask_edit.map(|m| m.layer);
|
||||
let editing_symbol = st.doc.symbol_edit.clone();
|
||||
let doc = std::mem::replace(&mut st.doc, e.doc);
|
||||
keep_unrecorded(&doc, &e.unrecorded, &mut st.doc);
|
||||
let selection = std::mem::replace(&mut st.selection, Arc::unwrap_or_clone(e.selection));
|
||||
let selection = shared_selection(selection, st.history.undo.last());
|
||||
let mut turned = crate::HistoryEntry::turned(e.label, doc, selection, &st.doc, costs);
|
||||
@@ -1076,8 +1158,10 @@ fn cut(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
/// Select every surviving piece while retaining intentional compound-path structure.
|
||||
/// `roots` contains the copied targets: whole-object roots are removed in full, while partial paths
|
||||
/// lose only the copied geometry. An exhausted partial path is removed, along with its compound
|
||||
/// parent if now empty; layers remain. Returns JSON `null` on success, replacing direct-selection
|
||||
/// references with surviving object IDs.
|
||||
/// parent if now empty; a compound left with one member stays a compound path, as after Clear;
|
||||
/// layers remain. Removed and replaced roots go through one [`super::pathops::Beside`], which
|
||||
/// rebuilds each parent's children once when the roots are separate. Returns JSON `null` on
|
||||
/// success, replacing direct-selection references with surviving object IDs.
|
||||
fn cut_direct_selection(s: &mut Session, roots: &[NodeId]) -> Result<Value> {
|
||||
let st = s.doc()?;
|
||||
let sel = st.selection.clone();
|
||||
@@ -1085,13 +1169,18 @@ fn cut_direct_selection(s: &mut Session, roots: &[NodeId]) -> Result<Value> {
|
||||
// The selected ruler guides were copied too (#3226): they go in the same undo step.
|
||||
let gone = selection.guides.clone();
|
||||
d.retain_guides(selection, |g| !g.id.is_some_and(|id| gone.contains(&id)));
|
||||
// The compound paths that hold a root; one left with no members goes too.
|
||||
let compounds: BTreeSet<NodeId> = roots
|
||||
.iter()
|
||||
.filter_map(|id| d.parent_of(*id).filter(|p| matches!(d.node(*p).map(|n| &n.kind), Some(NodeKind::Compound { .. }))))
|
||||
.collect();
|
||||
let mut survivors = vec![];
|
||||
let mut pieces = super::pathops::Beside::replacing(d, roots);
|
||||
for id in roots {
|
||||
let Some(node) = d.node(*id) else { continue };
|
||||
let has_direct = sel.anchors.contains_key(id) || sel.segments.contains_key(id);
|
||||
if !has_direct || node.path_data().is_none() {
|
||||
remove_leaving_no_empty_compound(d, *id)?;
|
||||
pieces.put(d, *id, vec![])?;
|
||||
continue;
|
||||
}
|
||||
let original = super::path::deletion_source(d, *id)?;
|
||||
@@ -1114,12 +1203,14 @@ fn cut_direct_selection(s: &mut Session, roots: &[NodeId]) -> Result<Value> {
|
||||
}
|
||||
subpaths.retain(|sp| sp.anchors.len() >= 2);
|
||||
if subpaths.is_empty() {
|
||||
remove_leaving_no_empty_compound(d, *id)?;
|
||||
pieces.put(d, *id, vec![])?;
|
||||
} else {
|
||||
survivors.extend(super::path::replace_deleted_pieces(d, &mut pieces, original, subpaths)?);
|
||||
}
|
||||
}
|
||||
pieces.finish(d)?;
|
||||
let emptied: Vec<NodeId> = compounds.into_iter().filter(|p| d.node(*p).is_some_and(|n| n.children().is_some_and(|c| c.is_empty()))).collect();
|
||||
super::pathops::remove_each(d, &emptied)?;
|
||||
selection.set(survivors);
|
||||
selection.anchors.clear();
|
||||
selection.segments.clear();
|
||||
@@ -1128,19 +1219,6 @@ fn cut_direct_selection(s: &mut Session, roots: &[NodeId]) -> Result<Value> {
|
||||
ok()
|
||||
}
|
||||
|
||||
/// Remove object `id`, and the compound path that held it when it was the compound's last member.
|
||||
/// A compound left with one member stays a compound path, as after Clear.
|
||||
fn remove_leaving_no_empty_compound(d: &mut Document, id: NodeId) -> Result<()> {
|
||||
let parent = d.parent_of(id).filter(|p| matches!(d.node(*p).map(|n| &n.kind), Some(NodeKind::Compound { .. })));
|
||||
d.remove(id)?;
|
||||
if let Some(p) = parent
|
||||
&& d.node(p).is_some_and(|n| n.children().is_some_and(|c| c.is_empty()))
|
||||
{
|
||||
d.remove(p)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn clear(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let guides = switch_or(p, "guides", false, "edit.clear")?;
|
||||
let explicit = if p.get("ids").is_some() { Some(checked_ids_param(s, p, "ids", "edit.clear")?) } else { None };
|
||||
@@ -1751,3 +1829,6 @@ pub(crate) fn copy_above(d: &mut Document, roots: &[NodeId], mut change: impl Fn
|
||||
pub(crate) fn arc_nodes(v: Vec<Node>) -> Vec<Arc<Node>> {
|
||||
v.into_iter().map(Arc::new).collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -0,0 +1,343 @@
|
||||
//! Cut with direct-selected anchors removes the objects selected whole and the paths it empties
|
||||
//! through one [`Beside`](super::super::pathops::Beside), and leaves the document, the selection,
|
||||
//! the clipboard and the undo history exactly as removing each of them on its own does.
|
||||
|
||||
use std::collections::BTreeSet;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use vectorcraft_doc::{Document, NodeId, NodeKind, tree_walks};
|
||||
|
||||
use super::*;
|
||||
use crate::tests_large_edits::{session, square};
|
||||
|
||||
/// Cut's removal with every root selected whole or emptied taken out by its own
|
||||
/// [`Document::remove`], and its compound path removed right after when that left it empty. The
|
||||
/// tests compare [`cut_direct_selection`] with it.
|
||||
fn cut_one_at_a_time(s: &mut Session, roots: &[NodeId]) -> Result<Value> {
|
||||
let st = s.doc()?;
|
||||
let sel = st.selection.clone();
|
||||
s.edit("Cut", |d, selection| {
|
||||
let gone = selection.guides.clone();
|
||||
d.retain_guides(selection, |g| !g.id.is_some_and(|id| gone.contains(&id)));
|
||||
let mut survivors = vec![];
|
||||
let mut pieces = super::super::pathops::Beside::replacing(d, roots);
|
||||
for id in roots {
|
||||
let Some(node) = d.node(*id) else { continue };
|
||||
let has_direct = sel.anchors.contains_key(id) || sel.segments.contains_key(id);
|
||||
if !has_direct || node.path_data().is_none() {
|
||||
remove_one(d, *id)?;
|
||||
continue;
|
||||
}
|
||||
let original = super::super::path::deletion_source(d, *id)?;
|
||||
let seg_refs = sel.segments.get(id);
|
||||
let anchor_refs = sel.anchors.get(id);
|
||||
let mut subpaths = Vec::new();
|
||||
let owned = std::mem::take(&mut super::super::path::path_mut(d, *id)?.subpaths);
|
||||
for (si, sp) in owned.into_iter().enumerate() {
|
||||
let cuts = super::super::clipboard::subpath_selected_segments(&sp, si, seg_refs, anchor_refs);
|
||||
if cuts.is_empty() {
|
||||
subpaths.push(sp);
|
||||
} else if seg_refs.is_some_and(|segments| !segments.is_empty()) {
|
||||
subpaths.extend(super::super::path::without_segments(sp, &cuts));
|
||||
} else {
|
||||
let gone: BTreeSet<usize> = anchor_refs.into_iter().flat_map(|refs| super::super::path::subpath_refs(refs, si)).collect();
|
||||
subpaths.extend(super::super::path::without_anchors(sp, &gone));
|
||||
}
|
||||
}
|
||||
subpaths.retain(|sp| sp.anchors.len() >= 2);
|
||||
if subpaths.is_empty() {
|
||||
remove_one(d, *id)?;
|
||||
} else {
|
||||
survivors.extend(super::super::path::replace_deleted_pieces(d, &mut pieces, original, subpaths)?);
|
||||
}
|
||||
}
|
||||
pieces.finish(d)?;
|
||||
selection.set(survivors);
|
||||
selection.anchors.clear();
|
||||
selection.segments.clear();
|
||||
Ok(())
|
||||
})?;
|
||||
ok()
|
||||
}
|
||||
|
||||
/// Removes object `id`, and the compound path that held it when it was the compound's last member.
|
||||
fn remove_one(d: &mut Document, id: NodeId) -> Result<()> {
|
||||
let parent = d.parent_of(id).filter(|p| matches!(d.node(*p).map(|n| &n.kind), Some(NodeKind::Compound { .. })));
|
||||
d.remove(id)?;
|
||||
if let Some(p) = parent
|
||||
&& d.node(p).is_some_and(|n| n.children().is_some_and(|c| c.is_empty()))
|
||||
{
|
||||
d.remove(p)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Cut as `edit.cut` runs it for a direct selection, with [`cut_one_at_a_time`] in place of
|
||||
/// [`cut_direct_selection`].
|
||||
fn reference_cut(s: &mut Session) {
|
||||
let (direct, roots) = copy_cut_targets(s).unwrap();
|
||||
assert!(direct, "the selection is a direct selection");
|
||||
copy(s, &json!({})).unwrap();
|
||||
cut_one_at_a_time(s, &roots).unwrap();
|
||||
}
|
||||
|
||||
fn run(s: &mut Session, cmd: &str, p: Value) -> Value {
|
||||
s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"))
|
||||
}
|
||||
|
||||
/// Selects `whole` as objects, then anchors `anchors` of each path in `partial`.
|
||||
fn select_direct(s: &mut Session, whole: &[NodeId], partial: &[(NodeId, Value)]) {
|
||||
run(s, "select.set", json!({"ids": whole.iter().map(|id| id.0).collect::<Vec<_>>()}));
|
||||
for (id, anchors) in partial {
|
||||
run(s, "select.anchors", json!({"id": id.0, "anchors": anchors, "mode": "add"}));
|
||||
}
|
||||
}
|
||||
|
||||
/// The ids of every node of the document, depth first, with the depth of each.
|
||||
fn tree(d: &Document) -> Vec<(usize, NodeId)> {
|
||||
fn walk(n: &vectorcraft_doc::Node, depth: usize, out: &mut Vec<(usize, NodeId)>) {
|
||||
out.push((depth, n.id));
|
||||
for c in n.children().into_iter().flatten() {
|
||||
walk(c, depth + 1, out);
|
||||
}
|
||||
}
|
||||
let mut out = vec![];
|
||||
for l in &d.layers {
|
||||
walk(l, 0, &mut out);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Whether `a` and `b` hold the same document, selection, clipboard and number of undo and redo
|
||||
/// steps.
|
||||
fn assert_same(a: &Session, b: &Session, when: &str) {
|
||||
let (x, y) = (a.doc().unwrap(), b.doc().unwrap());
|
||||
assert_eq!(tree(&x.doc), tree(&y.doc), "{when}: the tree");
|
||||
assert!(*x.doc == *y.doc, "{when}: the document");
|
||||
assert_eq!(x.selection, y.selection, "{when}: the selection");
|
||||
// Each session's document has its own uid; the clipboard names the one it came from.
|
||||
assert_eq!(a.clipboard.source_doc.is_some(), b.clipboard.source_doc.is_some(), "{when}: the clipboard's source");
|
||||
let unsourced = |c: &Clipboard| Clipboard { source_doc: None, ..c.clone() };
|
||||
assert!(unsourced(&a.clipboard) == unsourced(&b.clipboard), "{when}: the clipboard");
|
||||
assert_eq!(x.history.undo.len(), y.history.undo.len(), "{when}: the undo steps");
|
||||
assert_eq!(x.history.redo.len(), y.history.redo.len(), "{when}: the redo steps");
|
||||
}
|
||||
|
||||
/// Runs `edit.cut` on one session that `make` builds and [`reference_cut`] on another, and checks
|
||||
/// that both hold the same after the Cut, after Undo and after Redo. Returns the first session after
|
||||
/// the Cut.
|
||||
fn same_as_one_at_a_time(make: impl Fn() -> Session) -> Session {
|
||||
let (mut a, mut b) = (make(), make());
|
||||
let before = a.doc().unwrap().doc.clone();
|
||||
assert_same(&a, &b, "before");
|
||||
run(&mut a, "edit.cut", json!({}));
|
||||
reference_cut(&mut b);
|
||||
assert_same(&a, &b, "Cut");
|
||||
let after = a.doc().unwrap().doc.clone();
|
||||
run(&mut a, "edit.undo", json!({}));
|
||||
run(&mut b, "edit.undo", json!({}));
|
||||
assert_same(&a, &b, "Undo");
|
||||
assert!(*a.doc().unwrap().doc == *before, "Undo gives back the document");
|
||||
run(&mut a, "edit.redo", json!({}));
|
||||
run(&mut b, "edit.redo", json!({}));
|
||||
assert_same(&a, &b, "Redo");
|
||||
assert!(*a.doc().unwrap().doc == *after, "Redo gives back the Cut");
|
||||
run(&mut a, "edit.undo", json!({}));
|
||||
run(&mut a, "edit.redo", json!({}));
|
||||
a
|
||||
}
|
||||
|
||||
/// A new document; [`rect`] adds squares to it.
|
||||
fn new_doc() -> Session {
|
||||
let mut s = Session::new();
|
||||
run(&mut s, "file.new", json!({"width": 800, "height": 600}));
|
||||
s
|
||||
}
|
||||
|
||||
/// Adds a 10 pt square to the current layer, 20 pt right of the last one.
|
||||
fn rect(s: &mut Session) -> NodeId {
|
||||
let x = 20.0 * s.doc().unwrap().doc.node_count() as f64;
|
||||
NodeId(run(s, "shape.rectangle", json!({"x": x, "y": 10, "width": 10, "height": 10}))["id"].as_u64().unwrap())
|
||||
}
|
||||
|
||||
/// Makes a compound path of `ids` and returns it with its members in order.
|
||||
fn compound(s: &mut Session, ids: &[NodeId]) -> (NodeId, Vec<NodeId>) {
|
||||
run(s, "select.set", json!({"ids": ids.iter().map(|id| id.0).collect::<Vec<_>>()}));
|
||||
let c = NodeId(run(s, "object.compoundPath.make", json!({}))["id"].as_u64().unwrap());
|
||||
let members = s.doc().unwrap().doc.node(c).unwrap().children().unwrap().iter().map(|m| m.id).collect();
|
||||
(c, members)
|
||||
}
|
||||
|
||||
/// Anchors 0 to 2 of a square: Cut leaves it no segment, so it is removed.
|
||||
fn three_anchors() -> Value {
|
||||
json!([[0, 0], [0, 1], [0, 2]])
|
||||
}
|
||||
|
||||
/// Anchors 0 and 1 of a square: Cut keeps its other three sides.
|
||||
fn two_anchors() -> Value {
|
||||
json!([[0, 0], [0, 1]])
|
||||
}
|
||||
|
||||
/// The compound path whose members are cut one whole and one emptied goes with them; the other
|
||||
/// compound path keeps its one member left, as a compound path.
|
||||
#[test]
|
||||
fn cut_removes_a_compound_whose_members_all_go_and_keeps_one_with_one_member_left() {
|
||||
let make = || {
|
||||
let mut s = new_doc();
|
||||
let first = [(); 2].map(|()| rect(&mut s));
|
||||
let (gone, gone_members) = compound(&mut s, &first);
|
||||
let second = [(); 3].map(|()| rect(&mut s));
|
||||
let (kept, kept_members) = compound(&mut s, &second);
|
||||
let other = rect(&mut s);
|
||||
select_direct(
|
||||
&mut s,
|
||||
&[gone_members[0], kept_members[0]],
|
||||
&[(gone_members[1], three_anchors()), (kept_members[1], three_anchors()), (other, two_anchors())],
|
||||
);
|
||||
(s, gone, kept, kept_members[2], other)
|
||||
};
|
||||
let s = same_as_one_at_a_time(|| make().0);
|
||||
let (_, gone, kept, left, other) = make();
|
||||
let d = &s.doc().unwrap().doc;
|
||||
assert!(d.node(gone).is_none(), "the compound path whose members all went is removed");
|
||||
let kept = d.node(kept).expect("the compound path with a member left stays");
|
||||
assert!(matches!(kept.kind, NodeKind::Compound { .. }));
|
||||
assert_eq!(kept.children().unwrap().iter().map(|m| m.id).collect::<Vec<_>>(), [left]);
|
||||
assert_eq!(s.doc().unwrap().selection.objects, [other], "the cut square's other sides stay selected");
|
||||
}
|
||||
|
||||
/// Objects inside two groups and on the layer, removed whole, emptied or cut apart between kept
|
||||
/// siblings, keep the order and ids that removing them one at a time leaves.
|
||||
#[test]
|
||||
fn cut_inside_groups_keeps_the_order_and_ids_of_removing_one_at_a_time() {
|
||||
let make = || {
|
||||
let mut s = new_doc();
|
||||
let a = [(); 4].map(|()| rect(&mut s));
|
||||
run(&mut s, "select.set", json!({"ids": a.iter().map(|id| id.0).collect::<Vec<_>>()}));
|
||||
run(&mut s, "object.group", json!({}));
|
||||
let b = [(); 4].map(|()| rect(&mut s));
|
||||
run(&mut s, "select.set", json!({"ids": b.iter().map(|id| id.0).collect::<Vec<_>>()}));
|
||||
run(&mut s, "object.group", json!({}));
|
||||
let c = [(); 4].map(|()| rect(&mut s));
|
||||
select_direct(
|
||||
&mut s,
|
||||
&[a[0], a[2], b[3], c[1]],
|
||||
&[(a[1], two_anchors()), (b[0], three_anchors()), (b[2], two_anchors()), (c[3], three_anchors())],
|
||||
);
|
||||
s
|
||||
};
|
||||
let s = same_as_one_at_a_time(make);
|
||||
assert_eq!(s.doc().unwrap().selection.objects.len(), 2, "the two squares cut apart stay selected");
|
||||
}
|
||||
|
||||
/// Selected ruler guides go with the objects, in the Cut's undo step.
|
||||
#[test]
|
||||
fn cut_removes_the_selected_guides_with_the_objects() {
|
||||
let make = || {
|
||||
let mut s = new_doc();
|
||||
let [a, b, c] = [(); 3].map(|()| rect(&mut s));
|
||||
run(&mut s, "guide.add", json!({"vertical": true, "pos": 30}));
|
||||
run(&mut s, "guide.add", json!({"vertical": false, "pos": 40}));
|
||||
select_direct(&mut s, &[a, c], &[(b, two_anchors())]);
|
||||
run(&mut s, "guide.select", json!({"indexes": [1], "toggle": true}));
|
||||
s
|
||||
};
|
||||
let s = same_as_one_at_a_time(make);
|
||||
assert_eq!(s.doc().unwrap().doc.ruler_guides().len(), 1, "the selected guide is removed");
|
||||
assert_eq!(s.clipboard.guides.len(), 1, "the selected guide is on the clipboard");
|
||||
}
|
||||
|
||||
/// Roots that are not separate (one inside another) are removed one at a time, as before.
|
||||
#[test]
|
||||
fn cut_of_roots_inside_another_root_matches_removing_one_at_a_time() {
|
||||
let make = || {
|
||||
let mut s = new_doc();
|
||||
let a = [(); 3].map(|()| rect(&mut s));
|
||||
run(&mut s, "select.set", json!({"ids": a.iter().map(|id| id.0).collect::<Vec<_>>()}));
|
||||
let group = NodeId(run(&mut s, "object.group", json!({}))["id"].as_u64().unwrap());
|
||||
let b = rect(&mut s);
|
||||
select_direct(&mut s, &[group, b], &[(a[1], two_anchors())]);
|
||||
(s, vec![a[1], group, b])
|
||||
};
|
||||
let (mut x, roots) = make();
|
||||
let (mut y, _) = make();
|
||||
copy(&mut x, &json!({})).unwrap();
|
||||
copy(&mut y, &json!({})).unwrap();
|
||||
cut_direct_selection(&mut x, &roots).unwrap();
|
||||
cut_one_at_a_time(&mut y, &roots).unwrap();
|
||||
assert_same(&x, &y, "Cut");
|
||||
}
|
||||
|
||||
/// One layer of 10,000 squares with every fifth of the first 10,000 selected whole (2,000) and
|
||||
/// anchors 0 and 1 of the square after them picked.
|
||||
fn many() -> Session {
|
||||
let mut s = session(10_001, square);
|
||||
let ids = crate::tests_large_edits::layer(&s, 0);
|
||||
let whole: Vec<NodeId> = ids.iter().take(10_000).step_by(5).copied().collect();
|
||||
select_direct(&mut s, &whole, &[(ids[10_000], two_anchors())]);
|
||||
s
|
||||
}
|
||||
|
||||
/// The tree walks [`tree_walks`] counts while `f` runs on `s`.
|
||||
fn walks(s: &mut Session, f: impl FnOnce(&mut Session)) -> u64 {
|
||||
let before = tree_walks();
|
||||
f(s);
|
||||
tree_walks() - before
|
||||
}
|
||||
|
||||
/// Cut of 2,000 objects selected whole among 10,000, with a direct selection, walks the document's
|
||||
/// tree a few times, where removing them one at a time walks it several times for each object.
|
||||
#[test]
|
||||
fn direct_selection_cut_of_2000_of_10000_objects_takes_few_tree_walks() {
|
||||
let s = same_as_one_at_a_time(many);
|
||||
assert_eq!(crate::tests_large_edits::layer(&s, 0).len(), 8_001);
|
||||
let (mut a, mut b) = (many(), many());
|
||||
let batched = walks(&mut a, |s| {
|
||||
run(s, "edit.cut", json!({}));
|
||||
});
|
||||
let one_at_a_time = walks(&mut b, reference_cut);
|
||||
println!("tree walks: Cut {batched}, one at a time {one_at_a_time}");
|
||||
assert!(batched <= 64, "Cut walked the document's tree {batched} times");
|
||||
assert!(one_at_a_time >= 4 * batched.max(1), "one at a time walked it {one_at_a_time} times, Cut {batched}");
|
||||
}
|
||||
|
||||
/// This thread's CPU time, where the system reports it (`/proc/thread-self/schedstat` on Linux).
|
||||
fn cpu_time() -> Option<Duration> {
|
||||
let stat = std::fs::read_to_string("/proc/thread-self/schedstat").ok()?;
|
||||
stat.split_whitespace().next()?.parse().ok().map(Duration::from_nanos)
|
||||
}
|
||||
|
||||
/// The middle of `v`.
|
||||
fn median(mut v: Vec<Duration>) -> Duration {
|
||||
v.sort_unstable();
|
||||
v[v.len() / 2]
|
||||
}
|
||||
|
||||
/// Times Cut of [`many`] and [`reference_cut`] seven times each, in turn, and prints every run's
|
||||
/// CPU and wall-clock time with the medians. Run it with
|
||||
/// `cargo test --release -p vectorcraft-engine --lib -- --ignored --nocapture direct_selection_cut_timing`.
|
||||
#[test]
|
||||
#[ignore = "timing; prints the numbers"]
|
||||
fn direct_selection_cut_timing() {
|
||||
let mut runs: [(Vec<Duration>, Vec<Duration>); 2] = Default::default();
|
||||
for round in 0..7 {
|
||||
for (k, (cpu, wall)) in runs.iter_mut().enumerate() {
|
||||
let mut s = many();
|
||||
let (c0, w0) = (cpu_time(), Instant::now());
|
||||
if k == 0 {
|
||||
reference_cut(&mut s);
|
||||
} else {
|
||||
run(&mut s, "edit.cut", json!({}));
|
||||
}
|
||||
let w = w0.elapsed();
|
||||
let c = c0.zip(cpu_time()).map(|(a, b)| b.saturating_sub(a)).unwrap_or(w);
|
||||
println!("round {round} {}: cpu {c:?}, wall {w:?}", ["one at a time", "Cut"][k]);
|
||||
cpu.push(c);
|
||||
wall.push(w);
|
||||
}
|
||||
}
|
||||
for (k, (cpu, wall)) in runs.into_iter().enumerate() {
|
||||
println!("median {}: cpu {:?}, wall {:?}", ["one at a time", "Cut"][k], median(cpu), median(wall));
|
||||
}
|
||||
}
|
||||
@@ -28,7 +28,7 @@ pub(super) fn specs() -> Vec<CommandSpec> {
|
||||
"Map Graphic",
|
||||
[],
|
||||
None,
|
||||
"{symbol: name of a document symbol, face?: front|back (front; Plane has only a front; the back reads left to right as seen from behind; on Revolve the front is its swept side, which is the only face), x?: pt, y?: pt (0, 0: the offset of the graphic's center from the center of the object's bounds, in the face's own plane; on Revolve from the middle of the side unrolled flat, x around the axis and y along the profile), scale?: % (1..10000; default 100, or less so the graphic fits inside the object, on Revolve inside the half of the side seen from the front), rotation?: degrees (-360..360, 0; counterclockwise), index?: int (the 3D effect's position; default: each object's first 3D effect, its own before its fills' and strokes'), item?: appearance item index|null (refused without index; as effect.setParams), ids?|id?} add a graphic to the 3D effect of each selected object, drawn on that face turned, foreshortened and shaded with it and clipped to it (on Revolve wrapped around the side, and drawn only where its outside faces the viewer); every object's 3D effect must be Extrude & Bevel (on a solid cap), Rotate (the Plane type) or Revolve; one undo step → {ids, graphic}",
|
||||
"{symbol: name of a document symbol, face?: front|back|side (front; Plane has only a front; the back reads left to right as seen from behind; side is Extrude & Bevel's walls and bevels; on Revolve the front is its swept side, which is the only face), x?: pt, y?: pt (0, 0: the offset of the graphic's center from the center of the object's bounds, in the face's own plane; on a side from the middle of the side unrolled flat: on Extrude & Bevel x along the outline, clockwise from its top, and y from the front toward the back; on Revolve x around the axis and y along the profile), scale?: % (1..10000; default 100, or less so the graphic fits inside the object, on Extrude & Bevel's side inside the side unrolled about x = 0, short of its cut, on Revolve inside the half of the side seen from the front), rotation?: degrees (-360..360, 0; counterclockwise), index?: int (the 3D effect's position; default: each object's first 3D effect, its own before its fills' and strokes'), item?: appearance item index|null (refused without index; as effect.setParams), ids?|id?} add a graphic to the 3D effect of each selected object, drawn on that face turned, foreshortened and shaded with it and clipped to it (on a side wrapped around it, and drawn only where its outside faces the viewer); every object's 3D effect must be Extrude & Bevel (on a solid cap, or on the side, hollow or not), Rotate (the Plane type) or Revolve; one undo step → {ids, graphic}",
|
||||
has_doc,
|
||||
map_graphic
|
||||
),
|
||||
@@ -113,22 +113,32 @@ fn map_graphic(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
if !effects::takes_graphics(&effect.id) {
|
||||
return Err(bad(C, format!("object {}: {}", id.0, effects::GRAPHICS_NOT_TAKEN)));
|
||||
}
|
||||
// A hollow Extrude & Bevel keeps the graphics it has, to show when Cap is turned on again,
|
||||
// but has no cap to show a new one on.
|
||||
// A hollow Extrude & Bevel keeps the graphics it has on its caps, to show when Cap is turned
|
||||
// on again, but has no cap to show a new one on. Its side takes graphics.
|
||||
let merged = effects::merged_params(&effect.id, &effect.params);
|
||||
let extrude = (effect.id == effects::EXTRUDE).then(|| effects::extrude_options(&merged));
|
||||
if extrude.is_some_and(|o| o.depth > 0.0 && !o.cap) {
|
||||
let side = base.face == effects::PlanarFace::Side;
|
||||
if !side && extrude.is_some_and(|o| o.depth > 0.0 && !o.cap) {
|
||||
return Err(bad(C, format!("object {}: a hollow Extrude & Bevel has no caps: turn on Cap to map a graphic", id.0)));
|
||||
}
|
||||
// With a depth of 0 the art is a plane, which has only a front.
|
||||
if base.face == effects::PlanarFace::Back && extrude.is_some_and(|o| o.depth <= 0.0) {
|
||||
if base.face != effects::PlanarFace::Front && extrude.is_some_and(|o| o.depth <= 0.0) {
|
||||
return Err(bad(C, format!("object {}: with a depth of 0 the object has one face: map its graphics onto the front", id.0)));
|
||||
}
|
||||
let mut graphic = base.clone();
|
||||
if p.get("scale").is_none()
|
||||
&& let (Some(frame), Some(art)) = (effects::graphic_frame_at(Some(d), n, item, index), effects::graphic_bounds(d, &graphic.symbol))
|
||||
&& let Some(art) = effects::graphic_bounds(d, &graphic.symbol)
|
||||
{
|
||||
graphic.scale = frame.fitting_scale(art);
|
||||
// A graphic on the side starts fitting inside the side unrolled about x = 0, short of
|
||||
// its cut; one on a cap inside the object's bounds.
|
||||
let fit = if side {
|
||||
effects::graphic_side_size(Some(d), n, item, index).map(|(w, h)| effects::graphic_fitting_scale(w, h, art))
|
||||
} else {
|
||||
effects::graphic_frame_at(Some(d), n, item, index).map(|frame| frame.fitting_scale(art))
|
||||
};
|
||||
if let Some(fit) = fit {
|
||||
graphic.scale = fit;
|
||||
}
|
||||
}
|
||||
let params = effects::with_graphic(&effects::merged_params(&effect.id, &effect.params), &graphic);
|
||||
effects::validate_three_d_at_in(Some(d), n, &effect.id, ¶ms, (item, index)).map_err(|e| bad(C, e))?;
|
||||
|
||||
@@ -135,6 +135,47 @@ fn map_graphic_refuses_what_cannot_take_it_and_changes_nothing() {
|
||||
assert!(s.execute("threeD.mapGraphic", &json!({"symbol": "Mark", "ids": [id.0]})).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn map_graphic_puts_a_graphic_on_the_side_of_an_extrude() {
|
||||
let (mut s, id) = setup("threeD.extrude");
|
||||
// A hollow Extrude & Bevel takes a graphic on its side.
|
||||
s.execute("effect.setParams", &json!({"index": 0, "item": null, "params": {"cap": false}})).unwrap();
|
||||
s.execute("threeD.mapGraphic", &json!({"symbol": "Mark", "face": "side", "y": 4.0, "ids": [id.0]})).unwrap();
|
||||
assert_eq!(graphics(&s, id), json!([{"symbol": "Mark", "face": "side", "x": 0.0, "y": 4.0, "scale": 100.0, "rotation": 0.0}]));
|
||||
// A plane, and a depth of 0, have no side.
|
||||
let (mut s, plane) = setup("threeD.rotate");
|
||||
let history = undo_len(&s);
|
||||
let e = s.execute("threeD.mapGraphic", &json!({"symbol": "Mark", "face": "side", "ids": [plane.0]})).unwrap_err().to_string();
|
||||
assert!(e.contains("one face"), "{e}");
|
||||
assert_eq!(undo_len(&s), history);
|
||||
let (mut s, flat) = setup("threeD.extrude");
|
||||
s.execute("effect.setParams", &json!({"index": 0, "item": null, "params": {"depth": 0.0}})).unwrap();
|
||||
let history = undo_len(&s);
|
||||
let e = s.execute("threeD.mapGraphic", &json!({"symbol": "Mark", "face": "side", "ids": [flat.0]})).unwrap_err().to_string();
|
||||
assert!(e.contains("one face"), "{e}");
|
||||
assert_eq!(undo_len(&s), history);
|
||||
// A graphic taller than the side starts scaled to fit it: the side of the 100 × 100 square is
|
||||
// about 300 pt wide short of its cut and 10 pt deep here, and the graphic with its stroke is
|
||||
// 11 × 21.
|
||||
let (mut s, id) = setup("threeD.extrude");
|
||||
s.execute("effect.setParams", &json!({"index": 0, "item": null, "params": {"depth": 10.0}})).unwrap();
|
||||
s.execute("threeD.mapGraphic", &json!({"symbol": "Mark", "face": "side", "ids": [id.0]})).unwrap();
|
||||
let scale = graphics(&s, id)[0]["scale"].as_f64().unwrap();
|
||||
assert!((scale - 1000.0 / 21.0).abs() < 1e-9, "{scale}");
|
||||
// A graphic wider than the side is kept short of the cut, at a bottom corner of the square: the
|
||||
// part about x = 0 is three quarters of the outline.
|
||||
let (mut s, id) = setup("threeD.extrude");
|
||||
let wide = s.execute("path.create", &json!({"d":"M0 380L400 380L400 390L0 390Z"})).unwrap()["id"].clone();
|
||||
s.execute("threeD.addGraphic", &json!({"name": "Wide", "ids": [wide]})).unwrap();
|
||||
s.execute("threeD.mapGraphic", &json!({"symbol": "Wide", "face": "side", "ids": [id.0]})).unwrap();
|
||||
let d = &s.doc().unwrap().doc;
|
||||
let (span, _) = vectorcraft_render::effects::graphic_side_size(Some(d), d.node(id).unwrap(), None, 0).unwrap();
|
||||
let art = vectorcraft_render::effects::graphic_bounds(d, "Wide").unwrap();
|
||||
assert!((span - 300.0).abs() < 1e-6 || (span - 303.0).abs() < 1e-6, "{span}");
|
||||
let scale = graphics(&s, id)[0]["scale"].as_f64().unwrap();
|
||||
assert!((scale - 100.0 * span / art.width()).abs() < 1e-9, "{scale}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_params_edits_graphics_and_checks_them() {
|
||||
let (mut s, id) = setup("threeD.extrude");
|
||||
|
||||
@@ -65,6 +65,7 @@ pub mod zip;
|
||||
|
||||
use serde_json::{Value, json};
|
||||
|
||||
pub(crate) use action_batch::action_step;
|
||||
pub use action_batch::batch_overwrites_one_file;
|
||||
pub use dxf::{UNSUPPORTED, Unsupported, unsupported};
|
||||
pub use encode::{
|
||||
@@ -95,7 +96,7 @@ pub use naming::{NameParts as FileNameParts, parse_date as parse_file_date, rend
|
||||
pub(crate) use native::preview_png;
|
||||
pub use native::with_compression_pref;
|
||||
pub(crate) use pdfimport::opened_page_document;
|
||||
pub use pdfimport::{LoadOptions, page_document};
|
||||
pub use pdfimport::{LoadOptions, page_document, pages_can_link};
|
||||
pub(crate) use psdlayers::import_active as psd_layers;
|
||||
pub use psdlayers::{PsdInfo, info as psd_info};
|
||||
pub(crate) use psdslices::over as psd_slices;
|
||||
|
||||
@@ -144,8 +144,9 @@ pub(crate) fn check_scripts_of(cmd: &str, doc: &vectorcraft_doc::Document, doc_p
|
||||
}
|
||||
|
||||
/// Does a file of a document with `artboards` artboards, written in format `format` with options
|
||||
/// `p`, name the JavaScript files the document links? SVG, SVGZ, native files, native templates and
|
||||
/// EPS files always do. A `.ai` or `.ait` file does unless it is a legacy version 7 `.ai` file or `p`
|
||||
/// `p`, name the JavaScript files the document links? SVG, SVGZ, native files, native templates,
|
||||
/// EPS files and the files of an exporter plug-in's format (`plugin.<id>`, whose plug-in is given
|
||||
/// the native document's JSON) always do. A `.ai` or `.ait` file does unless it is a legacy version 7 `.ai` file or `p`
|
||||
/// picks only some of the artboards; a PDF does with Preserve Editing on (as its preset, standard and
|
||||
/// options leave it) unless `p` picks only some of the artboards. Neither a `.ai` file nor a PDF
|
||||
/// does when `useArtboards` is false in `p` (one page, the bounds of the art). Options the encoder
|
||||
@@ -159,6 +160,7 @@ pub(crate) fn names_linked_scripts(cmd: &str, format: &str, p: &Value, artboards
|
||||
let art_page = || super::encode::use_artboards(cmd, p).is_ok_and(|u| u == Some(false));
|
||||
match format {
|
||||
"svg" | "svgz" | "vectorcraft" | "template" | "eps" => true,
|
||||
_ if vectorcraft_plugins::export::plugin_id(format).is_some() => true,
|
||||
"ai" | "ait" => {
|
||||
let legacy = super::format(format).is_some_and(|f| super::legacy_ai::wanted(cmd, f, p).unwrap_or(false));
|
||||
!legacy && !(format == "ai" && art_page()) && every_artboard()
|
||||
@@ -228,7 +230,8 @@ pub(crate) fn check_images_in(cmd: &str, format: &str, d: &vectorcraft_doc::Docu
|
||||
|
||||
/// `cmd` may write `d` in format `format` (a format id other than SVG and SVGZ) with options `p`:
|
||||
/// always, unless read roots are in force, the file carries the native document (a native file or
|
||||
/// template, an EPS file, a `.ai` or `.ait` file or a PDF with Preserve Editing, as
|
||||
/// template, an EPS file, a `.ai` or `.ait` file, a PDF with Preserve Editing or an exporter
|
||||
/// plug-in's file, as
|
||||
/// [`names_linked_scripts`] counts them with `d`'s artboards) and that document names a file
|
||||
/// outside them ([`crate::cmd::links::names_hidden_file`]: a linked image or placed file, the
|
||||
/// relative path kept of one taken from `base`, a data set's image, or stored brushes that can't be
|
||||
|
||||
@@ -54,24 +54,19 @@ pub(super) fn action_batch(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
for (i, c) in cmds.iter().enumerate() {
|
||||
let id = c.get("command").and_then(Value::as_str).unwrap_or("");
|
||||
let refuse = |reason: &str| bad(C, action_step(i, id, reason));
|
||||
if id.is_empty() {
|
||||
return Err(bad(C, format!("commands[{i}]: missing `command`")));
|
||||
return Err(refuse("missing `command`"));
|
||||
}
|
||||
if id == "command.batch" || id == "action.batch" {
|
||||
return Err(bad(C, "batches cannot nest"));
|
||||
return Err(refuse("batches cannot nest"));
|
||||
}
|
||||
// `command.batch` refuses the batch when it reaches this step, which would fail every file or data set it plays.
|
||||
if id == "prefs.import" {
|
||||
return Err(bad(C, format!("commands[{i}]: `prefs.import` runs on its own, not as a batch step")));
|
||||
return Err(refuse("`prefs.import` runs on its own, not as a batch step"));
|
||||
}
|
||||
if find_command(id).is_none() {
|
||||
return Err(bad(
|
||||
C,
|
||||
match super::super::params::nearest_command(id) {
|
||||
Some(near) => format!("commands[{i}]: unknown command `{id}`; did you mean `{near}`?"),
|
||||
None => format!("commands[{i}]: unknown command `{id}`"),
|
||||
},
|
||||
));
|
||||
return Err(refuse(&super::super::params::unknown_command(id).to_string()));
|
||||
}
|
||||
}
|
||||
// Every option is checked before the destination folder is made.
|
||||
@@ -160,7 +155,7 @@ pub fn batch_overwrites_one_file(s: &Session, p: &Value) -> bool {
|
||||
Some(f) => own_format.is_some_and(|own| super::format(f).is_some_and(|f| f.id == own)),
|
||||
};
|
||||
match c.get("command").and_then(Value::as_str).unwrap_or("") {
|
||||
"document.save" | "file.save" => !save && (path || own_file()),
|
||||
"document.save" => !save && (path || own_file()),
|
||||
"file.saveAs" => !save && path,
|
||||
"file.saveCopy" | "file.saveAsTemplate" => path,
|
||||
"document.export" | "document.exportSelection" => !export && path,
|
||||
@@ -184,7 +179,7 @@ fn saves_move_to_each_file(steps: &[Value], redirected: bool) -> bool {
|
||||
/// in the destination folder when `redirected`) and makes that file the document's own: a save in
|
||||
/// the native template format writes a copy and leaves the document's file as it was.
|
||||
fn retargeting_save(c: &Value, redirected: bool) -> bool {
|
||||
if !matches!(c.get("command").and_then(Value::as_str), Some("document.save" | "file.save" | "file.saveAs")) {
|
||||
if !matches!(c.get("command").and_then(Value::as_str), Some("document.save" | "file.saveAs")) {
|
||||
return false;
|
||||
}
|
||||
let params = c.get("params");
|
||||
@@ -219,7 +214,7 @@ fn batch_folder(s: &mut Session, cmd: &str, p: &Value, override_open: bool, run:
|
||||
// open, so its artboard files count ([`dataset_output_paths`]). No output takes the name of a
|
||||
// source file in the destination folder, other than that file's own output, or of a subfolder
|
||||
// of the destination folder that holds source files.
|
||||
let (steps, places) = filter_steps(run.steps, override_open, false);
|
||||
let (steps, places) = filter_steps(run.steps, override_open);
|
||||
let run = Run { steps: &steps, ..*run };
|
||||
let in_dest: Vec<Option<(String, bool)>> = files.iter().map(|path| name_in_folder(path, run.dest_folder)).collect();
|
||||
let mut picker =
|
||||
@@ -272,7 +267,7 @@ fn batch_datasets(s: &mut Session, cmd: &str, run: &Run<'_>) -> Result<Value> {
|
||||
}
|
||||
let doc_stem = st.path.as_deref().and_then(|p| std::path::Path::new(p).file_stem().and_then(|s| s.to_str())).unwrap_or("Untitled").to_string();
|
||||
let stems = dataset_stems(&names, &doc_stem, run.dataset_file_naming, run, &st.doc)?;
|
||||
let (steps, places) = filter_steps(run.steps, true, false);
|
||||
let (steps, places) = filter_steps(run.steps, true);
|
||||
let run = Run { steps: &steps, ..*run };
|
||||
let mut processed = Vec::new();
|
||||
let mut failed = 0usize;
|
||||
@@ -353,22 +348,13 @@ impl StemPicker {
|
||||
}
|
||||
}
|
||||
|
||||
/// Drop Open (and optionally Close) steps when the batch supplies the file itself → the steps that
|
||||
/// stay, and the index of each in `cmds`.
|
||||
/// Drop the `document.open` steps when `drop_open` (the batch opens each source file itself) → the
|
||||
/// steps that stay, and the index of each in `cmds`.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
fn filter_steps(cmds: &[Value], drop_open: bool, drop_close: bool) -> (Vec<Value>, Vec<usize>) {
|
||||
fn filter_steps(cmds: &[Value], drop_open: bool) -> (Vec<Value>, Vec<usize>) {
|
||||
cmds.iter()
|
||||
.enumerate()
|
||||
.filter(|(_, c)| {
|
||||
let id = c.get("command").and_then(Value::as_str).unwrap_or("");
|
||||
if drop_open && matches!(id, "document.open" | "file.open") {
|
||||
return false;
|
||||
}
|
||||
if drop_close && matches!(id, "file.close" | "document.close") {
|
||||
return false;
|
||||
}
|
||||
true
|
||||
})
|
||||
.filter(|(_, c)| !(drop_open && c.get("command").and_then(Value::as_str) == Some("document.open")))
|
||||
.map(|(i, c)| (c.clone(), i))
|
||||
.unzip()
|
||||
}
|
||||
@@ -385,12 +371,24 @@ fn play_steps(s: &mut Session, run: &Run<'_>, places: &[usize], commands: Vec<Va
|
||||
let Some((n, id, reason)) = batch_step_failure(&text) else { return e };
|
||||
let same = run.steps.get(n).and_then(|c| c.get("command")).and_then(Value::as_str) == Some(id);
|
||||
match places.get(n) {
|
||||
Some(place) if same => EngineError::Other(format!("action step {} (`{id}`) failed: {reason}", place + 1)),
|
||||
Some(&place) if same => EngineError::Other(action_step(place, id, reason)),
|
||||
_ => e,
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// The text naming the member at `index` of an `action.batch`'s `commands`, counted from 1, with
|
||||
/// its command id when it has one, and `reason`: ``action step 2 (`object.move`) failed: …``. The
|
||||
/// checks before a batch runs and the errors of its steps as they run give the same text.
|
||||
pub(crate) fn action_step(index: usize, id: &str, reason: &str) -> String {
|
||||
let n = index.saturating_add(1);
|
||||
if id.is_empty() {
|
||||
format!("action step {n} failed: {reason}")
|
||||
} else {
|
||||
format!("action step {n} (`{}`) failed: {reason}", vectorcraft_apischema::shown_key(id))
|
||||
}
|
||||
}
|
||||
|
||||
/// The step number, command id and reason in the error `command.batch` gives when one of its steps
|
||||
/// fails (``batch step 2 (`object.move`) failed: …``); none for any other error.
|
||||
#[cfg(not(target_arch = "wasm32"))]
|
||||
@@ -540,7 +538,7 @@ fn dataset_output_extensions(run: &Run<'_>, doc: &vectorcraft_doc::Document, def
|
||||
outputs.push(DatasetOutput { ext: String::new(), artboards: false, joiner: "-", folder: true });
|
||||
continue;
|
||||
}
|
||||
let writes = (run.override_save && matches!(id, "document.save" | "file.save" | "file.saveAs"))
|
||||
let writes = (run.override_save && matches!(id, "document.save" | "file.saveAs"))
|
||||
|| (run.override_export && matches!(id, "document.export" | "document.exportSelection"));
|
||||
if writes {
|
||||
let format = step.get("params").and_then(|p| p.get("format")).and_then(Value::as_str).filter(|f| !f.is_empty());
|
||||
@@ -551,7 +549,7 @@ fn dataset_output_extensions(run: &Run<'_>, doc: &vectorcraft_doc::Document, def
|
||||
};
|
||||
if safe_extension(&ext) {
|
||||
let format_id = super::format(format.unwrap_or(default_ext)).map(|f| f.id).unwrap_or("vectorcraft");
|
||||
let is_save = matches!(id, "document.save" | "file.save" | "file.saveAs");
|
||||
let is_save = matches!(id, "document.save" | "file.saveAs");
|
||||
let artboards = if is_save {
|
||||
!doc.artboards.is_empty() && matches!(format_id, "vectorcraft" | "template" | "ai" | "ait")
|
||||
} else {
|
||||
@@ -693,7 +691,7 @@ fn rewrite_paths(
|
||||
.map(|c| {
|
||||
let id = c.get("command").and_then(Value::as_str).unwrap_or("");
|
||||
let mut c = c.clone();
|
||||
let rewrite = (override_save && matches!(id, "document.save" | "file.save" | "file.saveAs"))
|
||||
let rewrite = (override_save && matches!(id, "document.save" | "file.saveAs"))
|
||||
|| (override_export && matches!(id, "document.export" | "document.exportForScreens" | "document.exportSelection" | "assets.export"));
|
||||
if !rewrite {
|
||||
return c;
|
||||
@@ -2385,10 +2383,97 @@ mod tests {
|
||||
let mut s = Session::new();
|
||||
let p = json!({"folder": src.to_string_lossy(), "commands": [{"command": "object.unlockAll"}, {"command": "prefs.import", "params": {}}]});
|
||||
let e = s.execute("action.batch", &p).unwrap_err().to_string();
|
||||
assert!(e.contains("commands[1]: `prefs.import` runs on its own, not as a batch step"), "{e}");
|
||||
assert!(e.contains("action step 2 (`prefs.import`) failed: `prefs.import` runs on its own, not as a batch step"), "{e}");
|
||||
assert!(s.active().is_none(), "no file was opened");
|
||||
}
|
||||
|
||||
/// Each step the checks before the batch refuse is named by its place in `commands`, from 1,
|
||||
/// as a step that fails as it runs is, and no source file is opened.
|
||||
#[test]
|
||||
fn a_refused_step_is_named_by_its_place_from_1() {
|
||||
let src = tmp("step-number-refused-src");
|
||||
write_svg(&src, "a.svg", "#f00");
|
||||
let prefix = "invalid parameters for `action.batch`: ";
|
||||
let cases = [
|
||||
(json!({"params": {}}), "action step 2 failed: missing `command`"),
|
||||
(json!({"command": "select.al"}), "action step 2 (`select.al`) failed: unknown command `select.al`; did you mean `select.all`?"),
|
||||
(json!({"command": "command.batch", "params": {"commands": []}}), "action step 2 (`command.batch`) failed: batches cannot nest"),
|
||||
(json!({"command": "action.batch", "params": {}}), "action step 2 (`action.batch`) failed: batches cannot nest"),
|
||||
(
|
||||
json!({"command": "view.saved.new", "params": {"center": [0, 0], "zoom": 0}}),
|
||||
"action step 2 (`view.saved.new`) failed: invalid parameters for `view.saved.new`: `zoom` must be a number > 0, not 0",
|
||||
),
|
||||
];
|
||||
for (step, want) in cases {
|
||||
let mut s = Session::new();
|
||||
let p = json!({"folder": src.to_string_lossy(), "commands": [{"command": "object.unlockAll"}, step]});
|
||||
let e = s.execute("action.batch", &p).unwrap_err().to_string();
|
||||
assert_eq!(e, format!("{prefix}{want}"), "{step}");
|
||||
assert!(s.active().is_none(), "{step}: a file was opened");
|
||||
assert!(s.journal.is_empty(), "{step}: a step ran");
|
||||
}
|
||||
}
|
||||
|
||||
/// The parameter check of an `action.batch` names the step whose params it refuses, from 1;
|
||||
/// that of a `command.batch` passes the step's error on as it is.
|
||||
#[test]
|
||||
fn the_parameter_check_names_the_refused_step() {
|
||||
let bad_view = json!({"command": "view.saved.new", "params": {"center": [0, 0], "zoom": 0}});
|
||||
let commands = json!([{"command": "object.unlockAll"}, {"command": "select.all"}, bad_view]);
|
||||
let own = "invalid parameters for `view.saved.new`: `zoom` must be a number > 0, not 0";
|
||||
let e = crate::cmd::params::check_params("action.batch", &json!({"commands": commands})).unwrap_err().to_string();
|
||||
assert_eq!(e, format!("invalid parameters for `action.batch`: action step 3 (`view.saved.new`) failed: {own}"));
|
||||
let e = crate::cmd::params::check_params("command.batch", &json!({"commands": commands})).unwrap_err().to_string();
|
||||
assert_eq!(e, own);
|
||||
}
|
||||
|
||||
/// The ids of the File menu's Open… and Save in the app (`file.open`, `file.save`) and
|
||||
/// `document.close` are not engine commands, so a step with one is refused before the batch
|
||||
/// starts, with Override Open and Override Save on or off.
|
||||
#[test]
|
||||
fn steps_with_ids_that_are_not_engine_commands_are_refused() {
|
||||
let src = tmp("step-number-aliases-src");
|
||||
write_svg(&src, "a.svg", "#f00");
|
||||
for id in ["file.open", "file.save", "document.close"] {
|
||||
for overrides in [true, false] {
|
||||
let mut s = Session::new();
|
||||
let p = json!({
|
||||
"folder": src.to_string_lossy(),
|
||||
"overrideOpen": overrides,
|
||||
"overrideSave": overrides,
|
||||
"commands": [{"command": "object.unlockAll"}, {"command": id, "params": {}}],
|
||||
});
|
||||
let e = s.execute("action.batch", &p).unwrap_err().to_string();
|
||||
assert!(
|
||||
e.starts_with(&format!("invalid parameters for `action.batch`: action step 2 (`{id}`) failed: unknown command `{id}`")),
|
||||
"{e}"
|
||||
);
|
||||
assert!(s.active().is_none(), "{id}: a file was opened");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `command.batch` keeps its own numbering, from 0, for a step that fails.
|
||||
#[test]
|
||||
fn command_batch_keeps_its_own_step_numbers() {
|
||||
let mut s = Session::new();
|
||||
s.execute("file.new", &json!({})).unwrap();
|
||||
let e = s
|
||||
.execute("command.batch", &json!({"commands": [{"command": "object.unlockAll"}, {"command": "object.align", "params": {}}]}))
|
||||
.unwrap_err();
|
||||
assert!(e.to_string().starts_with("batch step 1 (`object.align`) failed: "), "{e}");
|
||||
}
|
||||
|
||||
/// A step's id in the error is cut short, as an unknown key's is.
|
||||
#[test]
|
||||
fn a_long_step_id_is_cut_short() {
|
||||
let id = "x".repeat(10_000);
|
||||
let shown = action_step(0, &id, "why");
|
||||
assert!(shown.len() < 1_000, "{}", shown.len());
|
||||
assert!(shown.starts_with("action step 1 (`xxx") && shown.ends_with("…`) failed: why"), "{shown}");
|
||||
assert_eq!(action_step(usize::MAX, "", "why"), format!("action step {} failed: why", usize::MAX));
|
||||
}
|
||||
|
||||
/// Only the error `command.batch` gives for a failed step is read as one.
|
||||
#[test]
|
||||
fn batch_step_failure_reads_only_a_step_error() {
|
||||
|
||||
@@ -117,7 +117,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Batch…",
|
||||
[],
|
||||
None,
|
||||
"{commands: [{command, params}] (the action's steps), source?: folder (default) | datasets, folder? (required for folder: the source folder), includeSubdirs?: false, destination?: none (default: leave each file open) | saveAndClose (save over the source and close; for source datasets, save the open document over its own file after each data set, and refuse a document that was never saved, was converted from an older version or was restored by Data Recovery, unless a recorded Save or Save As step writes a file first; a Save or Save As step that overrideSave points into destinationFolder makes each data set's file the document's own) | folder (save or export into destinationFolder and close), destinationFolder? (required when destination is folder; also the folder Override Save/Export write into), datasetFileNaming?: fileNumber | fileDataSetName (default) | dataSetName (used only for source datasets; ignored for folder), overrideOpen?: true (skip document.open / file.open steps: the batch opens each source file), overrideSave?: true (point document.save / file.save / file.saveAs at destinationFolder/{stem}.{ext}), overrideExport?: true (point document.export / document.exportSelection the same way, and give document.exportForScreens / assets.export the folder destinationFolder/{stem}, one for each source file or data set, in which the export names its files as it does outside Batch), stopOnError?: true, label?} play the commands on every readable file in folder (and its subfolders when includeSubdirs; {stem} is the file's name without its extension and without trailing periods and spaces, with `-2`, `-3`… added to a name an earlier file used or whose file or folder has the name of one an earlier file wrote or of another source file or a folder of source files in destinationFolder), or on every data set of the open document. Data set names use the document stem plus a three-digit ordinal, the document stem and an underscore plus the data set name, or the data set name alone. Invalid file name characters become `-` and trailing periods and spaces are dropped; a name already used in the batch or whose output file or folder already exists in a destination folder the batch may read and write gets the next free `-2`, `-3` suffix before the format-derived extension. Caps: 500 files or data sets, 8 folder levels, 256 steps. Batches cannot nest, and a prefs.import step is refused (commands[i], from 0) before any file is opened. A switch (includeSubdirs, overrideOpen, overrideSave, overrideExport, stopOnError) that is not true or false, or a source, folder, destination, destinationFolder, datasetFileNaming or label that is not a string, is an error before any folder is made or file opened; null reads as left out. A step that fails is named in the error by its place in commands, from 1, counting the Open steps the batch skips (action step 3 (`object.align`) failed: …); the batch's own opening of a file, choosing of a data set and destination save, export or close give their errors without a step number. → {processed: [{path|dataset, result|error}…], count, failed, stopped, warning?} (warning: for source datasets, when Save and Close without such a step, or a Save, Save a Copy, Save as Template or export step (document.export, exportSelection, exportForScreens, exportPdf, exportEps, exportDxf, exportForWeb, exportForOffice) that writes a file and is not pointed into destinationFolder, saves every data set over the same file)",
|
||||
"{commands: [{command, params}] (the action's steps), source?: folder (default) | datasets, folder? (required for folder: the source folder), includeSubdirs?: false, destination?: none (default: leave each file open) | saveAndClose (save over the source and close; for source datasets, save the open document over its own file after each data set, and refuse a document that was never saved, was converted from an older version or was restored by Data Recovery, unless a recorded Save or Save As step writes a file first; a Save or Save As step that overrideSave points into destinationFolder makes each data set's file the document's own) | folder (save or export into destinationFolder and close), destinationFolder? (required when destination is folder; also the folder Override Save/Export write into), datasetFileNaming?: fileNumber | fileDataSetName (default) | dataSetName (used only for source datasets; ignored for folder), overrideOpen?: true (skip document.open steps: the batch opens each source file), overrideSave?: true (point document.save / file.saveAs at destinationFolder/{stem}.{ext}), overrideExport?: true (point document.export / document.exportSelection the same way, and give document.exportForScreens / assets.export the folder destinationFolder/{stem}, one for each source file or data set, in which the export names its files as it does outside Batch), stopOnError?: true, label?} play the commands on every readable file in folder (and its subfolders when includeSubdirs; {stem} is the file's name without its extension and without trailing periods and spaces, with `-2`, `-3`… added to a name an earlier file used or whose file or folder has the name of one an earlier file wrote or of another source file or a folder of source files in destinationFolder), or on every data set of the open document. Data set names use the document stem plus a three-digit ordinal, the document stem and an underscore plus the data set name, or the data set name alone. Invalid file name characters become `-` and trailing periods and spaces are dropped; a name already used in the batch or whose output file or folder already exists in a destination folder the batch may read and write gets the next free `-2`, `-3` suffix before the format-derived extension. Caps: 500 files or data sets, 8 folder levels, 256 steps. A step without a command, with a command the engine doesn't have, with params its command refuses, or with command.batch, action.batch or prefs.import (batches cannot nest) is refused before any file is opened, named by its place in commands, from 1 (action step 2 (`select.al`) failed: unknown command `select.al`; did you mean `select.all`?). A switch (includeSubdirs, overrideOpen, overrideSave, overrideExport, stopOnError) that is not true or false, or a source, folder, destination, destinationFolder, datasetFileNaming or label that is not a string, is an error before any folder is made or file opened; null reads as left out. A step that fails as it runs is named the same way, counting the Open steps the batch skips (action step 3 (`object.align`) failed: …); the batch's own opening of a file, choosing of a data set and destination save, export or close give their errors without a step number. → {processed: [{path|dataset, result|error}…], count, failed, stopped, warning?} (warning: for source datasets, when Save and Close without such a step, or a Save, Save a Copy, Save as Template or export step (document.export, exportSelection, exportForScreens, exportPdf, exportEps, exportDxf, exportForWeb, exportForOffice) that writes a file and is not pointed into destinationFolder, saves every data set over the same file)",
|
||||
always,
|
||||
action_batch::action_batch
|
||||
),
|
||||
|
||||
@@ -226,9 +226,10 @@ pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>) ->
|
||||
vec![(Some(b), rect(b)?, false)]
|
||||
}
|
||||
};
|
||||
let regions: Vec<(Rect, bool)> = drawings.iter().map(|&(_, region, crop)| (region, crop)).collect();
|
||||
let outs = vectorcraft_cad::export_drawings(doc, &opts, ®ions).map_err(|e| bad(C, e))?;
|
||||
let mut enc = Encoded::default();
|
||||
for (board, region, crop) in drawings {
|
||||
let out = vectorcraft_cad::export(doc, &DxfOptions { region, crop, ..opts.clone() }).map_err(|e| bad(C, e))?;
|
||||
for ((board, _, _), out) in drawings.into_iter().zip(outs) {
|
||||
enc.files.push((board, out.bytes));
|
||||
for w in out.warnings {
|
||||
if !enc.warnings.contains(&w) {
|
||||
|
||||
@@ -1053,12 +1053,14 @@ fn encode_all_of(doc: &Document, format: &str, p: &Value) -> Result<Encoded> {
|
||||
|
||||
/// The file exporter plug-in `plugin` writes of `doc` in its format `f`
|
||||
/// ([`vectorcraft_plugins::export`]). The plug-in is given the native file's JSON
|
||||
/// ([`vectorcraft_format::json_part`]) and `p`'s `params`, for the file `p`'s `path` names (else
|
||||
/// one named after the document) with that path's extension when the plug-in lists it, else its
|
||||
/// first. Its warnings come back with the file, as losses (the plug-in gives them no kind).
|
||||
/// ([`vectorcraft_format::json_part`]), without an Export for Screens folder outside the read roots
|
||||
/// ([`super::access::with_readable_settings_folder`]), and `p`'s `params`, for the file `p`'s `path`
|
||||
/// names (else one named after the document) with that path's extension when the plug-in lists it,
|
||||
/// else its first. Its warnings come back with the file, as losses (the plug-in gives them no kind).
|
||||
fn plugin_file(doc: &Document, plugin: &vectorcraft_plugins::Plugin, f: &Format, p: &Value) -> Result<Encoded> {
|
||||
use vectorcraft_plugins::{Error, export};
|
||||
let doc = &*doc.without_edit_modes();
|
||||
let doc = doc.without_edit_modes();
|
||||
let doc = &*super::access::with_readable_settings_folder(&doc);
|
||||
let file = vectorcraft_format::save_with(doc, &vectorcraft_format::SaveOptions::default()).map_err(|e| EngineError::Other(e.to_string()))?;
|
||||
let path = p.get("path").and_then(Value::as_str);
|
||||
let listed = path.map(super::extension).and_then(|e| f.extensions.iter().copied().find(|x| *x == e));
|
||||
|
||||
@@ -26,13 +26,16 @@ pub(super) fn encode(doc: &Document, p: &Value, use_artboards: Option<bool>, kin
|
||||
Some(true) => pick.resolve(n).map_err(|e| bad(C, e))?.unwrap_or_else(|| (0..n).collect()),
|
||||
_ => vec![pick.one(n).map_err(|e| bad(C, e))?],
|
||||
};
|
||||
let rects = boards
|
||||
.iter()
|
||||
.map(|&b| doc.artboards.get(b).map(|a| a.rect).ok_or_else(|| bad(C, format!("no artboard {}", b + 1))))
|
||||
.collect::<Result<Vec<_>>>()?;
|
||||
// Raster effects (shadows, glows, blurs) as images, as PDF export does.
|
||||
let flat = crate::flatten_raster_effects(doc);
|
||||
let src = flat.as_ref().unwrap_or(doc);
|
||||
let outs = vectorcraft_metafile::export_regions(src, &rects, kind).map_err(|e| bad(C, e))?;
|
||||
let mut enc = Encoded::default();
|
||||
for b in boards {
|
||||
let region = doc.artboards.get(b).ok_or_else(|| bad(C, format!("no artboard {}", b + 1)))?.rect;
|
||||
let out = vectorcraft_metafile::export(src, region, kind).map_err(|e| bad(C, e))?;
|
||||
for (b, out) in boards.into_iter().zip(outs) {
|
||||
enc.files.push((Some(b), out.bytes));
|
||||
for w in out.warnings {
|
||||
if !enc.warnings.contains(&w) {
|
||||
|
||||
@@ -128,7 +128,7 @@ pub fn specs() -> Vec<CommandSpec> {
|
||||
"Export PDF",
|
||||
[],
|
||||
None,
|
||||
"{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), useArtboards?: true (false: one page, the bounds of the visible art the page draws (non-printing layers left out unless includeNonPrinting or createLayers keeps them), as document.export writes it; artboard, artboards and range are then ignored, Preserve Editing is left out (with a warning when it is on), and a document with no visible art is refused), standard?: none|pdfA2b|pdfX1a (CMYK, grey and spot colours only: colours and images converted to output.destination or the CMYK output intent, untagged; transparency flattened with flattenerPreset; PDF 1.3)|pdfX3 (colours ICC-tagged; transparency flattened; PDF 1.3)|pdfX4 (transparency and layers kept; colours ICC-tagged; PDF 1.6 at most) (PDF/X: a /GTS_PDFX output intent, by default the CMYK profile in effect, embedded; TrimBox, Trapped, GTS_PDFXVersion, title and dates; fonts embedded or outlined), compatibility?: 1.3 (no transparency: it is flattened with flattenerPreset, without the layers the file leaves out; images keep no see-through pixels)|1.4|1.5|1.6|1.7 (default)|2.0 (choosing a standard sets its version: 1.7 for pdfA2b, 1.6 for pdfX4, 1.3 for pdfX1a and pdfX3, which write 1.4 as 1.3 too; pdfA2b refuses 1.3; in pdfA2b files, and with longPagesInPoints: false, a page with a side longer than 14,400 pt keeps its size with a UserUnit from 1.6 on: 1.5 is then written as 1.6, with 1.5's encryption, and so is 1.4 in pdfA2b files, with a warning; PDF/X files and other 1.3 and 1.4 files write it in points, and 1.3 and 1.4 (pdfX1a and pdfX3 too) refuse a page past 32,767 pt whose size or art needs a real number past 32,767; a page whose short side is 3 pt or longer but would be under 3 units at that UserUnit gets a smaller one that keeps the short side at 3 units; a warning gives each such page's size), longPagesInPoints?: true (such a page is written at its size in points, without a UserUnit, at every version, and 1.5 stays 1.5, in files without a standard (PDF/A files keep the UserUnit); apps that keep to the limit cut it to 200 in; false: the UserUnit as above, with a warning that names this option), preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, a standard refuses it), thumbnails? (each page drawn as a /Thumb image, 106 px on its long side), fastWebView? (a linearised file: the first page shows while the rest downloads; it stays linearised when encrypted), viewAfterSaving? (the app opens the written file), createLayers? (each layer and sublayer but template layers as a PDF layer, an optional content group listed under its layer's: hidden layers off, non-printing ones /PrintState /OFF, locked ones locked; needs 1.5 or later; they reopen as layers; choosing pdfX1a or pdfX3 turns it off; they refuse it), includeNonPrinting? (keep layers whose Print option is off; left out by default unless createLayers), flattenerPreset?: \"\" (High Resolution) | high | medium | low | a saved preset (flattener.presets.list): what PDF 1.3 files flatten transparency with, flattener?: {object.flattenTransparency options over it}, compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength} (black-and-white images), compressText?: true} (images above abovePpi are resampled to ppi; auto keeps JPEGs JPEG, the others lossless; JPEG needs opaque images; none, jpeg2000, CCITT and runLength are written as ZIP with a warning), marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25 (trim marks and targets), offset: 6 (pt from the artboard, at least the bleed)} (printer's marks in [Registration], every plate: trim marks, registration targets mid-side, CMYK/spot/black-tint colour bars on top, page information (title, artboard, date UTC) below), bleed?: {useDocument (the document's bleed, document.setup), top, bottom, left, right} (pt; art in the bleed is kept; a PDF/X file with no bleed on a side where the document's bleed has one comes back with a warning). Each page: TrimBox = artboard, BleedBox = artboard + bleed, MediaBox = that + the marks' room (art clipped to the BleedBox), output?: {conversion: none (default)|destination (every colour into the destination profile's model, CMYK or RGB, also colours of that model in another profile)|preserveNumbers (only colours of the other model and Lab; those in the destination's model keep their numbers) (grey stays grey; images are converted too, and with destination and an sRGB destination a gray or RGB image tagged with an ICC profile is converted from it and written untagged; with destination and a CMYK destinatio
Line truncated
|
||||
"{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), useArtboards?: true (false: one page, the bounds of the visible art the page draws (non-printing layers left out unless includeNonPrinting or createLayers keeps them), as document.export writes it; artboard, artboards and range are then ignored, Preserve Editing is left out (with a warning when it is on), and a document with no visible art is refused), standard?: none|pdfA2b|pdfX1a (CMYK, grey and spot colours only: colours and images converted to output.destination or the CMYK output intent, untagged; transparency flattened with flattenerPreset; PDF 1.3)|pdfX3 (colours ICC-tagged, CMYK in the output intent's profile as DeviceCMYK; transparency flattened; PDF 1.3)|pdfX4 (transparency and layers kept; colours ICC-tagged, CMYK in the output intent's profile as DeviceCMYK; PDF 1.6 at most) (PDF/X: a /GTS_PDFX output intent, by default the CMYK profile in effect, embedded; TrimBox, Trapped, GTS_PDFXVersion, title and dates; fonts embedded or outlined), compatibility?: 1.3 (no transparency: it is flattened with flattenerPreset, without the layers the file leaves out; images keep no see-through pixels)|1.4|1.5|1.6|1.7 (default)|2.0 (choosing a standard sets its version: 1.7 for pdfA2b, 1.6 for pdfX4, 1.3 for pdfX1a and pdfX3, which write 1.4 as 1.3 too; pdfA2b refuses 1.3; in pdfA2b files, and with longPagesInPoints: false, a page with a side longer than 14,400 pt keeps its size with a UserUnit from 1.6 on: 1.5 is then written as 1.6, with 1.5's encryption, and so is 1.4 in pdfA2b files, with a warning; PDF/X files and other 1.3 and 1.4 files write it in points, and 1.3 and 1.4 (pdfX1a and pdfX3 too) refuse a page past 32,767 pt whose size or art needs a real number past 32,767; a page whose short side is 3 pt or longer but would be under 3 units at that UserUnit gets a smaller one that keeps the short side at 3 units; a warning gives each such page's size), longPagesInPoints?: true (such a page is written at its size in points, without a UserUnit, at every version, and 1.5 stays 1.5, in files without a standard (PDF/A files keep the UserUnit); apps that keep to the limit cut it to 200 in; false: the UserUnit as above, with a warning that names this option), preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, a standard refuses it), thumbnails? (each page drawn as a /Thumb image, 106 px on its long side), fastWebView? (a linearised file: the first page shows while the rest downloads; it stays linearised when encrypted), viewAfterSaving? (the app opens the written file), createLayers? (each layer and sublayer but template layers as a PDF layer, an optional content group listed under its layer's: hidden layers off, non-printing ones /PrintState /OFF, locked ones locked; needs 1.5 or later; they reopen as layers; choosing pdfX1a or pdfX3 turns it off; they refuse it), includeNonPrinting? (keep layers whose Print option is off; left out by default unless createLayers), flattenerPreset?: \"\" (High Resolution) | high | medium | low | a saved preset (flattener.presets.list): what PDF 1.3 files flatten transparency with, flattener?: {object.flattenTransparency options over it}, compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength} (black-and-white images), compressText?: true} (images above abovePpi are resampled to ppi; auto keeps JPEGs JPEG, the others lossless; JPEG needs opaque images; none, jpeg2000, CCITT and runLength are written as ZIP with a warning), marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25 (trim marks and targets), offset: 6 (pt from the artboard, at least the bleed)} (printer's marks in [Registration], every plate: trim marks, registration targets mid-side, CMYK/spot/black-tint colour bars on top, page information (title, artboard, date UTC) below), bleed?: {useDocument (the document's bleed, document.setup), top, bottom, left, right} (pt; art in the bleed is kept; a PDF/X file with no bleed on a side where the document's bleed has one comes back with a warning). Each page: TrimBox = artboard, BleedBox = artboard + bleed, MediaBox = that + the marks' room (art clipped to the BleedBox), output?: {conversion: none (default)|destination (every colour into the destination profile's model, CMYK or RGB, also colours of that model in another profile)|preserveNumbers (only colours of the other model and Lab; those in the destination's model keep their numbers) (grey stays grey; images are converted too, and with destination and an sRGB destination a gray or RGB image tagged
Line truncated
|
||||
has_doc,
|
||||
export_pdf
|
||||
),
|
||||
|
||||
@@ -222,6 +222,13 @@ fn page_options(page: usize, o: &LoadOptions) -> ImportOptions {
|
||||
ImportOptions { pages: Some(vec![page]), crop: o.crop, password: o.password.clone(), text_as: o.text_as, layers: false, ..Default::default() }
|
||||
}
|
||||
|
||||
/// Whether `document.open`'s `linkPages` takes the file `name` holding `bytes`: a PDF or a
|
||||
/// PDF-compatible `.ai` or `.ait` of at most [`document::MAX_FILE`] bytes. Its path, a password
|
||||
/// and `textAs` are checked apart ([`linked_pages`]).
|
||||
pub fn pages_can_link(name: &str, bytes: &[u8]) -> bool {
|
||||
bytes.len() <= document::MAX_FILE && document::is_pdf(name, bytes)
|
||||
}
|
||||
|
||||
/// `document.open` with `linkPages`: the pages `o` picks of the PDF (or PDF-compatible `.ai` or
|
||||
/// `.ait`) `name`, read from `path`, as a document holding one placed document per page, linked to
|
||||
/// that page of the file as File › Place with Link places one ([`document::source`]). Each page
|
||||
|
||||
@@ -116,6 +116,24 @@ fn use_artboards_writes_one_drawing_per_artboard() {
|
||||
assert!(e.contains("useArtboards"), "{e}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn each_artboard_s_drawing_is_the_drawing_of_that_artboard_alone() {
|
||||
let mut s = two_boards();
|
||||
// A second rectangle on the second artboard, so the two drawings differ.
|
||||
let second = s.doc().unwrap().doc.artboards[1].rect.x0;
|
||||
s.execute("shape.rectangle", &json!({"x": second + 50.0, "y": 50, "width": 20, "height": 20})).unwrap();
|
||||
let r = s.execute("document.export", &json!({"format": "dxf", "useArtboards": true, "unit": "pt"})).unwrap();
|
||||
let files = r["files"].as_array().unwrap();
|
||||
let doc = &s.doc().unwrap().doc;
|
||||
let o = dxf::options(&json!({"unit": "pt"})).unwrap();
|
||||
assert_eq!(files.len(), doc.artboards.len());
|
||||
assert_ne!(b64(&files[0]), b64(&files[1]));
|
||||
for (f, board) in files.iter().zip(&doc.artboards) {
|
||||
let alone = vectorcraft_cad::export(doc, &vectorcraft_cad::DxfOptions { region: board.rect, crop: true, ..o.clone() }).unwrap();
|
||||
assert_eq!(b64(f), alone.bytes, "{}", f["name"]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn selected_only_exports_the_selection_in_its_layers() {
|
||||
let mut s = two_boards();
|
||||
|
||||
@@ -410,3 +410,16 @@ fn a_placeholder_only_pdf_part_is_detected() {
|
||||
assert!(open(&mut s, &two, json!({"pages": "1"})).is_err());
|
||||
open(&mut s, &two, json!({})).unwrap();
|
||||
}
|
||||
|
||||
/// `linkPages` takes a PDF up to the largest file placed, and nothing else.
|
||||
#[test]
|
||||
fn pages_can_link_a_pdf_up_to_the_largest_file_placed() {
|
||||
let small = three_pages();
|
||||
assert!(pages_can_link("pages.pdf", &small));
|
||||
assert!(!pages_can_link("pages.svg", b"<svg xmlns=\"http://www.w3.org/2000/svg\"/>"));
|
||||
let mut big = vec![0u8; crate::cmd::place::document::MAX_FILE + 1];
|
||||
big[..small.len()].copy_from_slice(&small);
|
||||
assert!(!pages_can_link("pages.pdf", &big), "over the limit");
|
||||
big.pop();
|
||||
assert!(pages_can_link("pages.pdf", &big), "at the limit");
|
||||
}
|
||||
Loaded 100 of 527 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user