diff --git a/.coderabbit.yaml b/.coderabbit.yaml
new file mode 100644
index 0000000000..2408084cf9
--- /dev/null
+++ b/.coderabbit.yaml
@@ -0,0 +1,6 @@
+# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
+reviews:
+ auto_review:
+ # Dependabot bumps are checked by CI; skip CodeRabbit reviews on them.
+ ignore_usernames:
+ - "dependabot[bot]"
diff --git a/ASSETS.md b/ASSETS.md
index 81b0bd630a..f8121c35bd 100644
--- a/ASSETS.md
+++ b/ASSETS.md
@@ -167,6 +167,7 @@ Generated-in-code art is original and has no file to list. This covers the defau
| `assets/icons/dc-new-fill.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-new-item.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-new-stroke.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
+| `assets/icons/dc-objects-on-path.svg` | VectorCraft contributors | Original work, drawn for VectorCraft: three small squares along a curve | MIT OR Apache-2.0 | |
| `assets/icons/dc-options.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-para-center.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
| `assets/icons/dc-para-justify-all.svg` | VectorCraft contributors | Original work, drawn for VectorCraft | MIT OR Apache-2.0 | |
diff --git a/Cargo.lock b/Cargo.lock
index 431791145f..312d2d5b00 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3852,6 +3852,17 @@ version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+[[package]]
+name = "sctk-adwaita"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6277f0217056f77f1d8f49f2950ac6c278c0d607c45f5ee99328d792ede24ec"
+dependencies = [
+ "log",
+ "smithay-client-toolkit 0.19.2",
+ "tiny-skia",
+]
+
[[package]]
name = "self_cell"
version = "1.3.0"
@@ -4688,7 +4699,7 @@ dependencies = [
[[package]]
name = "vectorcraft"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"arboard",
"block2 0.6.2",
@@ -4725,7 +4736,7 @@ dependencies = [
[[package]]
name = "vectorcraft-affinity"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"crc32fast",
"flate2",
@@ -4736,7 +4747,7 @@ dependencies = [
[[package]]
name = "vectorcraft-brush"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"kurbo 0.13.1",
"serde",
@@ -4748,7 +4759,7 @@ dependencies = [
[[package]]
name = "vectorcraft-cad"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"image",
"kurbo 0.13.1",
@@ -4764,7 +4775,7 @@ dependencies = [
[[package]]
name = "vectorcraft-cli"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"log",
"objc2-core-foundation",
@@ -4786,7 +4797,7 @@ dependencies = [
[[package]]
name = "vectorcraft-color"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"kurbo 0.13.1",
"moxcms",
@@ -4798,7 +4809,7 @@ dependencies = [
[[package]]
name = "vectorcraft-doc"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"hayro-ccitt",
"image",
@@ -4816,7 +4827,7 @@ dependencies = [
[[package]]
name = "vectorcraft-effects"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"image",
"kurbo 0.13.1",
@@ -4832,7 +4843,7 @@ dependencies = [
[[package]]
name = "vectorcraft-engine"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"craft-docpath",
"crc32fast",
@@ -4875,7 +4886,7 @@ dependencies = [
[[package]]
name = "vectorcraft-eps"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"fax",
"flate2",
@@ -4898,7 +4909,7 @@ dependencies = [
[[package]]
name = "vectorcraft-format"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"flate2",
"proptest",
@@ -4913,7 +4924,7 @@ dependencies = [
[[package]]
name = "vectorcraft-geom"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"kurbo 0.13.1",
"proptest",
@@ -4925,7 +4936,7 @@ dependencies = [
[[package]]
name = "vectorcraft-mcp"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"image",
"log",
@@ -4944,7 +4955,7 @@ dependencies = [
[[package]]
name = "vectorcraft-metafile"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"image",
"kurbo 0.13.1",
@@ -4958,7 +4969,7 @@ dependencies = [
[[package]]
name = "vectorcraft-pathops"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"kurbo 0.13.1",
"linesweeper",
@@ -4970,7 +4981,7 @@ dependencies = [
[[package]]
name = "vectorcraft-pdf"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"aes",
"craft-pdf",
@@ -5000,7 +5011,7 @@ dependencies = [
[[package]]
name = "vectorcraft-plugins"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"serde",
"serde_json",
@@ -5014,7 +5025,7 @@ dependencies = [
[[package]]
name = "vectorcraft-render"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"flate2",
"gif",
@@ -5041,14 +5052,14 @@ dependencies = [
[[package]]
name = "vectorcraft-scriptcheck"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"proptest",
]
[[package]]
name = "vectorcraft-svg"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"craft-docpath",
"flate2",
@@ -5073,7 +5084,7 @@ dependencies = [
[[package]]
name = "vectorcraft-testkit"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"fax",
"image",
@@ -5091,7 +5102,7 @@ dependencies = [
[[package]]
name = "vectorcraft-text"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"harfrust 0.13.3",
"icu_segmenter",
@@ -5111,7 +5122,7 @@ dependencies = [
[[package]]
name = "vectorcraft-three-d"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"vectorcraft-geom",
"vectorcraft-pathops",
@@ -5119,7 +5130,7 @@ dependencies = [
[[package]]
name = "vectorcraft-tools"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"image",
"kurbo 0.13.1",
@@ -5135,7 +5146,7 @@ dependencies = [
[[package]]
name = "vectorcraft-trace"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"image",
"kurbo 0.13.1",
@@ -5147,7 +5158,7 @@ dependencies = [
[[package]]
name = "vectorcraft-ui-egui"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"craft-ui",
"egui",
@@ -5181,7 +5192,7 @@ dependencies = [
[[package]]
name = "vectorcraft-web"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"eframe",
"egui",
@@ -6129,6 +6140,7 @@ dependencies = [
"raw-window-handle",
"redox_syscall 0.4.1",
"rustix 0.38.44",
+ "sctk-adwaita",
"smithay-client-toolkit 0.19.2",
"smol_str",
"tracing",
@@ -6292,7 +6304,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
[[package]]
name = "xtask"
-version = "0.13.1"
+version = "0.14.0"
dependencies = [
"serde_json",
]
diff --git a/Cargo.toml b/Cargo.toml
index 496c5de948..b6e948188a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
default-members = ["crates/*", "apps/vectorcraft", "apps/vectorcraft-cli", "xtask"]
[workspace.package]
-version = "0.13.1"
+version = "0.14.0"
edition = "2024"
license = "MIT OR Apache-2.0"
rust-version = "1.95"
diff --git a/NOTICE b/NOTICE
index bcd3055b96..5cf3c8952f 100644
--- a/NOTICE
+++ b/NOTICE
@@ -92,3 +92,34 @@ Assets already bundled through Hayro's default features retain their licences:
non-visual character-mapping data; see licenses/pdf-backend/hayro-cmap/LICENSE.txt.
Adobe and contributor names do not endorse or promote this product.
Per-file hashes and sources are recorded in ASSETS.md.
+
+Linux Wayland window decorations
+-------------------------------
+sctk-adwaita 0.10.1 (https://github.com/PolyMeilex/sctk-adwaita,
+commit d5f343c45c04d4a026db57f76760819b7325db00) is used by winit on Linux
+for vector window controls. Its title-font features are disabled: no Cantarell
+font is embedded by this dependency and no font file is added to this repo.
+
+sctk-adwaita's MIT licence:
+
+MIT License
+
+Copyright (c) 2022 Bartłomiej Maryńczak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
index 68aa538e7d..2dfcd8fb3c 100644
--- a/README.md
+++ b/README.md
@@ -20,11 +20,14 @@
-
-
-
-
-
+
+
+
+
+
+
+
+
@@ -163,6 +166,8 @@ exposes to agents, and exported by VectorCraft's own renderer. The source files
## Quick start
+For posters and sewing patterns, see [Print a large poster across multiple pages](docs/print-tiling.md).
+
```sh
git clone https://github.com/storytold/vectorcraft
cd vectorcraft
@@ -178,6 +183,8 @@ cd apps/vectorcraft-web && trunk build --release # web build → dist
cargo xtask ci # fmt, clippy, tests, layering, wasm, vendor names
```
+For text and custom letter shapes, see [Typography and Custom Lettering](docs/typography-lettering.md).
+
Japanese fonts come from [storytold/craft-fonts](https://github.com/storytold/craft-fonts), an optional
build input (releases always use it): `CRAFT_FONTS_DIR="$PWD/../craft-fonts" cargo run --release -p vectorcraft` (an absolute path).
Without it, Japanese text uses the installed system fonts. See [`docs/development.md`](docs/development.md#fonts-craft-fonts-optional-build-input).
@@ -246,7 +253,7 @@ The scores are self-assessed from our code against public documentation;
- reliable exchange of .ai files (layer structure in real files; proprietary editing data isn't written);
- an interaction-fidelity pass covering every tool's modifiers and small behaviours;
- 3D and Materials beyond the initial live Revolve (Extrude & Bevel, Inflate, Rotate, materials);
-- about half of the raster effects (24 of 57 still missing; Cutout, Film Grain, Neon Glow and Poster Edges are available under Artistic, Halftone Pattern under Sketch) and the Effect Gallery;
+- most of the raster effects (11 of 57 still missing; Cutout, Film Grain, Neon Glow, Plastic Wrap, Poster Edges, Smudge Stick, Sponge and Watercolor are available under Artistic, Bas Relief, Chalk & Charcoal, Charcoal, Chrome, Graphic Pen, Halftone Pattern, Note Paper, Photocopy, Plaster, Reticulation and Stamp under Sketch) and the Effect Gallery;
- CJK composition for vertical type (vertical type itself has initial support, with a Japanese interface);
- scripting, and the rest of Variables (image and graph kinds, dataset import);
- generative AI features.
diff --git a/ROADMAP.md b/ROADMAP.md
index 579a791482..8ae1cf14af 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -9,7 +9,7 @@
**Stage: alpha** · next: beta, ~13 points (ready for real work ~62% → ~75%, and reliable `.ai` exchange) and ~170–270 h away
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-18 · **Change:** minor (Background Export progress dialog with Cancel, #2564; about 85 community PRs of 2026-10-18: Justification…, Word .docx placed as area type, CCITT Group 3 TIFF, Roman Hanging Punctuation, blend spines edited with the Anchor Point tool, shadows and glows in stack order, coloured 3D lights, a Dutch catalog completed; 3D lighting: one to ten colored lights, smooth colored Inflate, legacy white-light appearance preserved; surface batching and restored seam minimum; scores and estimates unchanged; about 145 community PRs of 2026-10-17: image-decode overflow guards, opaque floating panels, MCP export cancel and progress, editable Illustrator EPS import, scoped `doc_inspect`, Dutch, Danish and Indonesian, Simplified Chinese messages, screen-reader names; headline numbers unchanged; about 160 community PRs of 2026-10-15/16: PDF import crash fixes, Dimension tool, legacy `.ai` save, Intertwine, web pen input, Image Trace fixes, `.ai`/EPS/PDF import fidelity, Bulgarian, Greek, Swedish and Finnish catalogs; headline numbers unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-19 · **Change:** minor (about 90 community PRs of 2026-10-19: Objects on Path, the Simplify slider, Pencil Edit Selected Paths in the middle of a path, Georgian, and more; Background Export progress dialog with Cancel, #2564; about 85 community PRs of 2026-10-18: Justification…, Word .docx placed as area type, CCITT Group 3 TIFF, Roman Hanging Punctuation, blend spines edited with the Anchor Point tool, shadows and glows in stack order, coloured 3D lights, a Dutch catalog completed; 3D lighting: one to ten colored lights, smooth colored Inflate, legacy white-light appearance preserved; surface batching and restored seam minimum; scores and estimates unchanged; about 145 community PRs of 2026-10-17: image-decode overflow guards, opaque floating panels, MCP export cancel and progress, editable Illustrator EPS import, scoped `doc_inspect`, Dutch, Danish and Indonesian, Simplified Chinese messages, screen-reader names; headline numbers unchanged; about 160 community PRs of 2026-10-15/16: PDF import crash fixes, Dimension tool, legacy `.ai` save, Intertwine, web pen input, Image Trace fixes, `.ai`/EPS/PDF import fidelity, Bulgarian, Greek, Swedish and Finnish catalogs; headline numbers unchanged) · **Target:** Adobe Illustrator 2026 (30.x)
VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adobe Illustrator workflow. It runs
on macOS, Windows, Linux, FreeBSD and the web (WASM), and agents can drive all of it over MCP, the CLI and a JSON
@@ -29,7 +29,7 @@ blocking it ([Alpha gate](docs/roadmap.md#alpha-gate)).
| | Value | Kind |
|---|---|---|
-| **Feature breadth** (Illustrator's menu items, tools, effects, formats exist) | **~88%** | measured in part: menu items 348/375 wired (92.8%), tools 89/92, Illustrator effects 46/50, Photoshop effects 33/57, 3D 4/4 (initial types, no materials) |
+| **Feature breadth** (Illustrator's menu items, tools, effects, formats exist) | **~88%** | measured in part: menu items 348/375 wired (92.8%), tools 89/92, Illustrator effects 46/50, Photoshop effects 46/57, 3D 4/4 (initial types, no materials) |
| **Feature depth** (weighted by use, scored by behaviour) | **~75%** | estimated |
| **To beta** | **~170–270 h** one agent · ~50–80 h with 4–6 agents | estimated |
| **To full parity** | **~360–590 h** one agent · ~95–165 h with 4–6 agents | estimated |
@@ -76,7 +76,7 @@ The dimension hours overlap (feature rows hold some UI, format and AI work), so
| Strokes, brushes, width profiles | 88% | 8–15 |
| Appearance, transparency, graphic styles, masks | 97% | 1–2 |
| Live vector effects | 85% | 6–10 |
-| Raster effects (Effect Gallery) — [effects-parity.md](docs/effects-parity.md) | 49% | 21–35 |
+| Raster effects (Effect Gallery) — [effects-parity.md](docs/effects-parity.md) | 81% | 8–14 |
| 3D and Materials | ~25% | 30–55 |
| Type core — [type-parity.md](docs/type-parity.md) | 80% | 14–19 |
| Type advanced (CJK, spelling, Touch Type) | 50% | 20–28 |
@@ -123,7 +123,7 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
2. **`.ai` files from real users** (G9): layer structure, guides, speed: 10–20 h.
3. **Launch and stability on real machines** (G10): 20–35 h.
4. **Core-tool correctness** (G11: Shape Builder regions, Asset Export borders): 8–15 h.
-5. **Raster effects** (G2) alongside: 24 filters and the Effect Gallery, 21–35 h.
+5. **Raster effects** (G2) alongside: the 11 remaining filters (7 Artistic, 3 Sketch, 1 more) and the Effect Gallery, 8–14 h.
6. **Then:** type core and advanced type (G4), the Illustrator 2026 additions (G13), 3D (G3).
## Progress log
@@ -134,8 +134,10 @@ Ranked; detail in [docs/roadmap.md](docs/roadmap.md) and [docs/gaps.md](docs/gap
| Date | What landed |
|---|---|
-| 2026-10-18 | Exported and saved files can repeat their bytes: PNG, PDF, EPS, legacy `.ai`, packaged zips and `.vectorcraft` saves recorded the wall-clock time they were made in, so the same commands run twice gave different bytes though the pixels matched. `SOURCE_DATE_EPOCH` now stands in for the clock in everything a file records, as the reproducible-builds specification defines it; a date a command is given still wins, and a malformed value is ignored rather than refusing the export. The recovery heartbeat and the seed PDF encryption draws on keep the real clock (#2880). Headline numbers unchanged. |
+| 2026-10-18 | Inch rulers divide the inch in half, not in ten. Zooming in stepped an inch ruler through 0.2, 0.1 and 0.05 of an inch, marks an inch ruler does not carry; below an inch the steps are binary fractions now, 1/2 down to 1/16, with the unlabelled ticks between them binary too (down to 1/128, so the 32nds, 64ths and 128ths appear as the report expects), while the metric units, points, pixels and picas keep their tenths. A label carries the decimals its step needs, so a sixteenth reads 0.0625 rather than the rounded 0.06, with trailing zeros dropped (#2827). Headline numbers unchanged. |
+| 2026-10-18 | Exported and saved files can repeat their bytes: PNG, PDF, EPS, legacy `.ai`, packaged zips and `.vectorcraft` saves recorded the wall-clock time they were made in, so the same commands run twice gave different bytes though the pixels matched. `SOURCE_DATE_EPOCH` now stands in for the clock in everything a file records, as the reproducible-builds specification defines it; a date a command is given still wins, and a malformed value is ignored rather than refusing the export. The recovery heartbeat and the seed PDF encryption draws on keep the real clock, so a password-protected PDF still differs between runs (#2880). Headline numbers unchanged. |
| 2026-10-18 | About 85 community PRs landed in two batches through the full gate, with our fixes on top. New: Word `.docx` files place as area type with their formatting (#2766), CCITT Group 3 TIFF files open (#2770), Paragraph panel menu › Roman Hanging Punctuation (#2775), the Anchor Point tool edits blend spine points and handles (#2643, fixes #2544), shadows and glows each draw from the art with the effects before them, without the old exponential cost (#2395), one to ten coloured lights in 3D effects (#2706), Artboard Options X and Y with a reference point (#2739), more Contextual Task Bar actions (#2471), Optical Margin Alignment for a whole thread (#2773), History panel Step Backward/Forward and Set History Limit (#2764), Edit › Undo and Redo name the step as the History panel does (#2774), bounding-box handles snap to the grid, pixels and guides (#2715), Ctrl/Cmd+A in the Artboards panel (#2761), Tabs panel menu items (#2742), Import Data Sets defines variables from header cells (#2736), a Linux option to use X11 when a pen is attached (#2717). Fidelity and robustness: variable fonts named by their default weight and fallback glyphs keep bold and italic (#2733, #2732), legacy `.ai` layer names in Windows Latin-1 (#2722), WMF window mapping (#2721), Magic Wand inside isolation (#2720), type values out of range in files are clamped (#2728, #2757), raster effects stay responsive in drags (#2745), exports and Save for Web report undecodable images (#2762, #2737, #2684), Windows-safe exported file names (#2738), a marquee skips a Shaper Group's originals (#2772). Second batch: an export progress dialog with Cancel on the shared cancel token (#2564), CMYK gradient meshes drawn several times faster within a 16 MB cap (#2802), Paragraph panel menu › Justification… with file values clamped (#2771), Edit › Clear History (#2843), SVG image links keep their spelling (#2837, fixes main's Windows test failures), the Linux save dialog through the XDG portal (#2783), RGB input stored as CMYK in CMYK documents (#2812), legacy `.ai` export of images and radial highlights (#2801, #2807), `.ai` import notes for damaged editing data, page sizes and variable libraries (#2799, #2800, #2842), PDF and `.ai` keep their creation date (#2838), undecodable images left out of PDF exports with a note (#2790), MCP input waits for queue room (#2776), slice, snapping, selection, type and accessibility fixes (#2794–#2797, #2805, #2806, #2809, #2815, #2844–#2846), dropdowns close after a keyboard pick (#2824), plug-in dialogs scroll (#2840). Languages: the Dutch catalog completed (#2730). Headline numbers unchanged (estimated). |
+| 2026-10-19 | About 90 community PRs landed in batches through the full gate, with our fixes on top (formatting, catalog rows, small correctness fixes). New: Objects on Path (#3066), Object › Path › Simplify's slider with Auto-Simplify and More Options (#2555), Pencil Edit Selected Paths redraws the middle of a selected path (#2905), Pencil Tool Options' Alt key toggles to Smooth Tool (#2685), 3D solids built from each stroke's outline (#3049), Live Paint Selection Tool Options (#3052), Locate Selected Objects in the Layers panel (#3033), Snap to Unit for tab stops (#3039), DXF circles and arcs as native entities (#2962), Targa files (#2765), a Georgian interface (#2045), Traditional Chinese status and error messages (#2784), the web page's `window.vectorcraft` control channel (#2943), `select.color` (#2939), reproducible export bytes with `SOURCE_DATE_EPOCH` (#2947), Spacing Guides on resizes (#2966) and measurement labels on more tools. Fixed: number fields step to the next whole unit (#2916), a click away from edited type makes no new text (#2922), inch rulers in halves (#2951), Recent cards in New Document (#2904), Japanese W-weights in SVG (#2896), the point-type baseline marker (#2897) and the Reshape tool's falloff (#2900). Headline numbers unchanged. |
| 2026-10-17 | Background Export shows a progress dialog: the file being exported, the artboard count and a bar, Cancel (Esc) and Continue in Background. It runs on the shared cancel token of #2546, so a cancelled export writes no file and keeps no half-drawn pattern tile or effect raster; translated in every language with complete menus (#2564). Headline numbers unchanged. |
| 2026-10-17 | About 145 community PRs landed in six batches, each through the full gate, plus our fixes on top. Crashes and hostile input: an image's RGBA size is checked from its header before decoding, without overflowing, in the renderer, sampling, recoloring and Crop Image (#2442, #2468, #2407), PDF Add Around and huge art are clamped (#2440), graph axis labels past i64, `+` in hex colours and XML ids are handled (#2610, #2470, #2447), Document Raster Effects resolutions open in range (#2579), Batch names stay in their folder (#2504). Regressions: floating panel groups are opaque again while the docked card keeps its rounded corners (#2499), the Wayland pointer returns over panels (#2502). New: MCP cancels long exports, answers while one runs and reports progress (#2546), `doc_inspect` takes ids, kind and paging (#2543), raster export of a page rectangle (#2511), `text.create` returns bounds (#2478), PDF presets and ICC profiles persist (#2547), screen-reader names for widgets (#2611), Expand on Intertwine (#2622, fixes #2540), Duplicate/Copy/Cut of several artboards (#2567), print presets by name (#2607), TSV data sets (#2608), planar TIFF (#2598), Alt-click a swatch onto a gradient stop (#2623), Shift-click ranges in Links, Graphic Styles and Libraries (#2612, #2613, #2618), Space+Shift rotates the view (#2601), Presentation Mode keys (#2583), Small Caps and super/subscript buttons (#2508). Fidelity: editable vector art from Illustrator EPS (#2571), `.ai` Drop Shadow Darkness (#2513), overprint preview with Darken (#2514), Generic CMYK black round-trips (#2503), PNG sRGB chunk (#2519), kerning at a caret (#2518), tab widths in justified area type (#2487), Transform copies keep their own gradients (#2486), smooth Zig Zag (#2475), Live Corners round up to their neighbours (#2484), kerning across style runs (#2554), SVG letter spacing on justified lines (#2574), Dimension tool snapping (#2482), gradient chips (#2495), Transform panel flips and percentages (#2400, #2404). Later the same day: PostScript `.ps` and `.epsf` files open (#2461), EPS images with CCITTFax compression draw (#2445), Illustrator 3 EPS without layers (#2436), `.ai` type opacity and blend modes (#2420), envelope meshes and compound holes in `.ai` (#2410, #2444), CMYK image soft masks in PDF export (#2448), Show Transparency Grid saved with the document (#2488), Save Selection in the Layers panel menu (#2483), Character and Paragraph Reset Panel (#2479, #2438), Cmd/Ctrl+Shift double-click releases a guide (#2467), Shift+Enter keeps a field active (#2431), Shift keeps reshaped handles perpendicular (#2425), emptied type keeps its style (#2464), Smart Blur radius (#2443), freeform gradients recolour (#2397), mesh slivers (#2456), Recolor wheel handles in CMYK (#2454), and six Image Trace fixes (#2387, #2584, #2586–#2589). Fifth batch: Optical Margin Alignment (#2563), Window › Blend panel (#2573), graph column designs (#2406), Live Paint Gap Options (#2424), the SVG Interactivity panel (#2437), RTF placed as area type (#2524), the Touch Type tool (#2469), pattern fills expand into clipped tiles (#2616), Save and Export ask before replacing a file an added extension names (#2619), the Artboard tool's Control bar and Contextual Task Bar (#2559, #2556), Alt-click New Artboard for its options (#2496), Shift-click in Brushes (#2562), the Move dialog remembers the last move (#2542), PDF export uses the document's assigned profiles (#2536), Printer Setup opens the selected printer's preferences on Windows (#2577). Sixth batch: Effect › Artistic › Cutout, Neon Glow and Poster Edges (#2453), View › Rulers › Change to Global / Artboard Rulers (#2416), Symbol Options 9-slice guides (#2512), Create Gradient Mesh on an embedded image (#2538), Rotate View cursors and the Mac trackpad rotation gesture (#2594, #2644), choice parameters as dropdowns in the inline effect editor (#2582), Group Selection picks and moves one path of a compound path (part of #2441), Shift-click ranges in the Artboards panel (#2626), Lock Variables (#2631), a layer dropped under the last row goes to the bottom (#2632), and robustness work: huge selections draw bounded overlays (#2635, #2645, part of #2460), values out of range in presets and files are clamped (#2656), whole-number checks for counts (#2638, #2659), exports warn about overset type (#2628), symbol instances measured by their art (#2614), colour-managed Eyedropper in CMYK documents (#2664). Later: Effect › Rasterize (#2409), variable-font axis sliders in the Character panel (#2710), Image Trace Create Strokes on an exact distance transform with Guo–Hall thinning and a skeleton graph (#2703–#2705), Auto Color keeps rare colours (#2702), large images trace with a warning (#2700), a 1e9 pt input bound on Reshape Segment, Convert Anchor Point and the Pencil (#2709), task-bar Connect, Corner and Smooth for selected anchors (#2697), PDF 0 w strokes import as hairlines (#2696), threading text from the out port (#2713, part of #2572), a panel per swatch library with Persistent (#2714, #2603), installed plug-ins kept across restarts (#2695, #2541). Languages: Dutch, Danish and Indonesian complete (#2393), Simplified Chinese status and error messages (#2578), translated file filters and presets (#2590). Headline numbers unchanged (estimated). |
| 2026-10-16 | Symbol Options › Export Type (Graphic or Movie Clip, default Movie Clip) with Registration; `symbol.options` / `symbol.list` (G5).
diff --git a/apps/vectorcraft/Cargo.toml b/apps/vectorcraft/Cargo.toml
index 28ccdacedf..3459689111 100644
--- a/apps/vectorcraft/Cargo.toml
+++ b/apps/vectorcraft/Cargo.toml
@@ -72,6 +72,9 @@ objc2-core-text = { version = "0.3", default-features = false, features = ["std"
pollster = "1"
[target.'cfg(target_os = "linux")'.dependencies]
+# GNOME/Wayland needs client-side window controls without a bundled title font.
+winit = { version = "0.30", default-features = false, features = ["wayland-csd-adwaita-notitle"] }
+
# Asks the Wayland compositor which GPU it draws with (linux-dmabuf feedback, src/compositor_gpu.rs),
# so Automatic draws on that one. Both are already in the build through winit.
wayland-client = "0.31"
diff --git a/apps/vectorcraft/src/main.rs b/apps/vectorcraft/src/main.rs
index 1724287808..a457d98089 100644
--- a/apps/vectorcraft/src/main.rs
+++ b/apps/vectorcraft/src/main.rs
@@ -1090,4 +1090,116 @@ mod tests {
assert!(types > 1 && plist.matches("LSHandlerRank").count() == types, "every document type has a rank");
assert_eq!(plist.matches("Owner").count(), 2, "only VectorCraft documents and templates are owned");
}
+
+ /// The MIME types a Linux desktop gives each extension in `OPEN_EXTS` but `UNASSOCIATED_EXTS`
+ /// (one row per type): shared-mime-info's, or one that `ai.storyteller.vectorcraft.mime.xml`
+ /// declares.
+ const LINUX_TYPES: &[(&str, &str)] = &[
+ ("vectorcraft", "application/x-vectorcraft"),
+ ("drawcraft", "application/x-vectorcraft"),
+ ("svg", "image/svg+xml"),
+ ("svgz", "image/svg+xml-compressed"),
+ ("pdf", "application/pdf"),
+ ("ai", "application/illustrator"), // brand-ok: shared-mime-info's type
+ ("ait", "application/x-ai-template"),
+ ("png", "image/png"),
+ ("jpg", "image/jpeg"),
+ ("jpeg", "image/jpeg"),
+ ("gif", "image/gif"),
+ ("webp", "image/webp"),
+ ("tif", "image/tiff"),
+ ("tiff", "image/tiff"),
+ ("bmp", "image/bmp"),
+ ("vctemplate", "application/x-vectorcraft-template"),
+ ("dxf", "image/vnd.dxf"),
+ ("emf", "image/emf"),
+ ("wmf", "image/wmf"),
+ ("eps", "image/x-eps"),
+ ("af", "application/x-affinity"),
+ ("afdesign", "application/x-affinity"),
+ ("afpub", "application/x-affinity"),
+ ];
+
+ /// The types in `LINUX_TYPES` that shared-mime-info defines. The MIME package declares every
+ /// other one.
+ const LINUX_SHARED_TYPES: &[&str] = &[
+ "image/svg+xml",
+ "image/svg+xml-compressed",
+ "application/pdf",
+ "application/illustrator", // brand-ok: shared-mime-info's type
+ "image/png",
+ "image/jpeg",
+ "image/gif",
+ "image/webp",
+ "image/tiff",
+ "image/bmp",
+ "image/vnd.dxf",
+ "image/emf",
+ "image/wmf",
+ "image/x-eps",
+ ];
+
+ /// Extensions in `LINUX_TYPES` whose type the MIME package matches by file content and not by a
+ /// glob, with the package's `` rule for that type (its lines joined, indentation removed).
+ const LINUX_BY_CONTENT: &[(&str, &str)] = &[(
+ "af",
+ // `MAGIC` at offset 0 and `DOCUMENT_KIND` at offset 8 (crates/affinity/src/container.rs).
+ r#""#,
+ )];
+
+ /// The desktop entry lists a MIME type for every extension in `OPEN_EXTS` but
+ /// `UNASSOCIATED_EXTS`, and the app's MIME package declares the types shared-mime-info doesn't
+ /// have.
+ #[test]
+ fn the_linux_desktop_entry_opens_every_readable_format() {
+ let desktop = include_str!("../../../packaging/linux/ai.storyteller.vectorcraft.desktop");
+ let mime = include_str!("../../../packaging/linux/ai.storyteller.vectorcraft.mime.xml");
+ let listed: Vec<&str> =
+ desktop.lines().find_map(|l| l.strip_prefix("MimeType=")).unwrap_or_default().split(';').filter(|t| !t.is_empty()).collect();
+ // Each type the MIME package declares, with the extensions of its globs and its ``
+ // rule (empty when it has none) in the form `LINUX_BY_CONTENT` gives.
+ let declared: Vec<(&str, Vec<&str>, String)> = mime
+ .split("").next().unwrap_or_default();
+ let globs = body.split("")) {
+ (Some(start), Some(end)) => body[start..end + "".len()].lines().map(str::trim).collect(),
+ _ => String::new(),
+ };
+ (block.split('"').next().unwrap_or_default(), globs, magic)
+ })
+ .collect();
+ let mut associated: Vec<&str> = fileio::OPEN_EXTS.iter().copied().filter(|e| !fileio::UNASSOCIATED_EXTS.contains(e)).collect();
+ let mut typed: Vec<&str> = LINUX_TYPES.iter().map(|(e, _)| *e).collect();
+ associated.sort_unstable();
+ typed.sort_unstable();
+ typed.dedup();
+ assert_eq!(typed, associated, "a MIME type for each extension the packaging associates with the app");
+ for (e, t) in LINUX_TYPES {
+ assert!(listed.contains(t), "the desktop entry doesn't list {t} (.{e})");
+ let package = declared.iter().find(|(name, ..)| name == t);
+ if LINUX_SHARED_TYPES.contains(t) {
+ assert!(package.is_none(), "{t} is shared-mime-info's, and the MIME package declares it again");
+ continue;
+ }
+ let Some((_, globs, magic)) = package else { panic!("the MIME package doesn't declare {t} (.{e})") };
+ if let Some((_, rule)) = LINUX_BY_CONTENT.iter().find(|(content, _)| content == e) {
+ assert!(!globs.contains(e), "{t} matches .{e} files by content only");
+ assert_eq!(magic, rule, "{t}'s magic rule for .{e} files");
+ } else {
+ assert!(globs.contains(e), "{t} has no *.{e} glob");
+ }
+ }
+ for t in &listed {
+ assert!(LINUX_TYPES.iter().any(|(_, known)| known == t), "the desktop entry lists {t}, which the app doesn't open");
+ }
+ for (t, globs, _) in &declared {
+ assert!(listed.contains(t), "the desktop entry doesn't list the declared {t}");
+ for g in globs {
+ assert!(LINUX_TYPES.contains(&(*g, *t)), "{t}'s *.{g} isn't a file the app opens as {t}");
+ }
+ }
+ }
}
diff --git a/assets/icons/dc-appearance.svg b/assets/icons/dc-appearance.svg
index 12054b4e57..41ba9d7355 100644
--- a/assets/icons/dc-appearance.svg
+++ b/assets/icons/dc-appearance.svg
@@ -1 +1 @@
-
+
diff --git a/assets/icons/dc-objects-on-path.svg b/assets/icons/dc-objects-on-path.svg
new file mode 100644
index 0000000000..6ccf47c322
--- /dev/null
+++ b/assets/icons/dc-objects-on-path.svg
@@ -0,0 +1 @@
+
diff --git a/contributors/people.toml b/contributors/people.toml
index c65a339ce4..62fcd8d180 100644
--- a/contributors/people.toml
+++ b/contributors/people.toml
@@ -127,5 +127,16 @@ sync_github_name = true
[people.dennismutuku2005]
sync_github_name = true
+[people.krinry]
+display_name = "krinry"
+sync_github_name = true
+
[people.makesomethingshit]
sync_github_name = true
+
+[people.MiQ71]
+real_name = "Mirko Kerezovic"
+sync_github_name = false
+
+[people.KaboomFox]
+sync_github_name = true
diff --git a/crates/brush/src/lib.rs b/crates/brush/src/lib.rs
index 91523163e3..a53d205191 100644
--- a/crates/brush/src/lib.rs
+++ b/crates/brush/src/lib.rs
@@ -287,6 +287,8 @@ pub struct ArtBrush {
pub width: f64,
pub flip_along: bool,
pub flip_across: bool,
+ /// When true, art is placed on each run between sharp corners so folds do not overlap.
+ pub overlap: bool,
pub colorization: Colorization,
}
@@ -304,6 +306,7 @@ impl Default for ArtBrush {
width: 100.0,
flip_along: false,
flip_across: false,
+ overlap: false,
colorization: Colorization::Tints,
}
}
diff --git a/crates/brush/src/tests.rs b/crates/brush/src/tests.rs
index 94e9e6014e..3dcdbf9bcd 100644
--- a/crates/brush/src/tests.rs
+++ b/crates/brush/src/tests.rs
@@ -152,6 +152,28 @@ fn art_brush_between_guides_keeps_ends() {
assert!(near(h.x0, 280.0, 1e-6) && near(h.x1, 300.0, 1e-6), "{h:?}");
}
+#[test]
+fn art_brush_overlap_splits_at_corners() {
+ let mut bp = BezPath::new();
+ bp.move_to((0.0, 0.0));
+ bp.line_to((100.0, 0.0));
+ bp.line_to((100.0, 100.0));
+ let brush = |overlap: bool| Brush {
+ name: "a".into(),
+ kind: BrushKind::Art(ArtBrush {
+ art: rect_art(10.0, 4.0),
+ scale: ArtScale::Stretch,
+ overlap,
+ colorization: Colorization::None,
+ ..Default::default()
+ }),
+ };
+ let one = stroke_pieces(&Document::new(1.0, 1.0), &brush(false), &bp, &stroke(1.0));
+ let two = stroke_pieces(&Document::new(1.0, 1.0), &brush(true), &bp, &stroke(1.0));
+ assert_eq!(one.len(), 1, "one bent copy along the whole path");
+ assert_eq!(two.len(), 2, "one copy per run between corners");
+}
+
#[test]
fn art_brush_follows_curves() {
let bp = shapes::ellipse(Rect::new(0.0, 0.0, 200.0, 200.0)).to_bezpath();
diff --git a/crates/brush/src/warp.rs b/crates/brush/src/warp.rs
index 8eef08c04a..35031741e1 100644
--- a/crates/brush/src/warp.rs
+++ b/crates/brush/src/warp.rs
@@ -154,35 +154,65 @@ fn bend(t: &Track, art: &Node, b: Rect, along: AlongMap, cross: f64) -> Option Vec<(f64, f64)> {
+ let l = t.len();
+ let corners = t.corner_positions();
+ if corners.is_empty() {
+ return vec![(0.0, l)];
+ }
+ if t.closed {
+ let first = corners[0].1;
+ let mut bounds = corners.iter().map(|c| c.1).collect::>();
+ bounds.push(first + l);
+ return bounds.windows(2).map(|w| (w[0], w[1])).collect();
+ }
+ let mut bounds = vec![0.0];
+ bounds.extend(corners.iter().map(|c| c.1));
+ bounds.push(l);
+ bounds.windows(2).map(|w| (w[0], w[1])).collect()
+}
+
+fn art_on_run(a: &ArtBrush, t: &Track, s0: f64, s1: f64, art: &Node, b: Rect, cross: f64) -> Option {
+ let l = s1 - s0;
+ if l <= 1e-9 {
+ return None;
+ }
+ let w = b.width();
+ let (along, cross) = match a.scale {
+ ArtScale::Stretch => (AlongMap::linear(w, s0, s1), cross),
+ ArtScale::Proportional => {
+ let k = l / w;
+ (AlongMap::linear(w, s0, s1), k * a.width / 100.0)
+ }
+ ArtScale::BetweenGuides { start, end } => {
+ let (g0, g1) = (start.clamp(0.0, 1.0) * w, end.clamp(0.0, 1.0) * w);
+ let (g0, g1) = (g0.min(g1), g0.max(g1));
+ let fixed = (g0 + (w - g1)) * cross;
+ if fixed >= l || g1 - g0 < 1e-9 {
+ (AlongMap::linear(w, s0, s1), cross)
+ } else {
+ (AlongMap { xs: [0.0, g0, g1, w], ss: [s0, s0 + g0 * cross, s1 - (w - g1) * cross, s1] }, cross)
+ }
+ }
+ };
+ bend(t, art, b, along, cross)
+}
+
pub(crate) fn art(a: &ArtBrush, bp: &BezPath, weight: f64) -> Vec {
let Some((art, b)) = oriented(&a.art, a.direction, a.flip_along, a.flip_across) else { return vec![] };
let cross = weight * a.width / 100.0;
let mut out = vec![];
for t in tracks(bp, 0.05) {
- let l = t.len();
- if l <= 1e-9 {
+ if t.len() <= 1e-9 {
continue;
}
- let w = b.width();
- let (along, cross) = match a.scale {
- ArtScale::Stretch => (AlongMap::linear(w, 0.0, l), cross),
- ArtScale::Proportional => {
- let k = l / w;
- (AlongMap::linear(w, 0.0, l), k * a.width / 100.0)
+ let runs = if a.overlap { art_runs(&t) } else { vec![(0.0, t.len())] };
+ for (s0, s1) in runs {
+ if let Some(n) = art_on_run(a, &t, s0, s1, &art, b, cross) {
+ out.push(n);
}
- ArtScale::BetweenGuides { start, end } => {
- let (g0, g1) = (start.clamp(0.0, 1.0) * w, end.clamp(0.0, 1.0) * w);
- let (g0, g1) = (g0.min(g1), g0.max(g1));
- let fixed = (g0 + (w - g1)) * cross;
- if fixed >= l || g1 - g0 < 1e-9 {
- (AlongMap::linear(w, 0.0, l), cross)
- } else {
- (AlongMap { xs: [0.0, g0, g1, w], ss: [0.0, g0 * cross, l - (w - g1) * cross, l] }, cross)
- }
- }
- };
- if let Some(n) = bend(&t, &art, b, along, cross) {
- out.push(n);
}
}
out
diff --git a/crates/cad/src/scene.rs b/crates/cad/src/scene.rs
index 451173e86e..84e4a3aee3 100644
--- a/crates/cad/src/scene.rs
+++ b/crates/cad/src/scene.rs
@@ -56,6 +56,84 @@ struct Sub {
closed: bool,
}
+/// A subpath close enough to a circle to preserve as a native DXF CIRCLE/ARC. VectorCraft's
+/// ellipse helper uses the standard four-cubic circle approximation, so recognition needs a small
+/// relative tolerance rather than exact control-point tests.
+struct CircularSub {
+ centre: Point,
+ radius: f64,
+ samples: Vec,
+}
+
+fn cubic_point(p0: Point, p1: Point, p2: Point, p3: Point, t: f64) -> Point {
+ let u = 1.0 - t;
+ let a = u * u * u;
+ let b = 3.0 * u * u * t;
+ let c = 3.0 * u * t * t;
+ let d = t * t * t;
+ Point::new(a * p0.x + b * p1.x + c * p2.x + d * p3.x, a * p0.y + b * p1.y + c * p2.y + d * p3.y)
+}
+
+/// Conservatively fit a curved subpath to one circle. Straight segments are never promoted. The
+/// 5e-4 radial tolerance is just above the maximum radial error of the usual kappa cubic circle
+/// approximation (~2.7e-4 r), while rejecting visibly elliptical or arbitrary cubic curves.
+fn circular_subpath(sub: &Sub) -> Option {
+ if sub.segs.is_empty() || sub.segs.iter().any(|s| matches!(s, Seg::Line(_))) {
+ return None;
+ }
+ let mut samples = vec![sub.start];
+ let mut from = sub.start;
+ for seg in &sub.segs {
+ let Seg::Cubic(a, b, to) = *seg else { return None };
+ for i in 1..=8 {
+ samples.push(cubic_point(from, a, b, to, f64::from(i) / 8.0));
+ }
+ from = to;
+ }
+ if samples.len() < 4 {
+ return None;
+ }
+ let mut anchors = vec![sub.start];
+ anchors.extend(sub.segs.iter().map(|s| s.end()));
+ if sub.closed && anchors.last().is_some_and(|p| p.distance(sub.start) <= 1e-9) {
+ anchors.pop();
+ }
+ let (p0, p1, p2) = if anchors.len() >= 3 {
+ (anchors[0], anchors[anchors.len() / 3], anchors[anchors.len() * 2 / 3])
+ } else {
+ (samples[0], samples[samples.len() / 2], *samples.last()?)
+ };
+ let d = 2.0 * (p0.x * (p1.y - p2.y) + p1.x * (p2.y - p0.y) + p2.x * (p0.y - p1.y));
+ let scale2 = p0.distance(p1).max(p1.distance(p2)).max(p2.distance(p0)).powi(2);
+ if !d.is_finite() || d.abs() <= scale2 * 1e-9 {
+ return None;
+ }
+ let q0 = p0.x * p0.x + p0.y * p0.y;
+ let q1 = p1.x * p1.x + p1.y * p1.y;
+ let q2 = p2.x * p2.x + p2.y * p2.y;
+ let centre = Point::new(
+ (q0 * (p1.y - p2.y) + q1 * (p2.y - p0.y) + q2 * (p0.y - p1.y)) / d,
+ (q0 * (p2.x - p1.x) + q1 * (p0.x - p2.x) + q2 * (p1.x - p0.x)) / d,
+ );
+ let radius = centre.distance(p0);
+ if !centre.x.is_finite() || !centre.y.is_finite() || !radius.is_finite() || radius <= 1e-9 {
+ return None;
+ }
+ let tolerance = (radius * 5e-4).max(1e-6);
+ if samples.iter().any(|p| (centre.distance(*p) - radius).abs() > tolerance) {
+ return None;
+ }
+ Some(CircularSub { centre, radius, samples })
+}
+
+fn angle_deg(p: Point, centre: Point) -> f64 {
+ (p.y - centre.y).atan2(p.x - centre.x).to_degrees().rem_euclid(360.0)
+}
+
+fn on_ccw_arc(start: f64, end: f64, angle: f64) -> bool {
+ (angle - start).rem_euclid(360.0) <= (end - start).rem_euclid(360.0) + 1e-7
+}
+
/// The subpaths of `bp` (quadratics raised to cubics).
fn subpaths(bp: &BezPath) -> Vec {
let mut out = vec![];
@@ -576,6 +654,10 @@ impl<'a> Scene<'a> {
pts.pop();
}
self.polyline(&pts, sub.closed, style, width);
+ } else if (v.handles() || width.is_none()) && self.circular(&sub, style) {
+ // Native circles/arcs are preferred by CAD/CAM software. In R12, however, a
+ // stroked curve must stay on the flattened POLYLINE path so groups 40/41 retain
+ // its width. Non-circular curves continue through the existing fallback.
} else if v.handles() {
self.spline(&sub, style);
} else {
@@ -636,6 +718,73 @@ impl<'a> Scene<'a> {
self.e.entity("SEQEND", end, h, &layer, style, "");
}
+ /// Write a safely recognized circular subpath as a native DXF CIRCLE or ARC. Returns false
+ /// when the curve is not circular enough, leaving the caller to write it as a spline/polyline.
+ fn circular(&mut self, sub: &Sub, style: &EntityStyle) -> bool {
+ let Some(last) = sub.segs.last().map(|s| s.end()) else { return false };
+ let geometrically_closed = last.distance(sub.start) <= 1e-9;
+ // ClosePath can add an implicit straight closing edge. Do not replace that geometry with
+ // a full CIRCLE; likewise, an open curve that returns to its start is not an ARC. Check
+ // before fitting, updating extents or allocating an entity handle.
+ if sub.closed != geometrically_closed {
+ return false;
+ }
+ let Some(circle) = circular_subpath(sub) else { return false };
+ let centre = self.to_dxf * circle.centre;
+ let radius = circle.radius * self.k.abs();
+ if !centre.x.is_finite() || !centre.y.is_finite() || !radius.is_finite() || radius <= 1e-12 {
+ return false;
+ }
+
+ // Count sampled points in the drawing extents. For a full circle include all cardinal
+ // points exactly; for an arc, the dense samples conservatively cover its visible span.
+ if sub.closed {
+ let r = circle.radius;
+ for p in [
+ Point::new(circle.centre.x - r, circle.centre.y),
+ Point::new(circle.centre.x + r, circle.centre.y),
+ Point::new(circle.centre.x, circle.centre.y - r),
+ Point::new(circle.centre.x, circle.centre.y + r),
+ ] {
+ self.pt(p);
+ }
+ } else {
+ for p in &circle.samples {
+ self.pt(*p);
+ }
+ }
+
+ let layer = self.layer.clone();
+ let h = self.handle();
+ if sub.closed {
+ self.e.entity("CIRCLE", h, fixed::MODEL_RECORD, &layer, style, "AcDbCircle");
+ self.e.xyz(10, centre.x, centre.y);
+ self.e.num(40, radius);
+ self.e.normal();
+ return true;
+ }
+
+ let start = self.to_dxf * sub.start;
+ let end = self.to_dxf * last;
+ let middle = self.to_dxf * circle.samples[circle.samples.len() / 2];
+ let mut a0 = angle_deg(start, centre);
+ let mut a1 = angle_deg(end, centre);
+ let am = angle_deg(middle, centre);
+ if !on_ccw_arc(a0, a1, am) {
+ std::mem::swap(&mut a0, &mut a1);
+ }
+ self.e.entity("ARC", h, fixed::MODEL_RECORD, &layer, style, "AcDbCircle");
+ self.e.xyz(10, centre.x, centre.y);
+ self.e.num(40, radius);
+ self.e.normal();
+ if self.o.version.handles() {
+ self.e.raw(100, "AcDbArc");
+ }
+ self.e.num(50, a0);
+ self.e.num(51, a1);
+ true
+ }
+
/// A curved subpath as one cubic B-spline whose clamped knots repeat at every joint, so it
/// passes through every anchor (straight segments become straight cubics).
fn spline(&mut self, sub: &Sub, style: &EntityStyle) {
diff --git a/crates/cad/src/tests.rs b/crates/cad/src/tests.rs
index 37bebbd069..3701d11a9d 100644
--- a/crates/cad/src/tests.rs
+++ b/crates/cad/src/tests.rs
@@ -143,8 +143,8 @@ fn lines_are_lwpolylines_curves_splines_and_fills_hatches() {
let out = export(&d, &opts(&d)).unwrap();
assert_eq!(
kinds(&out),
- ["LWPOLYLINE", "HATCH", "LWPOLYLINE", "SPLINE"],
- "the fill's outline and hatch, then the stroke, then the ellipse's stroke"
+ ["LWPOLYLINE", "HATCH", "LWPOLYLINE", "CIRCLE"],
+ "the fill's outline and hatch, then the stroke, then the circle's stroke"
);
let e = entities(&out);
// The rectangle, y up from the artboard's bottom-left corner: 10..110 × 40..90.
@@ -164,11 +164,9 @@ fn lines_are_lwpolylines_curves_splines_and_fills_hatches() {
assert_eq!((get(&e[0], 370), get(&e[2], 370)), (None, Some("35")));
let hatch = &e[1];
assert_eq!((get(hatch, 2), get(hatch, 70), get(hatch, 91), get(hatch, 93)), (Some("SOLID"), Some("1"), Some("1"), Some("4")));
- // The ellipse: four cubics through clamped knots.
- let spline = &e[3];
- assert_eq!((get(spline, 71), get(spline, 73)), (Some("3"), Some("13")));
- assert_eq!(get(spline, 70), Some("9"), "closed planar spline (#1299): 1 = closed, 8 = planar");
- assert_eq!(all(spline, 40), [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0, 4.0, 4.0, 4.0, 4.0]);
+ // The circular ellipse is preserved as a native circle (#1299).
+ let circle = &e[3];
+ assert_eq!((all(circle, 10), all(circle, 20), all(circle, 40)), (vec![150.0], vec![50.0], vec![30.0]));
// R14 has lightweight polylines but no lineweights: the stroke is a polyline width.
let r14 = export(&d, &DxfOptions { version: DxfVersion::R14, ..opts(&d) }).unwrap();
assert_eq!(get(&entities(&r14)[2], 43), Some("1"));
@@ -177,16 +175,77 @@ fn lines_are_lwpolylines_curves_splines_and_fills_hatches() {
// R13 has splines and hatches, and polylines of vertices.
let r13 = export(&d, &DxfOptions { version: DxfVersion::R13, ..opts(&d) }).unwrap();
let poly = ["POLYLINE", "VERTEX", "VERTEX", "VERTEX", "VERTEX", "SEQEND"];
- assert_eq!(kinds(&r13), [&poly[..], &["HATCH"], &poly, &["SPLINE"]].concat());
- // R12: polylines only; the fill is its outline, the ellipse flattened.
+ assert_eq!(kinds(&r13), [&poly[..], &["HATCH"], &poly, &["CIRCLE"]].concat());
+ // R12: visible stroke widths live on old POLYLINE entities, including curved strokes.
let r12 = export(&d, &DxfOptions { version: DxfVersion::R12, ..opts(&d) }).unwrap();
let k = kinds(&r12);
assert!(k.iter().all(|k| matches!(k.as_str(), "POLYLINE" | "VERTEX" | "SEQEND")), "{k:?}");
assert_eq!(k.iter().filter(|k| *k == "POLYLINE").count(), 3);
- assert!(k.iter().filter(|k| *k == "VERTEX").count() > 20, "the ellipse is flattened");
+ assert_eq!(k.iter().filter(|k| *k == "CIRCLE").count(), 0);
assert!(r12.warnings.iter().any(|w| w.contains("R12 has no fills")), "{:?}", r12.warnings);
}
+#[test]
+fn circles_and_circular_arcs_are_native_dxf_entities() {
+ let d = doc_with(|d| {
+ let circle = shapes::ellipse(Rect::new(20.0, 20.0, 80.0, 80.0));
+ let c = Point::new(120.0, 50.0);
+ let r = 30.0;
+ let k = r * shapes::KAPPA;
+ let mut arc = vectorcraft_geom::BezPath::new();
+ arc.move_to(Point::new(c.x + r, c.y));
+ arc.curve_to(Point::new(c.x + r, c.y - k), Point::new(c.x + k, c.y - r), Point::new(c.x, c.y - r));
+ vec![
+ path(d, circle, Paint::None, Paint::solid(Color::BLACK), 1.0),
+ path(d, PathData::from_bezpath(&arc), Paint::None, Paint::solid(Color::BLACK), 1.0),
+ ]
+ });
+ for version in DxfVersion::ALL.into_iter().filter(|version| *version != DxfVersion::R12) {
+ let out = export(&d, &DxfOptions { version, ..opts(&d) }).unwrap();
+ let e = entities(&out);
+ assert_eq!(e.iter().map(|x| kind(x)).collect::>(), ["CIRCLE", "ARC"], "{version:?}");
+ assert_eq!((all(&e[0], 10), all(&e[0], 20), all(&e[0], 40)), (vec![50.0], vec![50.0], vec![30.0]), "{version:?}");
+ assert_eq!((all(&e[1], 10), all(&e[1], 20), all(&e[1], 40)), (vec![120.0], vec![50.0], vec![30.0]), "{version:?}");
+ assert_eq!((all(&e[1], 50), all(&e[1], 51)), (vec![0.0], vec![90.0]), "{version:?}");
+ }
+
+ // An actual ellipse is not close enough to a circle and remains a spline.
+ let ellipse = doc_with(|d| vec![path(d, shapes::ellipse(Rect::new(20.0, 20.0, 100.0, 60.0)), Paint::None, Paint::solid(Color::BLACK), 1.0)]);
+ assert_eq!(kinds(&export(&ellipse, &opts(&ellipse)).unwrap()), ["SPLINE"]);
+}
+
+#[test]
+fn r12_stroked_circles_keep_polyline_width() {
+ let d = doc_with(|d| vec![path(d, shapes::ellipse(Rect::new(20.0, 20.0, 80.0, 80.0)), Paint::None, Paint::solid(Color::BLACK), 3.0)]);
+ let out = export(&d, &DxfOptions { version: DxfVersion::R12, ..opts(&d) }).unwrap();
+ let e = entities(&out);
+ assert_eq!(kind(&e[0]), "POLYLINE");
+ assert_eq!((get(&e[0], 40), get(&e[0], 41)), (Some("3"), Some("3")));
+ assert!(!e.iter().any(|entity| kind(entity) == "CIRCLE"));
+}
+
+#[test]
+fn closed_circular_arc_with_a_closing_chord_is_not_a_circle() {
+ let d = doc_with(|d| {
+ let c = Point::new(50.0, 50.0);
+ let r = 30.0;
+ let k = r * shapes::KAPPA;
+ let mut arc = vectorcraft_geom::BezPath::new();
+ arc.move_to(Point::new(c.x + r, c.y));
+ arc.curve_to(Point::new(c.x + r, c.y - k), Point::new(c.x + k, c.y - r), Point::new(c.x, c.y - r));
+ arc.curve_to(Point::new(c.x - k, c.y - r), Point::new(c.x - r, c.y - k), Point::new(c.x - r, c.y));
+ arc.curve_to(Point::new(c.x - r, c.y + k), Point::new(c.x - k, c.y + r), Point::new(c.x, c.y + r));
+ arc.close_path();
+ vec![path(d, PathData::from_bezpath(&arc), Paint::None, Paint::solid(Color::BLACK), 1.0)]
+ });
+
+ let modern = export(&d, &opts(&d)).unwrap();
+ assert_eq!(kinds(&modern), ["SPLINE"]);
+ let r12 = export(&d, &DxfOptions { version: DxfVersion::R12, ..opts(&d) }).unwrap();
+ assert!(kinds(&r12).iter().any(|k| k == "POLYLINE"));
+ assert!(!kinds(&r12).iter().any(|k| k == "CIRCLE"));
+}
+
#[test]
fn spline_closed_flags_follow_path_intent_across_versions_without_changing_geometry() {
let cases = [(true, true), (true, false), (false, false), (false, true)];
@@ -353,7 +412,7 @@ fn alter_paths_writes_strokes_as_filled_outlines() {
// Each fill and stroke: its outlines, then its hatch.
let fill = ["LWPOLYLINE", "HATCH"];
let rect_stroke = ["LWPOLYLINE", "LWPOLYLINE", "HATCH"];
- assert_eq!(kinds(&out), [&fill[..], &rect_stroke, &["SPLINE", "SPLINE", "HATCH"]].concat());
+ assert_eq!(kinds(&out), [&fill[..], &rect_stroke, &["CIRCLE", "CIRCLE", "HATCH"]].concat());
// The rectangle's stroke: an outer and an inner boundary.
assert_eq!(get(&entities(&out)[4], 91), Some("2"));
// Preserve Appearance outlines only the strokes a line can't draw.
@@ -362,9 +421,9 @@ fn alter_paths_writes_strokes_as_filled_outlines() {
if let Some(st) = d.node_mut(rect).and_then(|n| n.appearance.stroke_mut()) {
st.align = vectorcraft_doc::StrokeAlign::Outside;
}
- assert_eq!(kinds(&export(&d, &opts(&d)).unwrap()), [&fill[..], &rect_stroke, &["SPLINE"]].concat());
+ assert_eq!(kinds(&export(&d, &opts(&d)).unwrap()), [&fill[..], &rect_stroke, &["CIRCLE"]].concat());
let editable = export(&d, &DxfOptions { preserve: Preserve::Editability, ..opts(&d) }).unwrap();
- assert_eq!(kinds(&editable), ["LWPOLYLINE", "HATCH", "LWPOLYLINE", "SPLINE"]);
+ assert_eq!(kinds(&editable), ["LWPOLYLINE", "HATCH", "LWPOLYLINE", "CIRCLE"]);
assert!(editable.warnings.iter().any(|w| w.contains("stroke alignment")));
}
@@ -451,7 +510,7 @@ fn crop_leaves_out_art_outside_the_region() {
let d = shapes_doc();
// Only the ellipse (120..180) reaches into 115..200.
let o = DxfOptions { region: Rect::new(115.0, 0.0, 200.0, 100.0), crop: true, ..opts(&d) };
- assert_eq!(kinds(&export(&d, &o).unwrap()), ["SPLINE"]);
+ assert_eq!(kinds(&export(&d, &o).unwrap()), ["CIRCLE"]);
assert_eq!(kinds(&export(&d, &DxfOptions { crop: false, ..o }).unwrap()).len(), 4);
}
diff --git a/crates/doc/src/appearance.rs b/crates/doc/src/appearance.rs
index 5b1dd7364d..b336ff1529 100644
--- a/crates/doc/src/appearance.rs
+++ b/crates/doc/src/appearance.rs
@@ -739,9 +739,10 @@ pub struct Appearance {
pub items: Vec,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub effects: Vec,
- /// Groups, layers and type: how many items paint below the object's contents (its members, or
- /// type's characters), the slot of the Appearance panel's Contents (Characters) row. `None`:
- /// every item paints above the contents (see [`Self::contents_at`]).
+ /// Groups, layers, type and images: how many items paint below the object's contents (its
+ /// members, type's characters, or an image's pixels), the slot of the Appearance panel's
+ /// Contents (Characters) row. `None`: every item paints above the contents (see
+ /// [`Self::contents_at`]).
#[serde(default, skip_serializing_if = "Option::is_none")]
pub contents_index: Option,
}
diff --git a/crates/doc/src/hit.rs b/crates/doc/src/hit.rs
index 8e16f1ed05..81d1d12f63 100644
--- a/crates/doc/src/hit.rs
+++ b/crates/doc/src/hit.rs
@@ -1,11 +1,12 @@
//! Hit testing over the document tree.
use std::collections::HashSet;
+use std::sync::OnceLock;
use vectorcraft_geom::hit::{fill_contains, stroke_contains};
-use vectorcraft_geom::{Point, Rect};
+use vectorcraft_geom::{BezPath, FillRule, Point, Rect};
-use crate::{Document, Node, NodeId, NodeKind, SymbolBoxes};
+use crate::{AppearanceItem, Document, Node, NodeId, NodeKind, SymbolBoxes};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum HitKind {
@@ -62,14 +63,37 @@ pub struct HitOptions {
/// (point type's baseline, area type's frame, type on a path's path), not anywhere in its
/// bounds.
pub type_path_only: bool,
+ /// Guide objects (paths made into guides) are not hittable: View › Guides › Lock Guides is
+ /// on or the guides are hidden.
+ pub skip_guides: bool,
}
impl Default for HitOptions {
fn default() -> Self {
- Self { tol: 3.0, outline: false, path_only: false, type_path_only: false, scope: None }
+ Self { tol: 3.0, outline: false, path_only: false, type_path_only: false, skip_guides: false, scope: None }
}
}
+/// 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
+/// above this crate, so the engine registers one with [`set_image_paint`].
+pub type ImagePaint = fn(&Node) -> Vec<(BezPath, FillRule, AppearanceItem)>;
+
+static IMAGE_PAINT: OnceLock = OnceLock::new();
+
+/// Register how the shapes of an image's own fills and strokes are found (the first registration
+/// stays).
+pub fn set_image_paint(f: ImagePaint) {
+ // Already set: the same engine, registered by another session.
+ 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(n: &Node) -> Vec<(BezPath, FillRule, AppearanceItem)> {
+ IMAGE_PAINT.get().map_or_else(Vec::new, |f| f(n))
+}
+
/// Topmost editable object under `p`.
pub fn hit_test(doc: &Document, p: Point, opt: HitOptions) -> Option {
hit_test_skipping(doc, p, opt, &|_| false, true)
@@ -318,6 +342,9 @@ fn may_hit(parent: &Node, i: usize, c: &Node, p: Point, opt: HitOptions, symbols
if !c.visible || editable_only && (c.locked || c.is_template()) {
return false;
}
+ if opt.skip_guides && matches!(c.kind, NodeKind::Path { guide: true, .. }) {
+ return false;
+ }
// (An envelope's content sits where it was, not where the envelope draws it.)
edits_contents(c)
|| c.extras().shaper.is_some() && source_of(c, opt.scope)
@@ -433,12 +460,23 @@ fn hit_leaf(n: &Node, p: Point, opt: HitOptions, symbols: &SymbolBoxes) -> Optio
n.geometric_bounds().filter(|b| b.inflate(opt.tol, opt.tol).contains(p))?;
on_type_path(n, t, p, opt.tol).then_some(HitKind::Outline)
}
- NodeKind::Text(_)
- | NodeKind::Image(_)
- | NodeKind::PlacedDocument(_)
- | NodeKind::SymbolInstance { .. }
- | NodeKind::Blend { .. }
- | NodeKind::Envelope { .. } => n.geometric_bounds_with(symbols).filter(|b| b.inflate(opt.tol, opt.tol).contains(p)).map(|_| HitKind::Bounds),
+ // An image is hit within its frame, and where its own fills and strokes paint
+ // ([`image_paint`]) except in outline mode.
+ NodeKind::Image(_) => {
+ if n.geometric_bounds_with(symbols).is_some_and(|b| b.inflate(opt.tol, opt.tol).contains(p)) {
+ return Some(HitKind::Bounds);
+ }
+ if opt.outline {
+ return None;
+ }
+ image_paint(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),
+ })
+ }
+ NodeKind::Text(_) | NodeKind::PlacedDocument(_) | NodeKind::SymbolInstance { .. } | NodeKind::Blend { .. } | NodeKind::Envelope { .. } => {
+ n.geometric_bounds_with(symbols).filter(|b| b.inflate(opt.tol, opt.tol).contains(p)).map(|_| HitKind::Bounds)
+ }
NodeKind::Repeat(r) => r.expand().iter().find_map(|g| hit_any(g, p, opt, symbols)),
NodeKind::Mesh(m) => {
let bp = m.outline().to_bezpath();
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index 4e72a6cae7..12ecf8570a 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -36,6 +36,7 @@ pub mod marks;
mod mem;
pub mod metadata;
pub mod node;
+pub mod objects_on_path;
pub mod orient;
pub mod overprint;
pub mod pattern;
@@ -215,13 +216,33 @@ impl Unit {
/// The rulers' label step at `zoom` (screen pixels per point), in this unit: the first of
/// 1, 2, 5 × 10ⁿ that puts labels at least 50 pixels apart. Ticks mark every tenth of it.
pub fn ruler_step(self, zoom: f64) -> f64 {
- const STEPS: [f64; 19] =
+ const DECIMAL: [f64; 19] =
[0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 25.0, 50.0, 100.0, 200.0, 500.0, 1000.0, 2000.0, 5000.0, 10000.0];
- STEPS.iter().copied().find(|s| s * self.points() * zoom >= 50.0).unwrap_or(10000.0)
+ // An inch is divided in half, not in ten: a tenth of an inch is not a mark an inch ruler
+ // carries, so below an inch the steps are binary fractions (#2827). Labelling stops at a
+ // sixteenth; zooming in past that leaves the labels where they are and only the ticks
+ // between them grow denser, down to a hundred and twenty-eighth
+ // ([`Self::ruler_minor`]). A label is at most six characters that way ("0.0625"), which
+ // the left ruler has room for when it spells one down the ruler a character at a time.
+ // From an inch up the ladder is the shared one.
+ const BINARY: [f64; 15] = [1.0 / 16.0, 0.125, 0.25, 0.5, 1.0, 2.0, 5.0, 10.0, 25.0, 50.0, 100.0, 200.0, 500.0, 1000.0, 10000.0];
+ let steps: &[f64] = if self.ruler_halves() { &BINARY } else { &DECIMAL };
+ steps.iter().copied().find(|s| s * self.points() * zoom >= 50.0).unwrap_or(10000.0)
+ }
+ /// Does this unit's ruler divide a step in half rather than in ten? Inches do; the metric
+ /// units, points, pixels and picas are read in tenths.
+ fn ruler_halves(self) -> bool {
+ matches!(self, Unit::Inches)
+ }
+ /// The unlabelled ticks between two labels, `step` apart ([`Self::ruler_step`]): an eighth of
+ /// the step on an inch ruler, so every tick is a binary fraction of an inch and they stay about
+ /// as dense as the tenths elsewhere; a tenth of it otherwise.
+ pub fn ruler_minor(self, step: f64) -> f64 {
+ if self.ruler_halves() { step / 8.0 } else { step / 10.0 }
}
/// `v` (points) on the nearest ruler tick at `zoom` ([`Self::ruler_step`]).
pub fn snap_to_ruler_tick(self, v: f64, zoom: f64) -> f64 {
- let tick = self.ruler_step(zoom) / 10.0 * self.points();
+ let tick = self.ruler_minor(self.ruler_step(zoom)) * self.points();
(v / tick).round() * tick
}
pub fn from_pt(self, v: f64) -> f64 {
@@ -1515,6 +1536,7 @@ impl Document {
n += usize::from(*k);
}
sel.guides = sel.guides.iter().filter_map(|i| to.get(*i).copied().flatten()).collect();
+ sel.key_guide = sel.key_guide.and_then(|i| to.get(i).copied().flatten());
let before = self.guides.len();
let mut flags = kept.into_iter();
self.guides.retain(|_| flags.next().unwrap_or(true));
@@ -1560,9 +1582,17 @@ impl Document {
{
dimension.source = None;
}
+ let mut renamed = std::collections::HashMap::new();
if let Some(ch) = n.children_mut() {
let old: Vec> = std::mem::take(ch);
*ch = old.iter().map(|c| Arc::new(self.reid(c))).collect();
+ renamed.extend(old.iter().zip(ch.iter()).map(|(o, c)| (o.id, c.id)));
+ }
+ // An Objects on Path group names its path and its objects by id: the copy names the copies.
+ if let Some(e) = n.extras_if_any()
+ && let Some(on_path) = &mut e.objects_on_path
+ {
+ on_path.rename(&renamed);
}
n
}
@@ -1803,6 +1833,46 @@ mod tests {
use super::*;
use vectorcraft_geom::shapes;
+ /// Zooming in on an inch ruler divided the inch into tenths (#2827). Its steps below an inch
+ /// are binary fractions now, and the minor ticks between them stay binary too; every other
+ /// unit is still read in tenths.
+ #[test]
+ fn an_inch_ruler_steps_in_binary_fractions() {
+ let step = |u: Unit, zoom: f64| u.ruler_step(zoom);
+ // Every inch step at or below an inch is 1/2^k, never a tenth or a fifth.
+ for zoom in [1.0, 2.0, 5.0, 7.5, 10.0, 20.0, 40.0, 100.0, 400.0] {
+ let s = step(Unit::Inches, zoom);
+ if s <= 1.0 {
+ let k = s.recip();
+ assert_eq!(k, k.round(), "{s} at zoom {zoom} is 1/k for a whole k");
+ assert!((k.round() as u64).is_power_of_two(), "{s} at zoom {zoom} is 1/2^k");
+ }
+ // A label step always leaves at least 50 px, which is what the ladder is picked for.
+ assert!(s * Unit::Inches.points() * zoom >= 50.0, "zoom {zoom}");
+ }
+ // The steps the report named: tenths became quarters, eighths and sixteenths.
+ assert_eq!(step(Unit::Inches, 5.0), 0.25);
+ assert_eq!(step(Unit::Inches, 10.0), 0.125);
+ assert_eq!(step(Unit::Inches, 20.0), 0.0625);
+ // An inch and wider is unchanged.
+ assert_eq!(step(Unit::Inches, 1.0), 1.0);
+ // Labelling stops at a sixteenth, as the report says Illustrator's does, so zooming in
+ // further only adds ticks. A label therefore never needs more than the six characters of
+ // "0.0625", which the left ruler has room for when it spells one out a character per line.
+ for zoom in [20.0, 50.0, 100.0, 400.0, 1600.0] {
+ assert_eq!(step(Unit::Inches, zoom), 0.0625, "zoom {zoom}");
+ }
+ // The unlabelled ticks go on down to a hundred and twenty-eighth: the 32nds, 64ths and
+ // 128ths the report expects to appear unlabelled when zoomed in close.
+ assert_eq!(Unit::Inches.ruler_minor(0.0625), 1.0 / 128.0);
+ // The minor ticks: an eighth of the step on an inch ruler, a tenth elsewhere.
+ assert_eq!(Unit::Inches.ruler_minor(0.25), 0.03125);
+ assert_eq!(Unit::Millimeters.ruler_minor(25.0), 2.5);
+ assert_eq!(Unit::Points.ruler_minor(100.0), 10.0);
+ // Other units keep the decimal ladder, so a tenth and a fifth still appear.
+ assert!([0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 25.0].contains(&step(Unit::Millimeters, 5.0)), "{}", step(Unit::Millimeters, 5.0));
+ }
+
fn doc_with_rects() -> (Document, NodeId, NodeId) {
let mut d = Document::new(612.0, 792.0);
let layer = d.layers[0].id;
diff --git a/crates/doc/src/live.rs b/crates/doc/src/live.rs
index fd78867868..9175c88c57 100644
--- a/crates/doc/src/live.rs
+++ b/crates/doc/src/live.rs
@@ -587,12 +587,18 @@ fn even_steps(n: u32) -> Vec {
(0..=n).map(|i| i as f64 / n as f64).collect()
}
+/// The number of points of a `(rows+1)×(cols+1)` grid, `None` past `usize`: counts come from
+/// files, and u32::MAX rows and columns (65,535 on 32-bit targets) would wrap to an empty grid.
+fn grid_len(rows: u32, cols: u32) -> Option {
+ (rows as usize).checked_add(1)?.checked_mul((cols as usize).checked_add(1)?)
+}
+
impl GradientMesh {
pub fn idx(&self, r: usize, c: usize) -> usize {
r * (self.cols as usize + 1) + c
}
pub fn is_valid(&self) -> bool {
- self.rows >= 1 && self.cols >= 1 && self.points.len() == (self.rows as usize + 1) * (self.cols as usize + 1)
+ self.rows >= 1 && self.cols >= 1 && grid_len(self.rows, self.cols) == Some(self.points.len())
}
/// A 1×1 mesh from its four corners (bottom-left, top-left, top-right, bottom-right in u/v
@@ -1026,7 +1032,8 @@ impl GradientMesh {
/// Mesh tool Alt-click: delete the mesh lines through point `index` (interior lines only).
pub fn remove_point_lines(&mut self, index: usize) -> bool {
- if index >= self.points.len() {
+ // A mesh from a file may not have the points its rows and columns need: it is indexed below.
+ if !self.is_valid() || index >= self.points.len() {
return false;
}
let w = self.cols as usize + 1;
@@ -1158,7 +1165,7 @@ fn surface_of<'a>(kind: &'a EnvelopeKind, src: Rect, frame: Affine) -> Box Vec<[Vec2; 4]>
/// the smooth ones, see [`smooth_handles`]) as a gradient mesh with black points: what the
/// canvas draws and the Mesh tool and Direct Selection edit. `None` for a malformed grid.
pub fn envelope_grid(rows: u32, cols: u32, points: &[Point], handles: &[[Vec2; 4]]) -> Option {
- // (Counts come from files: no overflow on 32-bit targets.)
- if rows == 0 || cols == 0 || points.len() as u64 != (u64::from(rows) + 1) * (u64::from(cols) + 1) {
+ if rows == 0 || cols == 0 || grid_len(rows, cols) != Some(points.len()) {
return None;
}
let smooth;
@@ -1829,6 +1835,20 @@ mod tests {
assert!((p.x - 37.0).abs() < 1e-6 && (p.y - 81.0).abs() < 1e-6, "{p:?}");
}
+ /// A file's rows and columns can be anything: a point count too large to compute is no match
+ /// for the points (u32::MAX × u32::MAX wrapped to 0 and passed for a grid without points).
+ #[test]
+ fn a_grid_too_large_to_count_is_malformed() {
+ let m = GradientMesh { rows: u32::MAX, cols: u32::MAX, points: vec![] };
+ assert!(!m.is_valid());
+ assert_eq!((m.lines(), m.outline(), m.quads(8).len()), (PathData::default(), PathData::default(), 0));
+ assert!(envelope_grid(u32::MAX, u32::MAX, &[], &[]).is_none());
+ // A mesh envelope without handles maps through its points: malformed, it leaves art as it is.
+ let kind = EnvelopeKind::Mesh { rows: u32::MAX, cols: u32::MAX, points: vec![], handles: vec![] };
+ let p = Point::new(25.0, 50.0);
+ assert_eq!(envelope_mapper(&kind, Rect::new(0.0, 0.0, 100.0, 100.0))(p), p);
+ }
+
#[test]
fn mesh_insert_and_remove_lines() {
let mut m =
@@ -1854,4 +1874,18 @@ mod tests {
m.points[1].color = Color::rgb(1.0, 0.0, 0.0);
assert!(matches!(m.color_at(0, 0, 0.5, 0.5).0, Color::Rgb { .. }));
}
+
+ /// Alt-clicking a point of a mesh from a file with fewer points than its rows and columns need
+ /// deletes nothing (it indexed past the points, a panic).
+ #[test]
+ fn mesh_lines_of_a_malformed_mesh_stay() {
+ let point = |i: u32| MeshPoint { p: Point::new(f64::from(i), 0.0), color: Color::BLACK, opacity: 1.0, handles: [Vec2::ZERO; 4] };
+ // An interior row's point and an interior column's point, each with 3 of the 6 points.
+ for (rows, cols, index) in [(2, 1, 2), (1, 2, 1)] {
+ let mut m = GradientMesh { rows, cols, points: (0..3).map(point).collect() };
+ let before = m.clone();
+ assert!(!m.remove_point_lines(index), "{rows}×{cols}, point {index}");
+ assert_eq!(m, before);
+ }
+ }
}
diff --git a/crates/doc/src/mem.rs b/crates/doc/src/mem.rs
index 3109fa4cfe..771b0b7fb6 100644
--- a/crates/doc/src/mem.rs
+++ b/crates/doc/src/mem.rs
@@ -253,6 +253,9 @@ fn node_bytes(n: &Node, other: Option<&Node>) -> usize {
b += boxed(&e.dimension) + boxed(&e.live_paint_gaps);
b += e.trace.as_ref().map_or(0, |t| ALLOC + size_of::() + json_bytes(t));
b += e.intertwine.as_deref().map_or(0, |a| ALLOC + size_of::() + path_bytes(a));
+ b += e.objects_on_path.as_deref().map_or(0, |o| {
+ ALLOC + size_of::() + o.members.capacity() * size_of::()
+ });
}
b += match &n.kind {
NodeKind::Path { path, live, .. } => path_bytes(path) + boxed(live),
diff --git a/crates/doc/src/metadata.rs b/crates/doc/src/metadata.rs
index f723b1ccd6..708cb82e8f 100644
--- a/crates/doc/src/metadata.rs
+++ b/crates/doc/src/metadata.rs
@@ -90,7 +90,13 @@ impl DocMetadata {
/// The raw clock stays in [`now_unix`], which is what a heartbeat is judged by and what seeds
/// encryption: neither may be pinned by the environment.
pub fn output_time() -> Option {
- stamp_from_env(|n| std::env::var(n).ok()).or_else(now_unix)
+ pinned_or(|n| std::env::var(n).ok(), now_unix)
+}
+
+/// [`output_time`] with the environment and the clock supplied, so a test can show that the
+/// variable is preferred and that the clock answers whenever it does not.
+fn pinned_or(get: impl Fn(&str) -> Option, clock: impl Fn() -> Option) -> Option {
+ stamp_from_env(get).or_else(clock)
}
/// `SOURCE_DATE_EPOCH` as Unix seconds: the reproducible-builds variable
@@ -184,4 +190,21 @@ mod tests {
assert_eq!(stamp_from_env(|_| Some("1791208980".to_owned())), Some(1_791_208_980));
assert_eq!(stamp_from_env(|n: &str| (n == "TZ").then(|| "1791208980".to_owned())), None);
}
+
+ /// What a file records: the variable when it is usable, the clock whenever it is not. The
+ /// environment and the clock are passed in, so no test changes this process's environment --
+ /// that is `unsafe` under edition 2024 and would reach every other test running beside it.
+ #[test]
+ fn a_pinned_epoch_is_preferred_and_the_clock_answers_otherwise() {
+ let env = |v: Option<&'static str>| move |_: &str| v.map(str::to_owned);
+ let clock = || Some(1_000_000);
+ assert_eq!(pinned_or(env(Some("1791208980")), clock), Some(1_791_208_980), "the variable wins over the clock");
+ assert_eq!(pinned_or(env(Some("0")), clock), Some(0), "including the epoch itself");
+ for ignored in [None, Some(""), Some("-1"), Some("later")] {
+ assert_eq!(pinned_or(env(ignored), clock), Some(1_000_000), "{ignored:?} leaves it to the clock");
+ }
+ // A platform with no clock and no variable has no date to record.
+ assert_eq!(pinned_or(env(None), || None), None);
+ assert_eq!(pinned_or(env(Some("1791208980")), || None), Some(1_791_208_980), "the variable needs no clock");
+ }
}
diff --git a/crates/doc/src/node.rs b/crates/doc/src/node.rs
index 25acfd0887..1bfabf9c19 100644
--- a/crates/doc/src/node.rs
+++ b/crates/doc/src/node.rs
@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
use vectorcraft_color::{BlendMode, Color, Paint};
use vectorcraft_geom::corners::cut_corners;
use vectorcraft_geom::shapes::{self, CornerKind};
-use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect};
+use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect, Shape};
use crate::appearance::Appearance;
use crate::live::{BlendSpec, EnvelopeKind, GradientMesh, Outliner};
@@ -102,6 +102,8 @@ pub enum LiveShape {
},
Polygon {
radius: f64,
+ /// 3–1000, as [`LiveShape::set_sides`] gives it; a file's count is clamped when read.
+ #[serde(deserialize_with = "de_sides")]
sides: u32,
xf: Affine,
/// Corner radii in document units, by vertex from the first one clockwise (none: sharp).
@@ -326,6 +328,12 @@ fn all_round(kinds: &[CornerKind]) -> bool {
kinds.iter().all(|k| *k == CornerKind::Round)
}
+/// A polygon's side count read from a file, clamped as the commands clamp it: the outline and its
+/// corner lists hold one entry per side, so a huge count would allocate gigabytes.
+fn de_sides<'de, D: serde::Deserializer<'de>>(d: D) -> Result {
+ u32::deserialize(d).map(|n| n.clamp(3, 1000))
+}
+
/// Whether `a` only moves (no rotation, scale, shear or reflection).
fn moves_only(a: Affine) -> bool {
let [a0, a1, a2, a3, _, _] = a.as_coeffs();
@@ -572,6 +580,9 @@ pub struct NodeExtras {
pub intertwine: Option>,
/// Live Paint group: its Gap Options (Object › Live Paint › Gap Options; `None`: the defaults).
pub live_paint_gaps: Option>,
+ /// Object › Objects on Path: the group's path and the objects attached to it (see
+ /// [`crate::objects_on_path`]).
+ pub objects_on_path: Option>,
}
/// No extras: what [`Node::extras`] gives for a node without any.
@@ -590,6 +601,7 @@ static NO_EXTRAS: NodeExtras = NodeExtras {
dimension: None,
intertwine: None,
live_paint_gaps: None,
+ objects_on_path: None,
};
/// A node's [`NodeExtras`], if it has any ([`Node::extras`]). Extras that are all unset equal
@@ -724,6 +736,7 @@ impl Serialize for Node {
e.dimension.is_none(),
e.intertwine.is_none(),
e.live_paint_gaps.is_none(),
+ e.objects_on_path.is_none(),
];
let mut st = s.serialize_struct("Node", skips.iter().filter(|s| !**s).count())?;
let mut skip = skips.into_iter();
@@ -762,6 +775,7 @@ impl Serialize for Node {
field!("dimension", &e.dimension);
field!("intertwine", &e.intertwine);
field!("live_paint_gaps", &e.live_paint_gaps);
+ field!("objects_on_path", &e.objects_on_path);
st.end()
}
}
@@ -821,6 +835,8 @@ struct NodeWire {
intertwine: Option>,
#[serde(default)]
live_paint_gaps: Option>,
+ #[serde(default)]
+ objects_on_path: Option>,
}
impl From for Node {
@@ -840,6 +856,7 @@ impl From for Node {
dimension: w.dimension,
intertwine: w.intertwine,
live_paint_gaps: w.live_paint_gaps,
+ objects_on_path: w.objects_on_path,
};
Node {
id: w.id,
@@ -1025,6 +1042,7 @@ impl Node {
match &self.kind {
NodeKind::Layer { .. } => "Layer",
NodeKind::Group { clip: true, .. } => "Clip Group",
+ NodeKind::Group { .. } if self.extras().objects_on_path.is_some() => "Objects on Path",
NodeKind::Group { .. } => "Group",
NodeKind::Path { live: Some(l), .. } => l.label(),
NodeKind::Path { guide: true, .. } => "Guide",
@@ -1087,8 +1105,10 @@ impl Node {
}
/// A quick box round everything the object can paint, for culling clicks: paths and compound
/// paths grow their geometric bounds by the farthest their strokes can reach from any path
- /// ([`Appearance::outset`]) instead of measuring along their shape. Symbol instances are
- /// measured as in [`Node::visual_bounds`].
+ /// ([`Appearance::outset`]) instead of measuring along their shape. 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`].
pub fn reach_bounds(&self) -> Option {
self.reach(None)
}
@@ -1106,6 +1126,22 @@ impl Node {
let o = self.appearance.outset();
self.geometric(symbols).map(|b| b.inflate(o, o))
}
+ // The members' reach, grown by the container's own strokes.
+ NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => {
+ let o = self.appearance.outset();
+ children
+ .iter()
+ .skip(usize::from(self.extras().shaper.is_some()))
+ .fold(None, |acc, c| vectorcraft_geom::union_opt(acc, c.reach(symbols)))
+ .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(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)))
+ }),
_ => self.visual(symbols),
}
}
@@ -1155,9 +1191,9 @@ impl Node {
}
}
/// Visual bounds: what the object paints, its strokes included (paths and compound paths
- /// measure theirs along their own shape, see [`Appearance::stroked_bounds`]). A symbol
- /// instance is measured as in [`Node::geometric_bounds`], grown by its own strokes' reach
- /// ([`Node::visual_bounds_with`] measures its art).
+ /// measure theirs along their own shape, see [`Appearance::stroked_bounds`]). An image is
+ /// measured by its frame. A symbol instance is measured as in [`Node::geometric_bounds`],
+ /// grown by its own strokes' reach ([`Node::visual_bounds_with`] measures its art).
pub fn visual_bounds(&self) -> Option {
self.visual(None)
}
@@ -1232,6 +1268,8 @@ impl Node {
let o = self.appearance.outset().max(chars);
self.geometric(symbols).map(|b| b.inflate(o, o))
}
+ // An image is measured by its frame, without its own fills and strokes.
+ NodeKind::Image(_) => self.geometric(symbols),
_ => {
let o = self.appearance.outset();
self.geometric(symbols).map(|b| b.inflate(o, o))
@@ -1251,6 +1289,12 @@ impl Node {
{
dimension.transform(a);
}
+ // The frames of the objects attached to a path move with them.
+ if let Some(e) = self.extras_if_any()
+ && let Some(on_path) = &mut e.objects_on_path
+ {
+ on_path.transform(a);
+ }
if !self.is_layer() {
self.bbox_angle = crate::orient::transformed_angle(self.bbox_angle, a);
}
@@ -1683,11 +1727,11 @@ impl Node {
impl Node {
/// The Appearance panel's row for what this object's own fills and strokes paint around:
- /// "Contents" for a group or layer (its members), "Characters" for type; `None` for objects
- /// whose fills and strokes paint their own geometry.
+ /// "Contents" for a group or layer (its members) and for an image (its pixels), "Characters"
+ /// for type; `None` for objects whose fills and strokes paint their own geometry.
pub fn contents_label(&self) -> Option<&'static str> {
match self.kind {
- NodeKind::Group { .. } | NodeKind::Layer { .. } => Some("Contents"),
+ NodeKind::Group { .. } | NodeKind::Layer { .. } | NodeKind::Image(_) => Some("Contents"),
NodeKind::Text(_) => Some("Characters"),
_ => None,
}
@@ -2154,6 +2198,24 @@ mod tests {
assert_eq!(path.label(), "Path");
}
+ /// A polygon read from a file has 3 to 1000 sides, as the commands give it: selecting one
+ /// with four billion made its outline and corner lists allocate tens of gigabytes.
+ #[test]
+ fn a_polygon_from_a_file_has_3_to_1000_sides() {
+ let read = |sides: u32| {
+ let json = serde_json::json!({"shape": "polygon", "radius": 10.0, "sides": sides, "xf": [1, 0, 0, 1, 0, 0]});
+ serde_json::from_value::(json).unwrap()
+ };
+ let sides_of = |l: &LiveShape| match l {
+ LiveShape::Polygon { sides, .. } => *sides,
+ _ => panic!("not a polygon: {l:?}"),
+ };
+ let huge = read(4_000_000_000);
+ assert_eq!([0, 5, 1000].map(|n| sides_of(&read(n))), [3, 5, 1000]);
+ assert_eq!(sides_of(&huge), 1000);
+ assert_eq!(huge.polygon_outline().anchor_count(), 1000);
+ }
+
#[test]
fn a_polygon_reports_and_takes_its_radius_angle_and_equal_sides() {
let close = |a: f64, b: f64| (a - b).abs() < 1e-9;
diff --git a/crates/doc/src/objects_on_path.rs b/crates/doc/src/objects_on_path.rs
new file mode 100644
index 0000000000..372fae87aa
--- /dev/null
+++ b/crates/doc/src/objects_on_path.rs
@@ -0,0 +1,335 @@
+//! Object › Objects on Path: objects attached to a path and spread along it.
+//!
+//! An Objects on Path group is an ordinary group ([`NodeKind::Group`]) with an [`ObjectsOnPath`]
+//! record in its extras ([`crate::node::NodeExtras::objects_on_path`]). One child is the path, and
+//! the other children are the attached objects, kept where they are drawn: the group draws, hits,
+//! saves and exports as a group. The record lists the objects in their order along the path, each
+//! with the frame it is drawn in and the angle that frame is turned by. [`place`] spreads them
+//! evenly along the path from its first anchor (the first object sits on that anchor, and the last
+//! one sits on the end of an open path), puts the attachment point of each one
+//! ([`ObjectsOnPath::pivot`]) on the path, and turns its frame to the path's direction there,
+//! tilted by [`ObjectsOnPath::rotate`].
+//!
+//! Behavior: .
+
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
+use serde::{Deserialize, Serialize};
+use vectorcraft_geom::{Affine, PathData, Point};
+
+use crate::blend::Spine;
+use crate::symbols::SymbolBoxes;
+use crate::{Node, NodeId, NodeKind};
+
+/// The center of the nine reference points.
+pub const CENTER: u8 = 4;
+
+fn center() -> u8 {
+ CENTER
+}
+
+/// What makes a group an Objects on Path group (see the module docs).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ObjectsOnPath {
+ /// The child of the group that is the path.
+ pub path: NodeId,
+ /// The attached objects, in their order along the path.
+ #[serde(default)]
+ pub members: Vec,
+ /// Pivot: the reference point of each object that attaches to the path, 0 to 8, row by row
+ /// from the top left of the object's bounds in its frame (4: the center).
+ #[serde(default = "center")]
+ pub pivot: u8,
+ /// Rotate: the counter-clockwise degrees each object is turned from upright on the path. An
+ /// upright object has its frame's x axis along the path's direction at its attachment point.
+ #[serde(default, skip_serializing_if = "crate::skip::is_default")]
+ pub rotate: f64,
+}
+
+/// An object attached to the path of an Objects on Path group.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(from = "MemberWire")]
+pub struct Member {
+ pub id: NodeId,
+ /// The object's frame, mapped to the document: the object's art is drawn in this frame.
+ pub frame: Affine,
+ /// The angle the frame is turned by (radians, the document's axes): the path's direction at
+ /// the object's attachment point plus the tilt from Rotate when it was placed, or the angle of
+ /// the frame's x axis before then.
+ pub angle: f64,
+}
+
+/// A [`Member`] as read from a file: without `angle`, the angle of the frame's x axis.
+#[derive(Deserialize)]
+struct MemberWire {
+ id: NodeId,
+ frame: Affine,
+ #[serde(default)]
+ angle: Option,
+}
+
+impl From for Member {
+ fn from(w: MemberWire) -> Self {
+ let angle = w.angle.filter(|a| a.is_finite()).unwrap_or_else(|| x_angle(w.frame));
+ Self { id: w.id, frame: w.frame, angle }
+ }
+}
+
+/// The angle of `frame`'s x axis (radians, the document's axes).
+fn x_angle(frame: Affine) -> f64 {
+ let [a0, a1, ..] = frame.as_coeffs();
+ a1.atan2(a0)
+}
+
+impl Member {
+ /// `n` in its frame as drawn ([`upright_frame`]).
+ pub fn new(n: &Node) -> Self {
+ let frame = upright_frame(n);
+ Self { id: n.id, frame, angle: x_angle(frame) }
+ }
+}
+
+impl ObjectsOnPath {
+ /// A record for the objects `members` (in their order along the path) attached to `path`, each
+ /// in its frame as drawn ([`upright_frame`]).
+ pub fn new(path: NodeId, members: &[&Node], pivot: u8, rotate: f64) -> Self {
+ let members = members.iter().map(|n| Member::new(n)).collect();
+ Self { path, members, pivot: pivot.min(8), rotate: if rotate.is_finite() { rotate } else { 0.0 } }
+ }
+ /// The frames go with the group, and each frame's angle becomes the transformed path's
+ /// direction at the object plus the tilt, so that [`place`] keeps each object's scale, shear
+ /// and reflection when it spreads the objects along the transformed path again. A reflection
+ /// also reverses Rotate: the objects keep the mirrored tilt to the mirrored path.
+ pub fn transform(&mut self, a: Affine) {
+ let before = tilt(self.rotate);
+ if a.determinant() < 0.0 && self.rotate != 0.0 {
+ self.rotate = -self.rotate;
+ }
+ let after = tilt(self.rotate);
+ let [a0, a1, a2, a3, _, _] = a.as_coeffs();
+ for m in &mut self.members {
+ m.frame = a * m.frame;
+ let (sin, cos) = (m.angle - before).sin_cos();
+ let (x, y) = (a0 * cos + a2 * sin, a1 * cos + a3 * sin);
+ if x.is_finite() && y.is_finite() && (x != 0.0 || y != 0.0) {
+ m.angle = y.atan2(x) + after;
+ }
+ }
+ }
+ /// The children given new ids (a copy of the group): the path and the objects by their new ids.
+ pub fn rename(&mut self, ids: &HashMap) {
+ let to = |id: NodeId| ids.get(&id).copied().unwrap_or(id);
+ self.path = to(self.path);
+ for m in &mut self.members {
+ m.id = to(m.id);
+ }
+ }
+ /// The group's children changed from `before` to `after`: a new child at the index of a member
+ /// that is gone replaces it (Break Link to Symbol, for one), keeping its place on the path.
+ pub fn follow_replacements(&mut self, before: &[Arc], after: &[Arc]) {
+ let now: HashSet = after.iter().map(|c| c.id).collect();
+ let then: HashSet = before.iter().map(|c| c.id).collect();
+ let listed: HashSet = self.members.iter().map(|m| m.id).collect();
+ let mut ids = HashMap::new();
+ for (old, new) in before.iter().zip(after) {
+ if listed.contains(&old.id) && !now.contains(&old.id) && !then.contains(&new.id) && new.id != self.path {
+ ids.insert(old.id, new.id);
+ }
+ }
+ if !ids.is_empty() {
+ self.rename(&ids);
+ }
+ }
+}
+
+/// Is `n` an Objects on Path group?
+pub fn is_objects_on_path(n: &Node) -> bool {
+ matches!(n.kind, NodeKind::Group { .. }) && n.extras().objects_on_path.is_some()
+}
+
+/// The path of `n` if it is a path object an Objects on Path group can attach objects to: a path
+/// (not a guide) whose first subpath has some length.
+pub fn attachable_path(n: &Node) -> Option<&PathData> {
+ match &n.kind {
+ NodeKind::Path { path, guide: false, .. } if Spine::new(path).is_some_and(|s| s.length() > 1e-9) => Some(path),
+ _ => None,
+ }
+}
+
+/// The frame `n` is drawn in when it is attached: the page's axes turned by its rotation
+/// ([`Node::bbox_angle`]) less the nearest multiple of 90°, about the center of its bounds. Placed in
+/// that frame, an object stands square to the path or across it.
+pub fn upright_frame(n: &Node) -> Affine {
+ let a = n.bbox_angle;
+ let off = if a.is_finite() { a - (a / 90.0).round() * 90.0 } else { 0.0 };
+ match n.geometric_bounds() {
+ Some(b) if off.abs() > 1e-9 => Affine::rotate_about(-off.to_radians(), b.center()),
+ _ => Affine::IDENTITY,
+ }
+}
+
+/// Where `n` objects attach along `path` (its first subpath): the point and the direction there
+/// (radians, as `atan2` gives in the document's axes). They are spread evenly by length from the
+/// first anchor: on an open path the last one is at its end, on a closed path the gaps go all the way
+/// around. `None` for a path without length.
+pub fn stops(path: &PathData, n: usize) -> Option> {
+ let spine = Spine::new(path)?;
+ let len = spine.length();
+ if !len.is_finite() || len <= 1e-9 {
+ return None;
+ }
+ let closed = path.subpaths.first().is_some_and(|s| s.closed);
+ let gaps = if closed { n } else { n.saturating_sub(1) }.max(1);
+ Some((0..n).map(|i| spine.at_length(len * i as f64 / gaps as f64)).collect())
+}
+
+/// The tilt Rotate gives (radians, the document's axes, where y points down): `rotate` degrees
+/// counter-clockwise on the page.
+fn tilt(rotate: f64) -> f64 {
+ -rotate.to_radians()
+}
+
+/// The frame that puts the attachment point `pivot` of `n` (drawn in `m`'s frame) at `at`, turned
+/// by `angle` (radians, the document's axes) instead of `m`'s angle: the frame's own scale, shear
+/// and reflection are kept. Symbol instances are measured by their art (`symbols`).
+fn placed_frame(n: &Node, symbols: &SymbolBoxes, m: &Member, pivot: u8, at: Point, angle: f64) -> Option {
+ let det = m.frame.determinant();
+ if !det.is_finite() || det.abs() < 1e-12 || !at.x.is_finite() || !at.y.is_finite() || !angle.is_finite() || !m.angle.is_finite() {
+ return None;
+ }
+ let mut local = n.clone();
+ local.transform(m.frame.inverse(), false);
+ let q = vectorcraft_geom::reference_point(local.geometric_bounds_with(symbols)?, usize::from(pivot.min(8)));
+ let [a0, a1, a2, a3, _, _] = m.frame.as_coeffs();
+ let shape = Affine::rotate(-m.angle) * Affine::new([a0, a1, a2, a3, 0.0, 0.0]);
+ Some(Affine::translate(at.to_vec2()) * Affine::rotate(angle) * shape * Affine::translate(-q.to_vec2()))
+}
+
+/// Is `a` the identity, give or take rounding?
+fn negligible(a: Affine) -> bool {
+ let [a0, a1, a2, a3, a4, a5] = a.as_coeffs();
+ (a0 - 1.0).abs() < 1e-9 && a1.abs() < 1e-9 && a2.abs() < 1e-9 && (a3 - 1.0).abs() < 1e-9 && a4.abs() < 1e-6 && a5.abs() < 1e-6
+}
+
+/// Put the objects of Objects on Path group `g` on its path (see the module docs). Before that, the
+/// record lets go of the objects that are no longer in the group, and children it does not list
+/// (other than the path) join it at the end of the path. A group whose path is gone, or is no
+/// longer a path object, becomes a plain group. Symbol instances are measured by their art
+/// (`symbols`, from the document the group is in). Returns whether `g` changed.
+pub fn place(g: &mut Node, symbols: &SymbolBoxes) -> bool {
+ let Some(mut rec) = g.extras().objects_on_path.as_deref().cloned() else { return false };
+ let old = rec.clone();
+ let NodeKind::Group { children, .. } = &mut g.kind else { return false };
+ let path_id = rec.path;
+ let Some(path) = children.iter().find(|c| c.id == path_id).filter(|c| matches!(c.kind, NodeKind::Path { .. })) else {
+ g.extras_mut().objects_on_path = None;
+ return true;
+ };
+ let path = attachable_path(path).cloned();
+ let at: HashMap = children.iter().enumerate().map(|(i, c)| (c.id, i)).collect();
+ rec.members.retain(|m| m.id != path_id && at.contains_key(&m.id));
+ let mut listed: HashSet = rec.members.iter().map(|m| m.id).collect();
+ for c in children.iter() {
+ if c.id != path_id && listed.insert(c.id) {
+ rec.members.push(Member::new(c));
+ }
+ }
+ let mut moved = false;
+ if let Some(stops) = path.and_then(|p| stops(&p, rec.members.len())) {
+ let turn = tilt(rec.rotate);
+ for (m, (p, dir)) in rec.members.iter_mut().zip(stops) {
+ let Some(c) = at.get(&m.id).and_then(|i| children.get_mut(*i)) else { continue };
+ let Some(next) = placed_frame(c, symbols, m, rec.pivot, p, dir + turn) else { continue };
+ let delta = next * m.frame.inverse();
+ if !negligible(delta) {
+ Arc::make_mut(c).transform(delta, false);
+ *m = Member { id: m.id, frame: next, angle: dir + turn };
+ moved = true;
+ }
+ }
+ }
+ if rec != old {
+ g.extras_mut().objects_on_path = Some(Box::new(rec));
+ return true;
+ }
+ moved
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use vectorcraft_geom::{Rect, shapes};
+
+ fn rect(id: u64, r: Rect) -> Node {
+ Node::path(NodeId(id), shapes::rectangle(r), Default::default())
+ }
+
+ #[test]
+ fn stops_spread_from_the_first_anchor() {
+ let open = shapes::line(Point::new(0.0, 0.0), Point::new(300.0, 0.0));
+ let s = stops(&open, 4).unwrap();
+ let xs: Vec = s.iter().map(|(p, _)| p.x.round()).collect();
+ assert_eq!(xs, [0.0, 100.0, 200.0, 300.0], "first at the start, last at the end of an open path");
+ let closed = shapes::rectangle(Rect::new(0.0, 0.0, 100.0, 100.0));
+ let s = stops(&closed, 4).unwrap();
+ let mut pts: Vec<(i64, i64)> = s.iter().map(|(p, _)| (p.x.round() as i64, p.y.round() as i64)).collect();
+ pts.sort();
+ assert_eq!(pts, [(0, 0), (0, 100), (100, 0), (100, 100)], "a closed path spreads them all the way round");
+ assert!(stops(&shapes::line(Point::ZERO, Point::ZERO), 2).is_none());
+ }
+
+ #[test]
+ fn upright_frames_round_the_rotation_to_a_right_angle() {
+ let mut n = rect(1, Rect::new(0.0, 0.0, 10.0, 10.0));
+ assert_eq!(upright_frame(&n), Affine::IDENTITY);
+ n.bbox_angle = 90.0;
+ assert_eq!(upright_frame(&n), Affine::IDENTITY);
+ n.bbox_angle = 30.0;
+ let f = upright_frame(&n);
+ let [a0, a1, ..] = f.as_coeffs();
+ assert!((a1.atan2(a0).to_degrees() + 30.0).abs() < 1e-9, "a frame turned 30° counter-clockwise");
+ }
+
+ #[test]
+ fn a_symbol_instance_is_placed_by_its_art() {
+ // The art is a 40 × 10 box to the right of and below the origin, not the 20 × 20 square
+ // around it that instances are measured by without the symbols.
+ let mut d = crate::Document::new(400.0, 400.0);
+ d.symbols.push(crate::Symbol { name: "Bar".into(), art: Arc::new(rect(9, Rect::new(0.0, 0.0, 40.0, 10.0))) });
+ let line = Node::path(NodeId(1), shapes::line(Point::new(100.0, 300.0), Point::new(300.0, 300.0)), Default::default());
+ let instance = Node::new(NodeId(2), NodeKind::SymbolInstance { symbol: "Bar".into(), xf: Affine::IDENTITY });
+ let other = rect(3, Rect::new(0.0, 0.0, 10.0, 10.0));
+ let members = [&instance, &other];
+ let mut g = Node::new(
+ NodeId(4),
+ NodeKind::Group { children: vec![Arc::new(line), Arc::new(instance.clone()), Arc::new(other.clone())], clip: false },
+ );
+ g.extras_mut().objects_on_path = Some(Box::new(ObjectsOnPath::new(NodeId(1), &members, 7, 0.0)));
+ let symbols = d.symbol_boxes();
+ assert!(place(&mut g, &symbols));
+ let placed = g.children().and_then(|c| c.iter().find(|c| c.id == NodeId(2)).cloned()).unwrap();
+ let b = placed.geometric_bounds_with(&symbols).unwrap();
+ assert!((b.y1 - 300.0).abs() < 1e-9 && (b.center().x - 100.0).abs() < 1e-9, "the art's bottom middle on the start: {b:?}");
+ }
+
+ #[test]
+ fn a_member_saved_without_its_angle_reads_the_angle_of_its_frame() {
+ let m = Member { id: NodeId(2), frame: Affine::rotate(0.5), angle: 0.5 };
+ let mut v = serde_json::to_value(m).unwrap();
+ assert_eq!(serde_json::from_value::(v.clone()).unwrap(), m);
+ v.as_object_mut().unwrap().remove("angle");
+ let back: Member = serde_json::from_value(v).unwrap();
+ assert!((back.angle - 0.5).abs() < 1e-12, "{back:?}");
+ }
+
+ #[test]
+ fn a_group_without_its_path_is_a_plain_group() {
+ let a = rect(2, Rect::new(0.0, 0.0, 10.0, 10.0));
+ let mut g = Node::new(NodeId(3), NodeKind::Group { children: vec![Arc::new(a.clone())], clip: false });
+ g.extras_mut().objects_on_path = Some(Box::new(ObjectsOnPath::new(NodeId(1), &[&a], CENTER, 0.0)));
+ let d = crate::Document::new(100.0, 100.0);
+ assert!(place(&mut g, &d.symbol_boxes()));
+ assert!(!is_objects_on_path(&g));
+ }
+}
diff --git a/crates/doc/src/pattern.rs b/crates/doc/src/pattern.rs
index 6b9d902bab..1b587e70fa 100644
--- a/crates/doc/src/pattern.rs
+++ b/crates/doc/src/pattern.rs
@@ -467,6 +467,14 @@ impl RepeatKind {
RepeatKind::Mirror { .. } => "Mirror Repeat",
}
}
+ /// How many instances [`repeat_transforms`] makes (with its clamps).
+ fn count(&self) -> usize {
+ match self {
+ RepeatKind::Radial { instances, .. } => (*instances).clamp(1, 1000) as usize,
+ RepeatKind::Grid { rows, cols, .. } => (*rows).clamp(1, 500) as usize * (*cols).clamp(1, 500) as usize,
+ RepeatKind::Mirror { .. } => 2,
+ }
+ }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -475,6 +483,23 @@ pub struct RepeatSpec {
pub source: Vec>,
}
+/// Most instances a Repeat makes in all, those of the Repeats nested in its source included: as
+/// many as one 500 × 500 grid, the budget [`PatternDef::offsets_covering`] also keeps.
+const MAX_REPEAT_INSTANCES: usize = 250_000;
+
+/// Instances the Repeats in `nodes` make in all (0 when there are none).
+fn nested_instances(nodes: &[Arc]) -> usize {
+ let mut sum = 0usize;
+ for n in nodes {
+ sum = sum.saturating_add(match (&n.kind, n.children()) {
+ (NodeKind::Repeat(r), _) => r.instances_in_all(),
+ (_, Some(c)) => nested_instances(c),
+ _ => 0,
+ });
+ }
+ sum
+}
+
/// Reflection across the line through `c` with direction angle `deg`.
pub fn reflect_about(c: Point, deg: f64) -> Affine {
let t = (2.0 * deg).to_radians();
@@ -536,7 +561,21 @@ impl RepeatSpec {
crate::live::nodes_bounds(&self.source)
}
pub fn transforms(&self) -> Vec {
- repeat_transforms(&self.kind, self.source_bounds())
+ let mut v = repeat_transforms(&self.kind, self.source_bounds());
+ // Each instance draws the Repeats in the source again, so nested ones multiply (a 500 × 500
+ // grid of one is 62.5 billion instances): keep the first that fit the budget.
+ v.truncate(self.kept(nested_instances(&self.source)));
+ v
+ }
+ /// How many of its instances this Repeat keeps when each makes `nested` instances of the
+ /// Repeats in its source: as many as fit in [`MAX_REPEAT_INSTANCES`], at least one.
+ fn kept(&self, nested: usize) -> usize {
+ self.kind.count().min(MAX_REPEAT_INSTANCES / nested.max(1)).max(1)
+ }
+ /// Instances made in all, those of the Repeats nested in the source included.
+ fn instances_in_all(&self) -> usize {
+ let nested = nested_instances(&self.source);
+ self.kept(nested).saturating_mul(nested.max(1))
}
/// Evaluated instances: one group of the (transformed) source per instance (ids 0).
pub fn expand(&self) -> Vec {
@@ -838,6 +877,35 @@ mod tests {
assert!((angle.rem_euclid(180.0) - 0.0).abs() < 1e-9 || (angle.rem_euclid(180.0) - 180.0).abs() < 1e-9, "{angle}");
}
+ #[test]
+ fn nested_repeats_share_one_instance_budget() {
+ // Instances made in all, counted from the transforms without drawing any.
+ fn made(r: &RepeatSpec) -> usize {
+ let each: usize = r.source.iter().map(|s| if let NodeKind::Repeat(n) = &s.kind { made(n) } else { 1 }).sum();
+ r.transforms().len().saturating_mul(each)
+ }
+ let grid = |source: Arc| {
+ let mut g = RepeatSpec::grid(vec![source], 0.0, 0.0);
+ if let RepeatKind::Grid { rows, cols, .. } = &mut g.kind {
+ *rows = 500;
+ *cols = 500;
+ }
+ g
+ };
+ let repeat = |r: RepeatSpec| Arc::new(Node::new(NodeId(2), NodeKind::Repeat(r)));
+ // One grid keeps all its instances.
+ let inner = grid(sq(0.0, 0.0, 1.0));
+ assert_eq!(made(&inner), 250_000);
+ // A 500 × 500 grid of it made 62.5 billion.
+ let outer = grid(repeat(inner.clone()));
+ assert!(made(&outer) <= 250_000, "{} instances", made(&outer));
+ assert_eq!(outer.expand().len(), outer.transforms().len());
+ assert!(made(&RepeatSpec::mirror(vec![repeat(inner)], 90.0, 5.0)) <= 250_000);
+ // Small nests are left as they are.
+ let small = RepeatSpec::mirror(vec![repeat(RepeatSpec::grid(vec![sq(0.0, 0.0, 10.0)], 1.0, 1.0))], 90.0, 5.0);
+ assert_eq!(made(&small), 18);
+ }
+
#[test]
fn serde_roundtrip() {
let mut def = PatternDef::new("Dots", vec![sq(0.0, 0.0, 10.0)]);
diff --git a/crates/doc/src/selection.rs b/crates/doc/src/selection.rs
index ba8eb4b9f1..1d45f5d738 100644
--- a/crates/doc/src/selection.rs
+++ b/crates/doc/src/selection.rs
@@ -43,6 +43,11 @@ pub struct Selection {
/// guides and objects can be selected together, in either order.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub guides: Vec,
+ /// A selected ruler guide that is the key object for Align instead of [`Self::key`] (an index
+ /// into [`Document::guides`], one of [`Self::guides`]): the objects line up on it. Never set
+ /// with `key`; [`Self::prune`] clears it when no object is selected to align to it.
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub key_guide: Option,
}
impl Selection {
@@ -67,6 +72,11 @@ impl Selection {
self.target = None;
self.slices.clear();
self.guides.clear();
+ self.key_guide = None;
+ }
+ /// Is there a key for Align: an object or a guide?
+ pub fn has_key(&self) -> bool {
+ self.key.is_some() || self.key_guide.is_some()
}
pub fn set(&mut self, ids: impl IntoIterator) {
self.clear();
@@ -114,6 +124,9 @@ impl Selection {
pub fn toggle_guide(&mut self, i: usize) {
if let Some(k) = self.guides.iter().position(|g| *g == i) {
self.guides.remove(k);
+ if self.key_guide == Some(i) {
+ self.key_guide = None;
+ }
} else {
self.guides.push(i);
}
@@ -162,13 +175,16 @@ impl Selection {
refs.retain(|&(si, seg)| path.subpaths.get(si).is_some_and(|sp| seg < sp.segment_count()));
!refs.is_empty() && self.objects.contains(id) && self.anchors.contains_key(id)
});
- // The key object stays while another selected object lies outside it.
+ // Guides on a hidden or locked layer can't stay selected.
+ self.guides.retain(|i| doc.guides.get(*i).is_some_and(|g| doc.guide_editable(g)));
+ // The key object stays while another selected object lies outside it, or while ruler
+ // guides are selected for it to line up (#2143).
let keep = self.key.and_then(|k| found.get(&k)).and_then(|p| doc.node_at(p)).is_some_and(|n| {
let mut inside = BTreeSet::new();
n.walk(&mut |c| {
inside.insert(c.id);
});
- self.objects.iter().any(|o| !inside.contains(o))
+ self.objects.iter().any(|o| !inside.contains(o)) || (self.objects.contains(&n.id) && !self.guides.is_empty())
});
if !keep {
self.key = None;
@@ -177,8 +193,10 @@ impl Selection {
self.target = None;
}
self.slices.retain(|id| doc.is_slice(*id));
- // Guides on a hidden or locked layer can't stay selected.
- self.guides.retain(|i| doc.guides.get(*i).is_some_and(|g| doc.guide_editable(g)));
+ // A key guide needs objects to line up on it, and stays selected.
+ if self.key.is_some() || self.objects.is_empty() || self.key_guide.is_some_and(|k| !self.guides.contains(&k)) {
+ self.key_guide = None;
+ }
}
/// Deselect the objects that are hidden or locked, themselves or through a group or layer
/// around them (and so the key object when it is one): hidden or locked art can't stay
diff --git a/crates/effects/src/bake.rs b/crates/effects/src/bake.rs
index 132e0cba00..2bdd0f2888 100644
--- a/crates/effects/src/bake.rs
+++ b/crates/effects/src/bake.rs
@@ -107,9 +107,10 @@ fn bake_node(d: &mut Document, n: &Node) -> Option {
let m = evaluate_container(&m).unwrap_or(m);
return Some(bake_pieces(d, m));
}
- // Type, images, symbol instances and live objects: reshaped through their outlines, and so is
- // type whose own fills or strokes have geometry effects ([`has_item_geometry`]). Type that
- // Transform effects only move and copy stays type, moved to each place.
+ // Type, images, symbol instances and live objects: reshaped through their outlines, and so are
+ // type whose own fills or strokes have geometry effects and images whose own fills or strokes
+ // paint a shape ([`has_item_geometry`]). Type that Transform effects only move and copy stays
+ // type, moved to each place.
if needs_outline(n) && (has_geometry(&n.appearance.effects) || n.projection().is_some() || has_item_geometry(n)) {
if let Some(m) = moved_type_group(n) {
return Some(bake_pieces(d, m));
diff --git a/crates/effects/src/lib.rs b/crates/effects/src/lib.rs
index 12de8f8610..45b50d5f97 100644
--- a/crates/effects/src/lib.rs
+++ b/crates/effects/src/lib.rs
@@ -56,7 +56,7 @@ mod tests;
mod tests_scale;
use serde_json::{Map, Value, json};
-use vectorcraft_doc::{AppearanceItem, Effect, Node, NodeKind, StrokeLayer};
+use vectorcraft_doc::{Appearance, AppearanceItem, Effect, Node, NodeKind, StrokeLayer};
use vectorcraft_geom::{BezPath, FillRule, PathData, Rect};
pub use adjust::{
@@ -73,7 +73,7 @@ pub use live::{expand_live, expand_live_deep, expanded_live_group, text_outliner
pub use marks::{CROP_MARKS, crop_marks_art, has_crop_marks};
pub use pixel::{PIXEL_EFFECTS, PixelFx, PixelSpace};
pub use raster::{RASTERIZE, RasterFx, Rasterize, outset, raster_effects};
-pub use reshape::{expand_outlined, has_gradient_copies, has_item_geometry, needs_outline, outline_art, outline_text, reshape};
+pub use reshape::{expand_outlined, has_gradient_copies, has_item_geometry, image_paint, needs_outline, outline_art, outline_text, reshape};
pub use revolve::{REVOLVE, has_revolve, revolve_art, revolve_options, validate_revolve};
pub use solids::{
EXTRUDE, INFLATE, ROTATE, ROTATION_PRESETS, SOLIDS, extrude_options, has_solid, inflate_options, is_three_d, solid_art, validate_solid,
@@ -153,7 +153,9 @@ fn lengths_of(id: &str) -> Lengths {
"texture.mosaicTiles" => always(&["tileSize"]),
"texture.patchwork" => always(&["squareSize"]),
"texture.stainedGlass" => always(&["cellSize"]),
+ "sketch.graphicPen" => always(&["strokeLength"]),
"sketch.halftonePattern" => always(&["size"]),
+ "sketch.notePaper" => always(&["relief"]),
RASTERIZE => always(&["addAround"]),
_ => Lengths::default(),
}
@@ -362,6 +364,13 @@ pub fn effect_catalog() -> Vec {
"{glowSize: -24..24 (5; above 0 the light areas glow, below 0 the dark ones; farther from 0 spreads the glow wider), glowBrightness: 0..50 (15; a stronger glow over dimmer greys), color: \"#rrggbb\" (\"#4da6ff\"; the glow's colour)} redraws the object in greys lit by a coloured glow, keeping its coverage. Original visual approximation; chosen VectorCraft defaults.",
json!({"glowSize": 5.0, "glowBrightness": 15.0, "color": "#4da6ff"}),
),
+ r(
+ "artistic.plasticWrap",
+ "Plastic Wrap…",
+ ARTISTIC,
+ "{highlightStrength: 0..20 (20; brighter specular highlights), detail: 0..15 (12; finer wrinkles in document space), smoothness: 1..15 (15; softer folds)} coats the object in shiny plastic, keeping its coverage. highlightStrength 0 leaves the art unchanged. Original visual approximation; chosen VectorCraft defaults.",
+ json!({"highlightStrength": 20.0, "detail": 12.0, "smoothness": 15.0}),
+ ),
r(
"artistic.posterEdges",
"Poster Edges…",
@@ -369,6 +378,27 @@ pub fn effect_catalog() -> Vec {
"{edgeThickness: 0..10 (2; wider lines), edgeIntensity: 0..10 (1; darker lines, on fainter edges too), posterization: 0..6 (2; posterization + 2 levels per colour channel)} reduces the object's colours and draws black lines on its edges, keeping its coverage. Original visual approximation; chosen VectorCraft defaults.",
json!({"edgeThickness": 2.0, "edgeIntensity": 1.0, "posterization": 2.0}),
),
+ r(
+ "artistic.smudgeStick",
+ "Smudge Stick…",
+ ARTISTIC,
+ "{strokeLength: 0..10 (2; length of the short diagonal strokes), highlightArea: 0..20 (12; widens the area counted as light), intensity: 0..10 (10; how far the light areas are lightened)} smudges the dark areas along short diagonal strokes; the lighter areas become brighter and lose detail. Coverage is kept. Original visual approximation; chosen VectorCraft defaults.",
+ json!({"strokeLength": 2.0, "highlightArea": 12.0, "intensity": 10.0}),
+ ),
+ r(
+ "artistic.sponge",
+ "Sponge…",
+ ARTISTIC,
+ "{brushSize: 0..10 (2; size of the sponge's pores), definition: 0..25 (12; how strongly lighter and darker blobs contrast), smoothness: 1..15 (5; softer blob edges)} paints the object as if dabbed with a sponge, in highly textured areas of contrasting colour. Coverage is kept. Original visual approximation; chosen VectorCraft defaults.",
+ json!({"brushSize": 2.0, "definition": 12.0, "smoothness": 5.0}),
+ ),
+ r(
+ "artistic.watercolor",
+ "Watercolor…",
+ ARTISTIC,
+ "{brushDetail: 1..14 (9; the larger, the more detail stays), shadowIntensity: 0..10 (1; deepens the shadows), texture: 1..3 (1; paper grain, whole numbers)} paints the object in a watercolor style: detail simplified, colour saturated and darker where tones change at edges. Coverage is kept. Original visual approximation; chosen VectorCraft defaults.",
+ json!({"brushDetail": 9.0, "shadowIntensity": 1.0, "texture": 1.0}),
+ ),
r(
"blur.radial",
"Radial Blur…",
@@ -467,13 +497,83 @@ pub fn effect_catalog() -> Vec {
"{amount: % 1..500 (50), radius: pt 0.1..250 (1; σ of the blur edges are found against), threshold: levels 0..255 (0; smaller differences are left alone)}",
json!({"amount": 50.0, "radius": 1.0, "threshold": 0.0}),
),
+ r(
+ "sketch.basRelief",
+ "Bas Relief…",
+ SKETCH,
+ "{detail: 1..15 (13; the larger, the finer the features that stay), smoothness: 1..15 (3; rounds the carving), lightDirection: \"bottom\"|\"bottomLeft\"|\"left\"|\"topLeft\"|\"top\"|\"topRight\"|\"right\"|\"bottomRight\" (\"bottom\"; where the light comes from)} carves the object in low relief in black and white: surfaces facing the light turn white, those turned away black, flat areas grey. Coverage is kept. Original visual approximation; chosen VectorCraft defaults.",
+ json!({"detail": 13.0, "smoothness": 3.0, "lightDirection": "bottom"}),
+ ),
+ r(
+ "sketch.chalkCharcoal",
+ "Chalk & Charcoal…",
+ SKETCH,
+ "{chalkArea: 0..20 (6; chalk in light areas), charcoalArea: 0..20 (6; charcoal in dark areas), strokePressure: 0..5 (2)} redraws the object with chalk highlights and charcoal strokes on white paper, keeping its coverage. Original visual approximation from public documentation; slider ranges and defaults are VectorCraft choices, not verified proprietary values.",
+ json!({"chalkArea": 6.0, "charcoalArea": 6.0, "strokePressure": 2.0}),
+ ),
+ r(
+ "sketch.charcoal",
+ "Charcoal…",
+ SKETCH,
+ "{thickness: 1..7 (1; width of the bold edges and of the strokes' spacing), detail: 0..5 (1; the larger, the finer the edges), lightDarkBalance: 0..100 (50; how far into the lights the charcoal reaches)} redraws the object in black charcoal on white paper: bold edges and diagonal strokes over the midtones. Coverage is kept. Original visual approximation; chosen VectorCraft defaults.",
+ json!({"thickness": 1.0, "detail": 1.0, "lightDarkBalance": 50.0}),
+ ),
+ r(
+ "sketch.chrome",
+ "Chrome…",
+ SKETCH,
+ "{detail: 0..10 (4; finer surface texture), smoothness: 0..10 (4; softer relief before the highlights and shadows)} treats the object as polished chrome lit from the top left: bright highlights on high points and dark shadows in low ones, keeping its coverage. Original visual approximation; chosen VectorCraft defaults.",
+ json!({"detail": 4.0, "smoothness": 4.0}),
+ ),
+ r(
+ "sketch.graphicPen",
+ "Graphic Pen…",
+ SKETCH,
+ "{strokeLength: pt 1..15 (5; the longest ink stroke), lightDarkBalance: 0..100 (50; more black when higher), strokeDirection: \"rightDiagonal\"|\"horizontal\"|\"leftDiagonal\"|\"vertical\" (\"rightDiagonal\")} redraws the object in fine linear black ink on white paper, with strokes denser in darker areas. Control names and ranges follow the public documentation; the defaults are unverified.",
+ json!({"strokeLength": 5.0, "lightDarkBalance": 50.0, "strokeDirection": "rightDiagonal"}),
+ ),
r(
"sketch.halftonePattern",
"Halftone Pattern…",
SKETCH,
- "{size: pt 1..12 (1; how far apart the screen's dots, rings or lines are), contrast: 0..50 (5; 50 draws pure black and white), patternType: \"circle\"|\"dot\"|\"line\" (\"dot\"; rings round the object's centre, dots on a square grid, horizontal lines)} redraws the object in black ink on white paper through a halftone screen whose ink covers as much as the colour is dark, keeping its coverage. Original visual approximation; chosen VectorCraft defaults.",
+ "{size: pt 1..12 (1; how far apart the screen's dots, rings or lines are), contrast: 0..50 (5; 50 draws pure black and white), patternType: \"circle\"|\"dot\"|\"line\" (\"dot\"; rings round the object's centre, dots on a square grid, horizontal lines)} redraws the object in black ink on white paper through a halftone screen whose ink covers as much as the colour is dark, keeping its coverage. Original visual approximation from the public Sketch effects reference; slider ranges follow the documented control names, numeric defaults are chosen for VectorCraft and are not verified against proprietary defaults (the public help pages give no numbers).",
json!({"size": 1.0, "contrast": 5.0, "patternType": "dot"}),
),
+ r(
+ "sketch.notePaper",
+ "Note Paper…",
+ SKETCH,
+ "{imageBalance: 0..50 (25; lower tones darken the emboss, higher lighten it), graininess: 0..10 (0; fibrous paper texture), relief: 0..50 (4; emboss strength in points)} embosses the object's tones on warm paper, keeping its coverage. Original visual approximation from the public Sketch effects reference; slider ranges follow the documented control names, numeric defaults are chosen for VectorCraft and are not verified against proprietary defaults (the public help pages give no numbers).",
+ json!({"imageBalance": 25.0, "graininess": 0.0, "relief": 4.0}),
+ ),
+ r(
+ "sketch.photocopy",
+ "Photocopy…",
+ SKETCH,
+ "{detail: 1..24 (7; the larger, the finer the features that copy), darkness: 1..50 (25; the larger, the more of the dark copies)} copies the object in black on white: large dark areas copy only around their edges and midtones go to black or white. Coverage is kept. Original visual approximation; chosen VectorCraft defaults.",
+ json!({"detail": 7.0, "darkness": 25.0}),
+ ),
+ r(
+ "sketch.plaster",
+ "Plaster…",
+ SKETCH,
+ "{imageBalance: 1..50 (20; higher values sink more of the image), smoothness: 1..15 (8; higher values soften the relief), lightDirection: \"bottom\"|\"bottomLeft\"|\"left\"|\"topLeft\"|\"top\"|\"topRight\"|\"right\"|\"bottomRight\" (\"top\")} molds the object in relief plaster and lights it from that direction; dark areas are raised and light areas recessed, keeping its coverage. Original visual approximation; chosen VectorCraft defaults.",
+ json!({"imageBalance": 20.0, "smoothness": 8.0, "lightDirection": "top"}),
+ ),
+ r(
+ "sketch.reticulation",
+ "Reticulation…",
+ SKETCH,
+ "{density: 0..50 (12; finer grain at higher values), foregroundLevel: 0..50 (6; pulls shadows toward black ink), backgroundLevel: 0..50 (6; pulls highlights toward white paper)} redraws the object in black ink on white paper through a high-contrast film-grain screen, keeping its coverage. Original visual approximation; chosen VectorCraft defaults.",
+ json!({"density": 12.0, "foregroundLevel": 6.0, "backgroundLevel": 6.0}),
+ ),
+ r(
+ "sketch.stamp",
+ "Stamp…",
+ SKETCH,
+ "{lightDarkBalance: 0..50 (25; the larger, the more of the object prints black), smoothness: 1..50 (5; rounds the shapes)} simplifies the object to solid black and white, as a rubber stamp would print it. Coverage is kept. Original visual approximation; chosen VectorCraft defaults.",
+ json!({"lightDarkBalance": 25.0, "smoothness": 5.0}),
+ ),
r(
"stylize.glowingEdges",
"Glowing Edges…",
@@ -841,6 +941,12 @@ pub struct GeomContext<'a> {
/// The seed of the Transform effect's Random: the object's id, so each object varies its own
/// way and keeps its result on every redraw.
pub seed: u64,
+ /// The object's appearance, which live-effect plug-ins are given read only (their fills and
+ /// strokes).
+ pub appearance: Option<&'a Appearance>,
+ /// The index in `appearance.items` of the fill or stroke whose own effects these are; `None`:
+ /// the object's effects.
+ pub item: Option,
}
impl<'a> GeomContext<'a> {
@@ -850,15 +956,17 @@ impl<'a> GeomContext<'a> {
NodeKind::Path { rule, .. } | NodeKind::Compound { rule, .. } => *rule,
_ => FillRule::NonZero,
};
- Self { stroke: n.appearance.stroke().filter(|s| !s.paint.is_none() && s.width > 0.0), rule, seed: n.id.0 }
+ let stroke = n.appearance.stroke().filter(|s| !s.paint.is_none() && s.width > 0.0);
+ Self { stroke, rule, seed: n.id.0, appearance: Some(&n.appearance), item: None }
}
/// The context of the effects on `item`, one of the same object's appearance items: a
- /// stroke's own effects outline that stroke.
+ /// stroke's own effects outline that stroke, and a plug-in is told which item it is on.
pub fn item(self, item: &'a AppearanceItem) -> Self {
+ let at = self.appearance.and_then(|a| a.items.iter().position(|i| std::ptr::eq(i, item)));
match item {
- AppearanceItem::Stroke(s) => Self { stroke: Some(s), ..self },
- AppearanceItem::Fill(_) => self,
+ AppearanceItem::Stroke(s) => Self { stroke: Some(s), item: at, ..self },
+ AppearanceItem::Fill(_) => Self { item: at, ..self },
}
}
}
@@ -897,7 +1005,8 @@ pub fn apply_geometry_bez(effects: &[Effect], path: &BezPath, bounds: Rect, ctx:
pub(crate) fn apply_one(id: &str, p: &Value, path: &PathData, b: Rect, ctx: &GeomContext) -> PathData {
use util::*;
if let Some(plugin) = vectorcraft_plugins::effect::plugin_id(id) {
- return vectorcraft_plugins::effect::apply(plugin, p, path, b, ctx.rule).unwrap_or_else(|| path.clone());
+ let paints = vectorcraft_plugins::effect::Paints { appearance: ctx.appearance, item: ctx.item };
+ return vectorcraft_plugins::effect::apply(plugin, p, path, b, ctx.rule, paints).unwrap_or_else(|| path.clone());
}
match id {
"distort.freeDistort" => distort::free_distort(path, b, p),
diff --git a/crates/effects/src/pixel/artistic.rs b/crates/effects/src/pixel/artistic.rs
index f18b1709a0..0d6764feb6 100644
--- a/crates/effects/src/pixel/artistic.rs
+++ b/crates/effects/src/pixel/artistic.rs
@@ -1,4 +1,4 @@
-//! Effect › Artistic (Cutout, Film Grain, Neon Glow, Poster Edges). Original filters built from
+//! Effect › Artistic (Cutout, Film Grain, Neon Glow, Plastic Wrap, Poster Edges). Original filters built from
//! public behaviour documentation:
//! and
//! .
@@ -6,6 +6,8 @@
use super::edges::sobel;
use super::pixelate::{Place, cell, rand};
+
+const SALT_PLASTIC: u64 = 512;
use super::texture::{luma, premultiply, straight};
use super::{PixelSpace, blur_plane};
use vectorcraft_geom::Point;
@@ -239,6 +241,79 @@ pub(super) fn poster_edges(px: &mut [[u8; 4]], w: usize, h: usize, space: &Pixel
}
}
+/// How far (document units) Plastic Wrap's softened relief is sampled at `smoothness` (1..15).
+pub(super) fn plastic_reach(smoothness: f64) -> f64 {
+ 3.0 * (0.15 + 0.35 * smoothness.clamp(1.0, 15.0))
+}
+
+/// Plastic Wrap: the object under shiny plastic. Its tones form a relief; `detail` (0..15) adds
+/// finer wrinkles in document space; `smoothness` (1..15) softens the relief; specular highlights
+/// as strong as `highlight` (0..20) are screened over it. Coverage is kept.
+pub(super) fn plastic_wrap(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, highlight: f64, detail: f64, smoothness: f64) {
+ if ![highlight, detail, smoothness].iter().all(|v| v.is_finite()) || !space.px.is_finite() || space.px <= 0.0 {
+ return;
+ }
+ let strength = (highlight / 20.0).clamp(0.0, 1.0) as f32;
+ if strength == 0.0 {
+ return;
+ }
+ let detail_amt = (detail / 15.0).clamp(0.0, 1.0) as f32;
+ let sigma = (0.15 + 0.35 * smoothness.clamp(1.0, 15.0)) / space.px;
+ let Some(place) = Place::new(space, w, h) else { return };
+ let len = px.len();
+ let mut height = vec![0.0f32; len];
+ let alpha: Vec = px.iter().map(|p| f32::from(p[3]) / 255.0).collect();
+ let cell_scale = 8.0 + 24.0 * (1.0 - detail_amt as f64);
+ let mut noise = CellNoise::default();
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ let i = y * w + x;
+ let l = luma(straight(*p));
+ let q = place.at(x, y);
+ let nq = Point::new(q.x / cell_scale, q.y / cell_scale);
+ height[i] = l + detail_amt * 0.35 * noise.at(SALT_PLASTIC, nq) as f32;
+ });
+ for (h, a) in height.iter_mut().zip(&alpha) {
+ *h *= *a;
+ }
+ blur_plane(&mut height, w, h, sigma);
+ let mut cov = alpha.clone();
+ blur_plane(&mut cov, w, h, sigma);
+ for (h, c) in height.iter_mut().zip(&cov) {
+ *h = if *c > 1e-4 { *h / *c } else { 0.0 };
+ }
+ const LIGHT: [f32; 3] = [0.35, -0.25, 0.9];
+ let inv = (LIGHT[0] * LIGHT[0] + LIGHT[1] * LIGHT[1] + LIGHT[2] * LIGHT[2]).sqrt().max(1e-6);
+ let light = LIGHT.map(|v| v / inv);
+ let scale = (8.0 * space.px).max(1e-6) as f32;
+ let sample = |x: isize, y: isize| -> f32 {
+ if x < 0 || y < 0 || x >= w as isize || y >= h as isize {
+ return 0.0;
+ }
+ height[y as usize * w + x as usize]
+ };
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ let gx = sample(x as isize + 1, y as isize) - sample(x as isize - 1, y as isize);
+ let gy = sample(x as isize, y as isize + 1) - sample(x as isize, y as isize - 1);
+ let nx = -gx / scale;
+ let ny = -gy / scale;
+ let nz = 1.0;
+ let nlen = (nx * nx + ny * ny + nz * nz).sqrt().max(1e-6);
+ let ndotl = (nx / nlen * light[0] + ny / nlen * light[1] + nz / nlen * light[2]).max(0.0);
+ let spec = ndotl.powi(12) * strength;
+ if spec <= 1e-5 {
+ return;
+ }
+ let c = straight(*p).map(|v| 1.0 - (1.0 - v) * (1.0 - spec));
+ *p = premultiply(c, f32::from(p[3]) / 255.0);
+ });
+}
+
/// How far (document units) Neon Glow's glow spreads at `size` (-24..24).
pub(super) fn glow_spread(size: f64) -> f64 {
0.25 * size.abs().min(24.0)
diff --git a/crates/effects/src/pixel/brushstrokes.rs b/crates/effects/src/pixel/brushstrokes.rs
index 416a67de43..d496f294ed 100644
--- a/crates/effects/src/pixel/brushstrokes.rs
+++ b/crates/effects/src/pixel/brushstrokes.rs
@@ -64,9 +64,9 @@ impl StrokeDirection {
}
/// Along a right diagonal stroke, rising to the right (y down).
-const RIGHT: Vec2 = Vec2::new(FRAC_1_SQRT_2, -FRAC_1_SQRT_2);
+pub(super) const RIGHT: Vec2 = Vec2::new(FRAC_1_SQRT_2, -FRAC_1_SQRT_2);
/// Along a left diagonal stroke, falling to the right.
-const LEFT: Vec2 = Vec2::new(FRAC_1_SQRT_2, FRAC_1_SQRT_2);
+pub(super) const LEFT: Vec2 = Vec2::new(FRAC_1_SQRT_2, FRAC_1_SQRT_2);
/// The most samples a stroke averages, whatever its length.
const MAX_SAMPLES: usize = 16;
@@ -75,7 +75,7 @@ const MAX_SAMPLES: usize = 16;
const JITTER: f64 = 0.25;
/// How soft (points, the σ) the tones are that decide which strokes a pixel gets.
-const TONE_SOFTNESS: f64 = 1.0;
+pub(super) const TONE_SOFTNESS: f64 = 1.0;
/// Dark Strokes' short dark strokes and long light ones (points).
pub(super) const DARK_LENGTH: f64 = 3.0;
@@ -86,7 +86,7 @@ const INK_SOFTNESS: f64 = 0.6;
/// A pixel at 72 ppi (points): how far the neighbours of the Sobel operator and of sampling
/// between pixels add to a filter's reach.
-const MARGIN: f64 = 1.0;
+pub(super) const MARGIN: f64 = 1.0;
/// How far (document units) strokes `len` long reach: half their length, their random shift, the
/// softening between their samples and the pixels a sample is taken between.
@@ -137,18 +137,18 @@ pub(super) fn spray_shift(radius: f64) -> f64 {
/// The object's colours averaged along strokes `len` long: [`MAX_SAMPLES`] at most, the object
/// softened first when they lie more than a pixel apart.
-struct Smear<'a> {
+pub(super) struct Smear<'a> {
/// Premultiplied colours (0..1).
src: Vec<[f32; 4]>,
w: usize,
h: usize,
place: &'a Place,
- len: f64,
+ pub(super) len: f64,
n: usize,
}
impl<'a> Smear<'a> {
- fn new(px: &[[u8; 4]], w: usize, h: usize, place: &'a Place, len: f64) -> Self {
+ pub(super) fn new(px: &[[u8; 4]], w: usize, h: usize, place: &'a Place, len: f64) -> Self {
let len = if len.is_finite() { len.max(0.0) } else { 0.0 };
let span = len / place.px;
let n = if span.is_finite() { (span.ceil() as usize).saturating_add(1).clamp(1, MAX_SAMPLES) } else { MAX_SAMPLES };
@@ -218,7 +218,7 @@ impl<'a> Smear<'a> {
}
/// The stroke of pattern `salt` through `q` along `dir`, its rows `width` apart.
- fn stroke(&self, salt: u64, q: Point, dir: Vec2, width: f64) -> [f32; 4] {
+ pub(super) fn stroke(&self, salt: u64, q: Point, dir: Vec2, width: f64) -> [f32; 4] {
self.at(q + dir * stroke_shift(salt, q, dir, self.len, width), dir)
}
}
@@ -242,37 +242,37 @@ fn stroke_shift(salt: u64, q: Point, dir: Vec2, len: f64, width: f64) -> f64 {
}
/// Smooth noise in [-1, 1) streaked along `dir`: blobs `along` long and `across` wide.
-fn streak(salt: u64, q: Point, dir: Vec2, along: f64, across: f64) -> f64 {
+pub(super) fn streak(salt: u64, q: Point, dir: Vec2, along: f64, across: f64) -> f64 {
let (u, v) = frame(q, dir);
2.0 * value_noise(salt, u / along.max(1e-3), v / across.max(1e-3)) - 1.0
}
/// The straight colour and coverage of premultiplied `pm` (0..1).
-fn unpremultiply(pm: [f32; 4]) -> ([f32; 3], f32) {
+pub(super) fn unpremultiply(pm: [f32; 4]) -> ([f32; 3], f32) {
let a = pm[3].clamp(0.0, 1.0);
if a > 1e-6 { ([pm[0], pm[1], pm[2]].map(|v| (v / a).clamp(0.0, 1.0)), a) } else { ([0.0; 3], 0.0) }
}
/// `a` + (`b` − `a`) × `t`, channel by channel.
-fn mix(a: [f32; N], b: [f32; N], t: f32) -> [f32; N] {
+pub(super) fn mix(a: [f32; N], b: [f32; N], t: f32) -> [f32; N] {
std::array::from_fn(|k| a[k] + (b[k] - a[k]) * t)
}
/// A smooth step from 0 at `t` ≤ 0 to 1 at `t` ≥ 1.
-fn ramp(t: f64) -> f64 {
+pub(super) fn ramp(t: f64) -> f64 {
let t = if t.is_finite() { t.clamp(0.0, 1.0) } else { 0.0 };
t * t * (3.0 - 2.0 * t)
}
/// Pixel `p` (premultiplied 0..255) as premultiplied 0..1.
-fn unit(p: [u8; 4]) -> [f32; 4] {
+pub(super) fn unit(p: [u8; 4]) -> [f32; 4] {
p.map(|v| f32::from(v) / 255.0)
}
/// The object's edges after softening it by `sigma` (document units): about 1 across a step from
/// black to white or from clear to opaque, the same at any resolution. Empty when the sizes don't
/// match.
-fn edges(px: &[[u8; 4]], w: usize, h: usize, place: &Place, sigma: f64) -> Vec {
+pub(super) fn edges(px: &[[u8; 4]], w: usize, h: usize, place: &Place, sigma: f64) -> Vec {
let mut tone: Vec = px.iter().map(|p| luma(straight(*p)) * f32::from(p[3]) / 255.0).collect();
let mut cover: Vec = px.iter().map(|p| f32::from(p[3]) / 255.0).collect();
let s = sigma / place.px;
@@ -516,3 +516,40 @@ pub(super) fn sumi_e(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace,
*p = premultiply(out, f32::from(p[3]) / 255.0);
});
}
+
+const SALT_GRAPHIC: u64 = 200;
+
+/// Graphic Pen: the object redrawn in fine linear ink strokes along `dir`, each `len` (1..15)
+/// points long on white paper; `balance` (0..100) sets the tone threshold (higher draws more
+/// black ink).
+pub(super) fn graphic_pen(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, len: f64, balance: f64, dir: StrokeDirection) {
+ let Some(place) = Place::new(space, w, h) else { return };
+ let len = if len.is_finite() { len.clamp(1.0, 15.0) } else { 1.0 };
+ let smear = Smear::new(px, w, h, &place, len);
+ let tones = Tones::new(px, w, h, TONE_SOFTNESS / place.px);
+ let threshold = 1.0 - balance.clamp(0.0, 100.0) / 100.0;
+ let row = (0.2 * len).max(0.75);
+ let along = dir.along();
+ place.each(px, |x, y, p| {
+ let a = f32::from(p[3]) / 255.0;
+ if a <= 0.0 {
+ return;
+ }
+ let q = place.at(x, y);
+ let (c, stroke_a) = unpremultiply(smear.stroke(SALT_GRAPHIC, q, along, row));
+ let dark = (1.0 - tones.get(x, y)).max(f64::from(1.0 - luma(c)) * f64::from(stroke_a));
+ if dark <= threshold {
+ *p = premultiply([1.0, 1.0, 1.0], a);
+ return;
+ }
+ let weight = ramp((dark - threshold) / (1.0 - threshold).max(1e-3));
+ let u = frame(q, along).0;
+ let on_stroke = {
+ let t = (u / len).rem_euclid(1.0);
+ if t < 0.65 { 1.0 } else { 0.0 }
+ };
+ let grain = 0.08 * streak(SALT_GRAPHIC + 1, q, along, 0.35 * len, 0.5);
+ let ink = (weight * on_stroke + grain).clamp(0.0, 1.0);
+ *p = premultiply([(1.0 - ink) as f32; 3], a);
+ });
+}
diff --git a/crates/effects/src/pixel/mod.rs b/crates/effects/src/pixel/mod.rs
index ee25c9ca60..051278eb11 100644
--- a/crates/effects/src/pixel/mod.rs
+++ b/crates/effects/src/pixel/mod.rs
@@ -1,7 +1,9 @@
-//! Photoshop-style raster effects (Effect › Artistic › Cutout, Film Grain, Neon Glow and Poster Edges, Blur › Radial Blur and Smart Blur, Brush Strokes ›
-//! Accented Edges, Angled Strokes, Crosshatch, Dark Strokes, Ink Outlines, Spatter, Sprayed Strokes
-//! and Sumi-e, Distort › Diffuse Glow, Glass and Ocean Ripple, Pixelate › Color Halftone,
-//! Crystallize, Mezzotint and Pointillize, Sharpen › Unsharp Mask, Sketch › Halftone Pattern, Stylize ›
+//! Photoshop-style raster effects (Effect › Artistic › Cutout, Film Grain, Neon Glow, Plastic Wrap and
+//! Poster Edges, Smudge Stick, Sponge and Watercolor, Blur › Radial Blur and Smart Blur, Brush Strokes › Accented Edges, Angled Strokes,
+//! Crosshatch, Dark Strokes, Ink Outlines, Spatter, Sprayed Strokes and Sumi-e, Distort › Diffuse
+//! Glow, Glass and Ocean Ripple, Pixelate › Color Halftone, Crystallize, Mezzotint and Pointillize,
+//! Sharpen › Unsharp Mask, Sketch › Chalk & Charcoal, Graphic Pen, Halftone Pattern, Note Paper, Plaster and
+//! Reticulation, Stylize ›
//! Glowing Edges, Texture
//! › Craquelure, Grain, Mosaic Tiles, Patchwork, Stained Glass and Texturizer, and Video ›
//! De-Interlace and NTSC Colors): filters over premultiplied RGBA8 pixels.
@@ -19,9 +21,11 @@ mod brushstrokes;
mod distort;
mod edges;
mod loaded;
+mod paint;
mod pixelate;
mod sharpen;
mod sketch;
+mod sketch_ink;
mod texture;
mod video;
@@ -39,11 +43,15 @@ pub use sketch::{HALFTONE_TYPES, HalftonePattern};
pub use texture::{GRAIN_TYPES, Grain, LIGHT_DIRECTIONS, Light, TEXTURES, Texture};
/// The Photoshop-style effect ids (all raster effects, see [`crate::is_raster`]).
-pub const PIXEL_EFFECTS: [&str; 32] = [
+pub const PIXEL_EFFECTS: [&str; 46] = [
"artistic.cutout",
"artistic.filmGrain",
"artistic.neonGlow",
+ "artistic.plasticWrap",
"artistic.posterEdges",
+ "artistic.smudgeStick",
+ "artistic.sponge",
+ "artistic.watercolor",
"blur.radial",
"blur.smart",
"brushStrokes.accentedEdges",
@@ -62,7 +70,17 @@ pub const PIXEL_EFFECTS: [&str; 32] = [
"pixelate.mezzotint",
"pixelate.pointillize",
"sharpen.unsharpMask",
+ "sketch.basRelief",
+ "sketch.chalkCharcoal",
+ "sketch.charcoal",
+ "sketch.chrome",
+ "sketch.graphicPen",
"sketch.halftonePattern",
+ "sketch.notePaper",
+ "sketch.photocopy",
+ "sketch.plaster",
+ "sketch.reticulation",
+ "sketch.stamp",
"stylize.glowingEdges",
"texture.craquelure",
"texture.grain",
@@ -84,10 +102,23 @@ pub enum PixelFx {
/// Artistic › Film Grain: monochrome grain in shadows and midtones, a wider bright
/// highlight area (0..20), and tonal intensity (0..10), preserving coverage.
FilmGrain { grain: f64, highlight: f64, intensity: f64 },
+ /// Artistic › Smudge Stick: the dark areas smudged along short diagonal strokes `stroke`
+ /// (0..10) long, the light areas (widened by `highlight`, 0..20) smudged longer and lightened
+ /// by up to `intensity` (0..10).
+ SmudgeStick { stroke: f64, highlight: f64, intensity: f64 },
+ /// Artistic › Sponge: soft blobs of lighter and darker colour about `brush` (0..10) large,
+ /// contrasting as `definition` (0..25) says, their edges as soft as `smoothness` (1..15).
+ Sponge { brush: f64, definition: f64, smoothness: f64 },
+ /// Artistic › Watercolor: detail simplified by a brush of `detail` (1..14), edges saturated,
+ /// shadows deepened by `shadow` (0..10), `texture` (1..3) grains of paper showing.
+ Watercolor { detail: f64, shadow: f64, texture: u32 },
/// Artistic › Neon Glow: dimmed greys lit by `colour` (straight RGB, 0..1) glowing from the
/// light areas (`size` above 0) or the dark ones (below 0), spread by |`size`| (-24..24), as
/// strong as `brightness` (0..50).
NeonGlow { size: f64, brightness: f64, colour: [f32; 3] },
+ /// Artistic › Plastic Wrap: specular highlights as strong as `highlight` (0..20) on a relief
+ /// wrinkled by `detail` (0..15) and softened by `smoothness` (1..15).
+ PlasticWrap { highlight: f64, detail: f64, smoothness: f64 },
/// Artistic › Poster Edges: colours posterized to `posterization` + 2 levels (0..6) with black
/// lines on the edges, as thick as `thickness` (0..10) and as dark as `intensity` (0..10).
PosterEdges { thickness: f64, intensity: f64, posterization: f64 },
@@ -139,9 +170,38 @@ pub enum PixelFx {
/// Sharpen › Unsharp Mask: colours pushed away from a Gaussian blur of σ = `radius` by `amount`
/// (1 = 100 %), where they differ from it by at least `threshold` levels.
UnsharpMask { amount: f64, radius: f64, threshold: f64 },
+ /// Sketch › Chalk & Charcoal: chalk highlights in light areas and charcoal in dark ones;
+ /// `chalk` and `charcoal` (0..20) set how much, `pressure` (0..5) the stroke weight.
+ ChalkCharcoal { chalk: f64, charcoal: f64, pressure: f64 },
+ /// Sketch › Chrome: polished chrome relief with `detail` (0..10) and `smoothness` (0..10).
+ Chrome { detail: f64, smoothness: f64 },
+ /// Sketch › Graphic Pen: fine linear ink strokes along `dir`, each `length` (1..15) points long
+ /// on white paper; `balance` (0..100) sets how much of the tone range becomes black ink.
+ GraphicPen { length: f64, balance: f64, direction: StrokeDirection },
/// Sketch › Halftone Pattern: black ink on white paper through a `kind` screen of cells `size`
/// (1..12) apart, its edges as hard as `contrast` (0..50) says.
HalftonePattern { size: f64, contrast: f64, kind: HalftonePattern },
+ /// Sketch › Note Paper: embossed tones on fibrous paper (`balance`, `graininess`, `relief`).
+ NotePaper { balance: f64, graininess: f64, relief: f64 },
+ /// Sketch › Bas Relief: low relief lit from `light`, keeping the finer features as `detail`
+ /// (1..15) says and rounded by `smoothness` (1..15).
+ BasRelief { detail: f64, smoothness: f64, light: Light },
+ /// Sketch › Charcoal: bold edges `thickness` (1..7) wide, as fine as `detail` (0..5) says, and
+ /// diagonal strokes over the midtones; `balance` (0..100) sets how far into the lights it reaches.
+ Charcoal { thickness: f64, detail: f64, balance: f64 },
+ /// Sketch › Photocopy: black only where a pixel is darker than its surroundings, as fine as
+ /// `detail` (1..24) says, and as readily as `darkness` (1..50) says.
+ Photocopy { detail: f64, darkness: f64 },
+ /// Sketch › Stamp: solid black and white, printing black as much as `balance` (0..50) says,
+ /// its shapes rounded by `smoothness` (1..50).
+ Stamp { balance: f64, smoothness: f64 },
+ /// Sketch › Plaster: relief plaster lit from `light`; dark areas raised, light recessed;
+ /// `imageBalance` (1..50) shifts more of the image lower at higher values; `smoothness` (1..15)
+ /// softens the relief.
+ Plaster { image_balance: f64, smoothness: f64, light: Light },
+ /// Sketch › Reticulation: black ink on white paper through a high-contrast film-grain screen;
+ /// `density` (0..50), `foreground` and `background` (0..50) pull tones before the grain.
+ Reticulation { density: f64, foreground: f64, background: f64 },
/// Stylize › Glowing Edges: bright coloured Sobel outlines on black.
GlowingEdges { width: f64, brightness: f64, smoothness: f64 },
/// Pixelate › Color Halftone: each colour channel screened at its angle (`angles`° of channels
@@ -242,6 +302,26 @@ pub(crate) fn parse(id: &str, p: &Value) -> Option {
highlight: num(p, "highlightArea", 0.0).clamp(0.0, 20.0),
intensity: num(p, "intensity", 10.0).clamp(0.0, 10.0),
},
+ "artistic.smudgeStick" => PixelFx::SmudgeStick {
+ stroke: num(p, "strokeLength", 2.0).clamp(0.0, 10.0),
+ highlight: num(p, "highlightArea", 12.0).clamp(0.0, 20.0),
+ intensity: num(p, "intensity", 10.0).clamp(0.0, 10.0),
+ },
+ "artistic.sponge" => PixelFx::Sponge {
+ brush: num(p, "brushSize", 2.0).clamp(0.0, 10.0),
+ definition: num(p, "definition", 12.0).clamp(0.0, 25.0),
+ smoothness: num(p, "smoothness", 5.0).clamp(1.0, 15.0),
+ },
+ "artistic.watercolor" => PixelFx::Watercolor {
+ detail: num(p, "brushDetail", 9.0).clamp(1.0, 14.0),
+ shadow: num(p, "shadowIntensity", 1.0).clamp(0.0, 10.0),
+ texture: num(p, "texture", 1.0).clamp(1.0, 3.0).round() as u32,
+ },
+ "artistic.plasticWrap" => PixelFx::PlasticWrap {
+ highlight: num(p, "highlightStrength", 20.0).clamp(0.0, 20.0),
+ detail: num(p, "detail", 12.0).clamp(0.0, 15.0),
+ smoothness: num(p, "smoothness", 15.0).clamp(1.0, 15.0),
+ },
"blur.radial" => PixelFx::RadialBlur {
amount: num(p, "amount", 10.0).clamp(1.0, 100.0),
zoom: text(p, "method", "spin").eq_ignore_ascii_case("zoom"),
@@ -311,11 +391,53 @@ pub(crate) fn parse(id: &str, p: &Value) -> Option {
radius: num(p, "radius", 1.0).clamp(0.1, 250.0),
threshold: num(p, "threshold", 0.0).clamp(0.0, 255.0),
},
+ "sketch.chalkCharcoal" => PixelFx::ChalkCharcoal {
+ chalk: num(p, "chalkArea", 6.0).clamp(0.0, 20.0),
+ charcoal: num(p, "charcoalArea", 6.0).clamp(0.0, 20.0),
+ pressure: num(p, "strokePressure", 2.0).clamp(0.0, 5.0),
+ },
+ "sketch.chrome" => PixelFx::Chrome { detail: num(p, "detail", 4.0).clamp(0.0, 10.0), smoothness: num(p, "smoothness", 4.0).clamp(0.0, 10.0) },
+ "sketch.graphicPen" => PixelFx::GraphicPen {
+ length: num(p, "strokeLength", 5.0).clamp(1.0, 15.0),
+ balance: num(p, "lightDarkBalance", 50.0).clamp(0.0, 100.0),
+ direction: StrokeDirection::parse(text(p, "strokeDirection", "rightDiagonal")),
+ },
"sketch.halftonePattern" => PixelFx::HalftonePattern {
size: num(p, "size", 1.0).clamp(1.0, 12.0),
contrast: num(p, "contrast", 5.0).clamp(0.0, 50.0),
kind: HalftonePattern::parse(text(p, "patternType", "dot")),
},
+ "sketch.notePaper" => PixelFx::NotePaper {
+ balance: num(p, "imageBalance", 25.0).clamp(0.0, 50.0),
+ graininess: num(p, "graininess", 0.0).clamp(0.0, 10.0),
+ relief: num(p, "relief", 4.0).clamp(0.0, 50.0),
+ },
+ "sketch.basRelief" => PixelFx::BasRelief {
+ detail: num(p, "detail", 13.0).clamp(1.0, 15.0),
+ smoothness: num(p, "smoothness", 3.0).clamp(1.0, 15.0),
+ light: Light::parse(text(p, "lightDirection", "bottom")),
+ },
+ "sketch.charcoal" => PixelFx::Charcoal {
+ thickness: num(p, "thickness", 1.0).clamp(1.0, 7.0),
+ detail: num(p, "detail", 1.0).clamp(0.0, 5.0),
+ balance: num(p, "lightDarkBalance", 50.0).clamp(0.0, 100.0),
+ },
+ "sketch.photocopy" => {
+ PixelFx::Photocopy { detail: num(p, "detail", 7.0).clamp(1.0, 24.0), darkness: num(p, "darkness", 25.0).clamp(1.0, 50.0) }
+ }
+ "sketch.stamp" => {
+ PixelFx::Stamp { balance: num(p, "lightDarkBalance", 25.0).clamp(0.0, 50.0), smoothness: num(p, "smoothness", 5.0).clamp(1.0, 50.0) }
+ }
+ "sketch.plaster" => PixelFx::Plaster {
+ image_balance: num(p, "imageBalance", 20.0).clamp(1.0, 50.0),
+ smoothness: num(p, "smoothness", 8.0).clamp(1.0, 15.0),
+ light: Light::parse(text(p, "lightDirection", "top")),
+ },
+ "sketch.reticulation" => PixelFx::Reticulation {
+ density: num(p, "density", 12.0).clamp(0.0, 50.0),
+ foreground: num(p, "foregroundLevel", 6.0).clamp(0.0, 50.0),
+ background: num(p, "backgroundLevel", 6.0).clamp(0.0, 50.0),
+ },
"stylize.glowingEdges" => PixelFx::GlowingEdges {
width: num(p, "edgeWidth", 2.0).clamp(1.0, 14.0),
brightness: num(p, "edgeBrightness", 6.0).clamp(0.0, 20.0),
@@ -381,7 +503,9 @@ impl PixelFx {
PixelFx::SmartBlur { radius, .. } => radius,
PixelFx::AccentedEdges { .. } => 0.0,
// Strokes reach out of the object as far as they reach into it.
- PixelFx::AngledStrokes { length, .. } | PixelFx::InkOutlines { length, .. } => brushstrokes::stroke_reach(length),
+ PixelFx::AngledStrokes { length, .. } | PixelFx::GraphicPen { length, .. } | PixelFx::InkOutlines { length, .. } => {
+ brushstrokes::stroke_reach(length)
+ }
PixelFx::Crosshatch { length, .. } => brushstrokes::stroke_reach(length) + brushstrokes::rough(length),
PixelFx::DarkStrokes { .. } => brushstrokes::stroke_reach(brushstrokes::LIGHT_LENGTH),
PixelFx::Spatter { radius, .. } => brushstrokes::spatter_shift(radius),
@@ -392,11 +516,21 @@ impl PixelFx {
// Content shifted outwards reaches past the bounds by as much as the shift.
PixelFx::Glass { distortion, .. } => distort::glass_shift(distortion),
PixelFx::OceanRipple { size, magnitude } => distort::ripple_shift(size, magnitude),
- PixelFx::UnsharpMask { .. } | PixelFx::HalftonePattern { .. } => 0.0,
+ PixelFx::UnsharpMask { .. }
+ | PixelFx::ChalkCharcoal { .. }
+ | PixelFx::Chrome { .. }
+ | PixelFx::HalftonePattern { .. }
+ | PixelFx::NotePaper { .. }
+ | PixelFx::Plaster { .. }
+ | PixelFx::Reticulation { .. } => 0.0,
+ PixelFx::BasRelief { .. } | PixelFx::Charcoal { .. } | PixelFx::Photocopy { .. } | PixelFx::Stamp { .. } => 0.0,
PixelFx::GlowingEdges { width, smoothness, .. } => width.max(smoothness * 3.0),
+ // These three keep the object's coverage.
+ PixelFx::SmudgeStick { .. } | PixelFx::Sponge { .. } | PixelFx::Watercolor { .. } => 0.0,
PixelFx::FilmGrain { .. }
| PixelFx::Cutout { .. }
| PixelFx::NeonGlow { .. }
+ | PixelFx::PlasticWrap { .. }
| PixelFx::PosterEdges { .. }
| PixelFx::ColorHalftone { .. }
| PixelFx::Mezzotint { .. }
@@ -420,9 +554,14 @@ impl PixelFx {
PixelFx::RadialBlur { .. } => None,
PixelFx::SmartBlur { radius, mode: SmartBlurMode::Normal, .. } => Some(radius),
PixelFx::SmartBlur { radius, samples, .. } => Some(blur::edge_reach(radius, samples)),
+ PixelFx::SmudgeStick { stroke, .. } => Some(paint::smudge_reach(stroke)),
+ PixelFx::Sponge { brush, smoothness, .. } => Some(paint::sponge_reach(brush, smoothness)),
+ PixelFx::Watercolor { detail, .. } => Some(paint::watercolor_reach(detail)),
PixelFx::AccentedEdges { width, smoothness, .. } => Some(brushstrokes::accent_reach(width, smoothness)),
// The strokes, and the softened tones that choose them.
- PixelFx::AngledStrokes { length, .. } => Some(brushstrokes::stroke_reach(length).max(brushstrokes::TONE_REACH)),
+ PixelFx::AngledStrokes { length, .. } | PixelFx::GraphicPen { length, .. } => {
+ Some(brushstrokes::stroke_reach(length).max(brushstrokes::TONE_REACH))
+ }
PixelFx::Crosshatch { length, .. } => {
Some((brushstrokes::stroke_reach(length) + brushstrokes::rough(length)).max(brushstrokes::TONE_REACH))
}
@@ -435,15 +574,27 @@ impl PixelFx {
PixelFx::Glass { distortion, .. } => Some(distort::glass_shift(distortion)),
PixelFx::OceanRipple { size, magnitude } => Some(distort::ripple_shift(size, magnitude)),
PixelFx::UnsharpMask { radius, .. } => Some(3.0 * radius),
+ PixelFx::BasRelief { detail, smoothness, .. } => Some(sketch_ink::relief_reach(detail, smoothness)),
+ PixelFx::Charcoal { thickness, detail, .. } => Some(sketch_ink::charcoal_reach(thickness, detail)),
+ PixelFx::Photocopy { detail, .. } => Some(sketch_ink::copy_reach(detail)),
+ PixelFx::Stamp { smoothness, .. } => Some(sketch_ink::stamp_reach(smoothness)),
PixelFx::GlowingEdges { width, smoothness, .. } => Some(width.max(smoothness * 3.0)),
// The cells around the pixel's, and the cells around theirs.
PixelFx::ColorHalftone { max_radius, .. } => Some(3.0 * std::f64::consts::SQRT_2 * max_radius),
PixelFx::Crystallize { cell } => Some(1.5 * cell),
- PixelFx::FilmGrain { .. } | PixelFx::Mezzotint { .. } | PixelFx::HalftonePattern { .. } => Some(0.0),
+ PixelFx::ChalkCharcoal { .. } => Some(sketch::CHALK_CHARCOAL_REACH),
+ PixelFx::Chrome { smoothness, .. } => Some(sketch::chrome_reach(smoothness)),
+ PixelFx::FilmGrain { .. }
+ | PixelFx::Mezzotint { .. }
+ | PixelFx::HalftonePattern { .. }
+ | PixelFx::NotePaper { .. }
+ | PixelFx::Reticulation { .. } => Some(0.0),
+ PixelFx::Plaster { smoothness, .. } => Some(sketch::plaster_reach(smoothness)),
// Cutout's palette comes from the whole object.
PixelFx::Cutout { .. } => None,
// The softened tones around the pixel.
PixelFx::NeonGlow { size, .. } => Some(3.0 * artistic::glow_spread(size)),
+ PixelFx::PlasticWrap { smoothness, .. } => Some(artistic::plastic_reach(smoothness)),
// The edges' lines, spread round them.
PixelFx::PosterEdges { thickness, .. } => Some(3.0 * (0.3 + 0.25 * thickness) + 1.0),
// The dots' points, and the softened colour around them.
@@ -468,6 +619,10 @@ impl PixelFx {
match *self {
PixelFx::Cutout { levels, simplicity, fidelity } => artistic::cutout(px, w, h, space, levels, simplicity, fidelity),
PixelFx::FilmGrain { grain, highlight, intensity } => artistic::film_grain(px, w, h, space, grain, highlight, intensity),
+ PixelFx::SmudgeStick { stroke, highlight, intensity } => paint::smudge_stick(px, w, h, space, stroke, highlight, intensity),
+ PixelFx::Sponge { brush, definition, smoothness } => paint::sponge(px, w, h, space, brush, definition, smoothness),
+ PixelFx::Watercolor { detail, shadow, texture } => paint::watercolor(px, w, h, space, detail, shadow, texture),
+ PixelFx::PlasticWrap { highlight, detail, smoothness } => artistic::plastic_wrap(px, w, h, space, highlight, detail, smoothness),
PixelFx::NeonGlow { size, brightness, colour } => artistic::neon_glow(px, w, h, space, size, brightness, colour),
PixelFx::PosterEdges { thickness, intensity, posterization } => {
artistic::poster_edges(px, w, h, space, thickness, intensity, posterization)
@@ -493,7 +648,17 @@ impl PixelFx {
}
PixelFx::OceanRipple { size, magnitude } => distort::ocean_ripple(px, w, h, space, size, magnitude),
PixelFx::UnsharpMask { amount, radius, threshold } => sharpen::unsharp(px, w, h, amount, to_px(radius), threshold),
+ PixelFx::ChalkCharcoal { chalk, charcoal, pressure } => sketch::chalk_charcoal(px, w, h, space, chalk, charcoal, pressure),
+ PixelFx::Chrome { detail, smoothness } => sketch::chrome(px, w, h, space, detail, smoothness),
+ PixelFx::GraphicPen { length, balance, direction } => brushstrokes::graphic_pen(px, w, h, space, length, balance, direction),
PixelFx::HalftonePattern { size, contrast, kind } => sketch::halftone_pattern(px, w, h, space, size, contrast, kind),
+ PixelFx::NotePaper { balance, graininess, relief } => sketch::note_paper(px, w, h, space, balance, graininess, relief),
+ PixelFx::BasRelief { detail, smoothness, light } => sketch_ink::bas_relief(px, w, h, space, detail, smoothness, light),
+ PixelFx::Charcoal { thickness, detail, balance } => sketch_ink::charcoal(px, w, h, space, thickness, detail, balance),
+ PixelFx::Photocopy { detail, darkness } => sketch_ink::photocopy(px, w, h, space, detail, darkness),
+ PixelFx::Stamp { balance, smoothness } => sketch_ink::stamp(px, w, h, space, balance, smoothness),
+ PixelFx::Plaster { image_balance, smoothness, light } => sketch::plaster(px, w, h, space, image_balance, smoothness, light),
+ PixelFx::Reticulation { density, foreground, background } => sketch::reticulation(px, w, h, space, density, foreground, background),
PixelFx::GlowingEdges { width, brightness, smoothness } => edges::glow(px, w, h, to_px(width), brightness, to_px(smoothness)),
PixelFx::ColorHalftone { max_radius, angles } => pixelate::color_halftone(px, w, h, space, max_radius, angles),
PixelFx::Crystallize { cell } => pixelate::crystallize(px, w, h, space, cell),
@@ -742,3 +907,7 @@ pub fn gaussian_rgba(data: &mut [u8], w: usize, h: usize, sigma: f64) {
#[cfg(test)]
mod tests;
+#[cfg(test)]
+mod tests_paint;
+#[cfg(test)]
+mod tests_sketch;
diff --git a/crates/effects/src/pixel/paint.rs b/crates/effects/src/pixel/paint.rs
new file mode 100644
index 0000000000..a078fb9f98
--- /dev/null
+++ b/crates/effects/src/pixel/paint.rs
@@ -0,0 +1,173 @@
+//! Effect › Artistic › Smudge Stick, Sponge and Watercolor. Original filters built from public
+//! behaviour documentation: and
+//! (Smudge Stick smudges the
+//! dark areas with short diagonal strokes and brightens the light ones, Sponge paints highly
+//! textured areas of contrasting colour, Watercolor simplifies detail with a medium brush loaded
+//! with water and saturates the colour where tones change at edges). Visual approximations, not
+//! reproductions of a proprietary algorithm; the ranges and defaults are chosen for VectorCraft.
+//!
+//! All three keep the object's coverage, so they paint nothing outside it. Their patterns lie in
+//! document space around the object's centre, as the Brush Strokes' and Texture filters' do.
+
+use super::blur;
+use super::brushstrokes::{MARGIN, RIGHT, Smear, TONE_SOFTNESS, edges, mix, ramp, streak, stroke_reach, unpremultiply};
+use super::pixelate::Place;
+use super::texture::{Tones, luma, premultiply, smooth_noise, straight};
+use super::{PixelSpace, Px16, gaussian, to16};
+
+const SALT_SMUDGE: u64 = 320;
+const SALT_SPONGE: u64 = 328;
+const SALT_WATER: u64 = 336;
+
+/// The length (points) of Smudge Stick's short strokes for Stroke Length `stroke` (0..10); the
+/// light areas are smudged with strokes twice as long.
+fn smudge_length(stroke: f64) -> f64 {
+ 1.0 + 1.5 * stroke.clamp(0.0, 10.0)
+}
+
+/// How far (document units) Smudge Stick reaches for Stroke Length `stroke`: its strokes and the
+/// softened tones that choose them.
+pub(super) fn smudge_reach(stroke: f64) -> f64 {
+ stroke_reach(2.0 * smudge_length(stroke)).max(3.0 * TONE_SOFTNESS + MARGIN)
+}
+
+/// The σ (points) Sponge softens the object by, for Brush Size `brush` (0..10) and Smoothness
+/// `smoothness` (1..15).
+fn sponge_softness(brush: f64, smoothness: f64) -> f64 {
+ (0.15 + 0.04 * smoothness.clamp(1.0, 15.0)) * sponge_pore(brush)
+}
+
+/// The size (points) of Sponge's pores for Brush Size `brush` (0..10).
+fn sponge_pore(brush: f64) -> f64 {
+ 2.0 + 1.5 * brush.clamp(0.0, 10.0)
+}
+
+/// How far (document units) Sponge reaches: the softened colours around a pixel.
+pub(super) fn sponge_reach(brush: f64, smoothness: f64) -> f64 {
+ 3.0 * sponge_softness(brush, smoothness) + MARGIN
+}
+
+/// The radius (points) of the brush that simplifies detail for Brush Detail `detail` (1..14): the
+/// less detail, the wider the brush.
+fn water_brush(detail: f64) -> f64 {
+ 0.5 * (15.0 - detail.clamp(1.0, 14.0))
+}
+
+/// The σ (points) of the softening that finds Watercolor's edges.
+const WATER_EDGE: f64 = 0.6;
+
+/// How far (document units) Watercolor reaches for Brush Detail `detail`.
+pub(super) fn watercolor_reach(detail: f64) -> f64 {
+ water_brush(detail) + 3.0 * WATER_EDGE + MARGIN
+}
+
+/// Smudge Stick: the dark areas smudged along short diagonal strokes `stroke` (0..10) long, the
+/// light areas smudged with longer strokes and lightened towards white as strongly as `intensity`
+/// (0..10) says, so they lose their detail; `highlight` (0..20) widens the area counted as light.
+pub(super) fn smudge_stick(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, stroke: f64, highlight: f64, intensity: f64) {
+ if ![stroke, highlight, intensity].iter().all(|v| v.is_finite()) {
+ return;
+ }
+ let Some(place) = Place::new(space, w, h) else { return };
+ let len = smudge_length(stroke);
+ let (short, long) = (Smear::new(px, w, h, &place, len), Smear::new(px, w, h, &place, 2.0 * len));
+ let tones = Tones::new(px, w, h, TONE_SOFTNESS / place.px);
+ // Tones above the threshold count as light; a wider highlight area lowers it.
+ let threshold = 0.9 - 0.5 * (highlight / 20.0).clamp(0.0, 1.0);
+ let lift = (0.7 * intensity / 10.0).clamp(0.0, 0.7) as f32;
+ let row = (0.25 * len).max(1.0);
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ let q = place.at(x, y);
+ let own = straight(*p);
+ let paint = |smear: &Smear, salt: u64| {
+ let (c, a) = unpremultiply(smear.stroke(salt, q, RIGHT, row));
+ if a > 0.0 { c } else { own }
+ };
+ // Bristle marks along the dark strokes.
+ let bristle = (1.0 + 0.08 * streak(SALT_SMUDGE + 2, q, RIGHT, len, 0.5)) as f32;
+ let dark = paint(&short, SALT_SMUDGE).map(|v| v * bristle);
+ let light = paint(&long, SALT_SMUDGE + 1);
+ let t = ramp((tones.get(x, y) - threshold) / 0.2 + 0.5) as f32;
+ let bright = light.map(|v| v + (1.0 - v) * lift);
+ *p = premultiply(mix(dark, bright, t), f32::from(p[3]) / 255.0);
+ });
+}
+
+/// Sponge: the object as if dabbed with a sponge, soft blobs of lighter and darker colour about
+/// `brush` (0..10) large; `definition` (0..25) sets how strongly they contrast and `smoothness`
+/// (1..15) how soft their edges are.
+pub(super) fn sponge(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, brush: f64, definition: f64, smoothness: f64) {
+ if ![brush, definition, smoothness].iter().all(|v| v.is_finite()) {
+ return;
+ }
+ let Some(place) = Place::new(space, w, h) else { return };
+ let mut soft: Vec = to16(px);
+ gaussian(&mut soft, w, sponge_softness(brush, smoothness) / place.px);
+ let pore = sponge_pore(brush);
+ let edge = 0.12 + 0.03 * smoothness.clamp(1.0, 15.0);
+ let amount = (definition / 25.0).clamp(0.0, 1.0);
+ let gain = 1.0 + 1.2 * amount;
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ let alpha = f32::from(p[3]) / 255.0;
+ let own = straight(*p);
+ let (c, a) = unpremultiply(soft.get(y * w + x).map_or([0.0; 4], |s| s.map(|v| f32::from(v) / 65535.0)));
+ let c = if a > 0.0 { c } else { own };
+ let q = place.at(x, y);
+ let n = 0.65 * smooth_noise(SALT_SPONGE, q, pore) + 0.35 * smooth_noise(SALT_SPONGE + 1, q, 0.45 * pore);
+ // -1 inside a dark pore, 1 on a light bridge between pores.
+ let blob = 2.0 * ramp(0.5 + n / (2.0 * edge)) - 1.0;
+ let l = f64::from(luma(c));
+ let target = (0.5 + (l + 0.55 * amount * blob - 0.5) * gain).clamp(0.0, 1.0);
+ // Darker towards black, lighter towards white: the hue stays.
+ let out = if target <= l {
+ let k = if l > 1e-3 { (target / l) as f32 } else { 0.0 };
+ c.map(|v| v * k)
+ } else {
+ let k = ((target - l) / (1.0 - l).max(1e-3)).clamp(0.0, 1.0) as f32;
+ c.map(|v| v + (1.0 - v) * k)
+ };
+ *p = premultiply(out, alpha);
+ });
+}
+
+/// Watercolor: the object's detail simplified by a brush whose size `detail` (1..14) sets (the
+/// larger, the more detail stays), the colour saturated and its pigment pooled where tones change
+/// at edges, the shadows deepened as strongly as `shadow` (0..10) says, and `texture` (1..3)
+/// grains of paper showing through.
+pub(super) fn watercolor(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, detail: f64, shadow: f64, texture: u32) {
+ if ![detail, shadow].iter().all(|v| v.is_finite()) {
+ return;
+ }
+ let Some(place) = Place::new(space, w, h) else { return };
+ let coverage: Vec = px.iter().map(|p| p[3]).collect();
+ // Simplify: average within areas of similar colour, keeping the bolder edges; a coarser brush
+ // (less detail) also merges colours further apart.
+ blur::smart(px, w, h, water_brush(detail) / place.px, 20.0 + 6.0 * (14.0 - detail.clamp(1.0, 14.0)), 7);
+ let found = edges(px, w, h, &place, WATER_EDGE);
+ let shadow = shadow.clamp(0.0, 10.0);
+ let paper = 0.02 * f64::from(texture.clamp(1, 3));
+ let grain = 1.0 + 0.5 * f64::from(texture.clamp(1, 3));
+ place.each(px, |x, y, p| {
+ let alpha = coverage.get(y * w + x).copied().unwrap_or(0);
+ if alpha == 0 {
+ *p = [0; 4];
+ return;
+ }
+ let c = straight(*p);
+ let e = (2.0 * f64::from(found.get(y * w + x).copied().unwrap_or(0.0))).clamp(0.0, 1.0) as f32;
+ let l = luma(c);
+ // Saturated colour and darker pigment where the tones change.
+ let c = c.map(|v| (l + (v - l) * (1.0 + 0.9 * e)) * (1.0 - 0.12 * e));
+ let deep = ((1.0 - l / 0.5).clamp(0.0, 1.0) * 0.07 * shadow as f32).min(0.8);
+ let q = place.at(x, y);
+ let n = 0.6 * smooth_noise(SALT_WATER, q, grain) + 0.4 * smooth_noise(SALT_WATER + 1, q, 0.5 * grain);
+ let n = (paper * n) as f32;
+ *p = premultiply(c.map(|v| v * (1.0 - deep) + n), f32::from(alpha) / 255.0);
+ });
+}
diff --git a/crates/effects/src/pixel/sketch.rs b/crates/effects/src/pixel/sketch.rs
index 7f9f7cd040..9f04b12770 100644
--- a/crates/effects/src/pixel/sketch.rs
+++ b/crates/effects/src/pixel/sketch.rs
@@ -1,12 +1,42 @@
-//! Effect › Sketch › Halftone Pattern. Original filter built from public behaviour documentation:
+//! Effect › Sketch (Chalk & Charcoal, Chrome, Halftone Pattern, Note Paper, Plaster and Reticulation; Graphic Pen lives in
+//! [`super::brushstrokes`]). Original filters built from public behaviour documentation:
//! (Sketch effects redraw in
-//! black and white; Halftone Pattern simulates a halftone screen while keeping the range of tones)
-//! and (only Size depends on the raster
-//! resolution). A visual approximation, not a reproduction of a proprietary algorithm.
+//! black and white) and the public Photoshop Elements Artistic filters guide. Visual
+//! approximations, not proprietary reproductions.
-use super::pixelate::Place;
-use super::texture::{luma, premultiply, straight};
-use super::{PixelSpace, pick};
+use std::f64::consts::{FRAC_1_SQRT_2, TAU};
+
+use vectorcraft_geom::Vec2;
+
+use super::edges::sobel;
+use super::pixelate::{Place, cell, rand, value_noise};
+use super::texture::{Light, Tones, luma, premultiply, smooth_noise, straight};
+use super::{PixelSpace, blur_plane, pick};
+
+const SALT_CHALK: u64 = 216;
+const SALT_CHROME: u64 = 0xC40_4D45;
+const EDGE_SOFT: f64 = 0.8;
+const TONE_SOFT: f64 = 1.0;
+/// Light from the top left (document axes, y down), as on polished relief surfaces.
+const CHROME_LIGHT: Vec2 = Vec2::new(-FRAC_1_SQRT_2, -FRAC_1_SQRT_2);
+
+/// How far (document units) Chalk & Charcoal samples softened tones and edges.
+pub(super) const CHALK_CHARCOAL_REACH: f64 = 3.0 * TONE_SOFT + 1.0 + 3.0 * EDGE_SOFT;
+
+fn ramp(t: f64) -> f64 {
+ t.clamp(0.0, 1.0)
+}
+
+fn tone_edges(px: &[[u8; 4]], w: usize, h: usize, place: &Place, sigma: f64) -> Vec {
+ let mut tone: Vec = px.iter().map(|p| luma(straight(*p)) * f32::from(p[3]) / 255.0).collect();
+ let mut cover: Vec = px.iter().map(|p| f32::from(p[3]) / 255.0).collect();
+ let s = sigma / place.px;
+ blur_plane(&mut tone, w, h, s);
+ blur_plane(&mut cover, w, h, s);
+ let norm = (s.max(0.8) * TAU.sqrt() / 8.0) as f32;
+ let norm = if norm.is_finite() { norm } else { 0.0 };
+ sobel(&tone, w, h).iter().zip(sobel(&cover, w, h)).map(|(t, c)| t.max(c) * norm).collect()
+}
/// Halftone Pattern's screens, in its Pattern Type menu's order: (label, parameter value).
pub const HALFTONE_TYPES: [(&str, &str); 3] = [("Circle", "circle"), ("Dot", "dot"), ("Line", "line")];
@@ -69,3 +99,261 @@ pub(super) fn halftone_pattern(px: &mut [[u8; 4]], w: usize, h: usize, space: &P
*p = premultiply([(1.0 - ink) as f32; 3], f32::from(p[3]) / 255.0);
});
}
+
+/// Note Paper: the object embossed on fibrous paper. `balance` (0..50) shifts tones toward
+/// highlights or shadows around the middle; `graininess` (0..10) adds paper fibre; `relief`
+/// (0..50, points) is how strongly the tones stand out in the light. Coverage is kept.
+pub(super) fn note_paper(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, balance: f64, graininess: f64, relief: f64) {
+ if !(balance.is_finite() && graininess.is_finite() && relief.is_finite()) {
+ return;
+ }
+ let Some(place) = Place::new(space, w, h) else { return };
+ let height: Vec = px
+ .iter()
+ .map(|p| {
+ if p[3] == 0 {
+ 0.0
+ } else {
+ let mut l = f64::from(luma(straight(*p)));
+ l += (balance - 25.0) / 125.0;
+ l.clamp(0.0, 1.0) as f32
+ }
+ })
+ .collect();
+ let sample = |x: i32, y: i32| -> f32 {
+ if x < 0 || y < 0 || x >= w as i32 || y >= h as i32 {
+ return 0.0;
+ }
+ height.get(y as usize * w + x as usize).copied().unwrap_or(0.0)
+ };
+ let emboss = relief / 50.0;
+ let grain = graininess / 10.0;
+ let light = (-0.6_f64, -0.6, 0.8);
+ let ln = (light.0 * light.0 + light.1 * light.1 + light.2 * light.2).sqrt().max(1e-9);
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ let xi = x as i32;
+ let yi = y as i32;
+ let h0 = height.get(y * w + x).copied().unwrap_or(0.0);
+ let dx = (sample(xi + 1, yi) - sample(xi - 1, yi)) as f64;
+ let dy = (sample(xi, yi + 1) - sample(xi, yi - 1)) as f64;
+ let dz = emboss * 0.12;
+ let nx = -dx;
+ let ny = -dy;
+ let nz = dz;
+ let nn = (nx * nx + ny * ny + nz * nz).sqrt().max(1e-9);
+ let shade = ((nx * light.0 + ny * light.1 + nz * light.2) / (nn * ln) * 0.5 + 0.5).clamp(0.0, 1.0);
+ let tone = (0.35 + 0.65 * f64::from(h0)) * shade;
+ let q = place.at(x, y);
+ let fibre = if grain > 0.0 { value_noise(0x4e4f_5450, q.x * 0.35, q.y * 0.35) * grain * 0.18 } else { 0.0 };
+ let v = (tone + fibre).clamp(0.0, 1.0) as f32;
+ *p = premultiply([v; 3], f32::from(p[3]) / 255.0);
+ });
+}
+
+/// Chalk & Charcoal: light areas get chalky highlights and dark areas charcoal strokes and grain;
+/// `chalk` and `charcoal` (0..20) set how strongly, `pressure` (0..5) the stroke weight. Black
+/// chalk and charcoal on white paper, coverage kept.
+pub(super) fn chalk_charcoal(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, chalk: f64, charcoal: f64, pressure: f64) {
+ if !(chalk.is_finite() && charcoal.is_finite() && pressure.is_finite()) {
+ return;
+ }
+ let scale = (pressure.clamp(0.0, 5.0) / 5.0).clamp(0.0, 1.0);
+ let chalk_amt = (0.05 * chalk.clamp(0.0, 20.0) * scale).clamp(0.0, 1.0);
+ let charcoal_amt = (0.05 * charcoal.clamp(0.0, 20.0) * scale).clamp(0.0, 1.0);
+ if chalk_amt <= 0.0 && charcoal_amt <= 0.0 {
+ return;
+ }
+ let Some(place) = Place::new(space, w, h) else { return };
+ let tones = Tones::new(px, w, h, TONE_SOFT / place.px);
+ let edges = tone_edges(px, w, h, &place, EDGE_SOFT);
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ let q = place.at(x, y);
+ let tone = tones.get(x, y);
+ let dark = (1.0 - tone).clamp(0.0, 1.0);
+ let light = tone.clamp(0.0, 1.0);
+ let edge = f64::from(edges.get(y * w + x).copied().unwrap_or(0.0));
+ let charcoal_stroke = value_noise(SALT_CHALK + 1, q.x * 1.1, q.y * 0.12);
+ let charcoal_grain = value_noise(SALT_CHALK, q.x * 0.35, q.y * 0.35);
+ let charcoal_mask = ramp((dark - 0.3) / 0.22)
+ * charcoal_amt
+ * (0.35 + 0.65 * edge)
+ * (0.45 + 0.55 * ramp(charcoal_stroke * 2.2 - 0.55))
+ * (0.6 + 0.4 * charcoal_grain);
+ let chalk_grain = value_noise(SALT_CHALK + 2, q.x * 0.45 + 7.0, q.y * 0.45);
+ let chalk_mask = ramp((light - 0.5) / 0.22) * chalk_amt * (0.55 + 0.45 * chalk_grain);
+ let down = (0.9 * charcoal_mask).clamp(0.0, 1.0) as f32;
+ let up = (0.8 * chalk_mask).clamp(0.0, 1.0) as f32;
+ let mut grey = luma(straight(*p));
+ grey *= 1.0 - down;
+ grey += (1.0 - grey) * up;
+ *p = premultiply([grey, grey, grey], f32::from(p[3]) / 255.0);
+ });
+}
+
+/// How far (document units) Chrome reaches for `smoothness` (0..10): 3 σ of the height-field blur
+/// plus the Sobel neighbours.
+pub(super) fn chrome_reach(smoothness: f64) -> f64 {
+ let smoothness = smoothness.clamp(0.0, 10.0);
+ 3.0 * (0.4 + 0.55 * smoothness) + 1.0
+}
+
+/// Chrome: the object as a polished chrome surface lit from the top left. `detail` (0..10) adds
+/// finer relief; `smoothness` (0..10) softens the height field before the highlights and shadows
+/// are drawn. Coverage is kept.
+pub(super) fn chrome(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, detail: f64, smoothness: f64) {
+ if w == 0 || h == 0 {
+ return;
+ }
+ let detail = detail.clamp(0.0, 10.0);
+ let smoothness = smoothness.clamp(0.0, 10.0);
+ let Some(place) = Place::new(space, w, h) else { return };
+ let sigma = (0.4 + smoothness * 0.55) / place.px.max(1e-9);
+ let cell = (14.0 - detail * 1.2).max(1.5);
+ let bump = (detail / 10.0) * 0.4;
+ let strength = 2.5 + detail * 0.35;
+ let mut height: Vec = Vec::with_capacity(w * h);
+ let mut alpha: Vec = Vec::with_capacity(w * h);
+ for y in 0..h {
+ for x in 0..w {
+ let p = px[y * w + x];
+ let a = f32::from(p[3]) / 255.0;
+ alpha.push(a);
+ if a <= 0.0 {
+ height.push(0.0);
+ continue;
+ }
+ let q = place.at(x, y);
+ let base = f64::from(luma(straight(p)));
+ let n = if bump > 0.0 { bump * smooth_noise(SALT_CHROME, q, cell) } else { 0.0 };
+ height.push((base + n).clamp(0.0, 1.0) as f32);
+ }
+ }
+ blur_plane(&mut height, w, h, sigma);
+ blur_plane(&mut alpha, w, h, sigma);
+ let tone: Vec = height.iter().zip(&alpha).map(|(h, a)| if *a > 1e-4 { f64::from(*h / *a).clamp(0.0, 1.0) } else { 0.0 }).collect();
+ let px_unit = place.px.max(1e-9);
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ let at = |dx: isize, dy: isize| {
+ let (xx, yy) = ((x as isize + dx).clamp(0, w as isize - 1) as usize, (y as isize + dy).clamp(0, h as isize - 1) as usize);
+ tone[yy * w + xx]
+ };
+ let h0 = tone[y * w + x];
+ let gx = 0.5 * (at(1, 0) - at(-1, 0)) / px_unit;
+ let gy = 0.5 * (at(0, 1) - at(0, -1)) / px_unit;
+ let face = -(gx * CHROME_LIGHT.x + gy * CHROME_LIGHT.y);
+ let spec = (face * strength + (h0 - 0.5) * 1.5).tanh();
+ let grey = (0.5 + 0.5 * spec).clamp(0.0, 1.0);
+ *p = premultiply([grey as f32; 3], f32::from(p[3]) / 255.0);
+ });
+}
+
+/// Colour `c` lit by `s`: darkened towards black below 0, lightened towards white above.
+fn lit(c: [f32; 3], s: f64) -> [f32; 3] {
+ let s = if s.is_finite() { s.clamp(-1.0, 1.0) as f32 } else { 0.0 };
+ c.map(|v| if s < 0.0 { v * (1.0 + s) } else { v + (1.0 - v) * s })
+}
+
+/// How a surface whose height rises along `slope` faces a light from `toward`.
+fn facing(slope: Vec2, toward: Vec2) -> f64 {
+ -slope.dot(toward)
+}
+
+/// The σ (document units) of Plaster's height blur at `smoothness` (1..15).
+fn plaster_sigma_pt(smoothness: f64) -> f64 {
+ let smoothness = smoothness.clamp(1.0, 15.0);
+ 0.15 + 0.85 * (smoothness - 1.0) / 14.0
+}
+
+/// How far (document units) Plaster's softened relief reaches at `smoothness` (1..15).
+pub(super) fn plaster_reach(smoothness: f64) -> f64 {
+ if !smoothness.is_finite() {
+ return 3.0 * plaster_sigma_pt(8.0) + 0.5;
+ }
+ 3.0 * plaster_sigma_pt(smoothness) + 0.5
+}
+
+/// Plaster: the object molded in relief plaster and lit from `light`. Dark areas are raised and
+/// light areas recessed; `imageBalance` (1..50) shifts more of the image lower at higher values;
+/// `smoothness` (1..15) softens the relief. Coverage is kept.
+pub(super) fn plaster(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, image_balance: f64, smoothness: f64, light: Light) {
+ if !(image_balance.is_finite() && smoothness.is_finite() && space.px.is_finite() && space.px > 0.0)
+ || w == 0
+ || h == 0
+ || w.checked_mul(h) != Some(px.len())
+ {
+ return;
+ }
+ let image_balance = image_balance.clamp(1.0, 50.0);
+ let smoothness = smoothness.clamp(1.0, 15.0);
+ let bias = (image_balance - 1.0) / 49.0;
+ let mut height: Vec = px
+ .iter()
+ .map(|p| {
+ let a = f32::from(p[3]) / 255.0;
+ let dark = (1.0 - luma(straight(*p))) * a;
+ (dark - bias as f32 * 0.65).clamp(0.0, 1.0)
+ })
+ .collect();
+ blur_plane(&mut height, w, h, plaster_sigma_pt(smoothness) / space.px);
+ let Some(place) = Place::new(space, w, h) else { return };
+ let step = (0.35f64).max(0.5 * place.px);
+ let strength = 0.55;
+ let toward = light.toward();
+ let at = |x: usize, y: usize, dx: i32, dy: i32| {
+ let (xx, yy) = ((x as i32 + dx).clamp(0, w as i32 - 1) as usize, (y as i32 + dy).clamp(0, h as i32 - 1) as usize);
+ height[yy * w + xx]
+ };
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ let h = height[y * w + x];
+ let (left, right, up, down) = (at(x, y, -1, 0), at(x, y, 1, 0), at(x, y, 0, -1), at(x, y, 0, 1));
+ let slope = Vec2::new(f64::from(right - left), f64::from(down - up)) / (2.0 * step);
+ let ridge = f64::from(h - 0.25 * (left + right + up + down)) / step;
+ let shade = strength * (facing(slope, toward) + ridge);
+ *p = premultiply(lit(straight(*p), shade), f32::from(p[3]) / 255.0);
+ });
+}
+
+/// Reticulation: the object redrawn in black ink on white paper through a high-contrast film-grain
+/// screen. `density` (0..50) sets how fine the grain is; `foreground` and `background` (0..50 each)
+/// pull shadows toward black and highlights toward white before the grain decides ink. Coverage is
+/// kept.
+pub(super) fn reticulation(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, density: f64, foreground: f64, background: f64) {
+ if !(density.is_finite() && foreground.is_finite() && background.is_finite()) {
+ return;
+ }
+ let Some(place) = Place::new(space, w, h) else { return };
+ // Finer grain at higher density: cells from about 11 pt down to 1 pt.
+ let cell_size = 1.0 + (50.0 - density.clamp(0.0, 50.0)) * 0.2;
+ let fg = foreground.clamp(0.0, 50.0) / 50.0;
+ let bg = background.clamp(0.0, 50.0) / 50.0;
+ let spread = 0.12 + 0.38 * (density.clamp(0.0, 50.0) / 50.0);
+ const SALT: u64 = 0x5245_7469;
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ let q = place.at(x, y);
+ let dark = f64::from(1.0 - luma(straight(*p))).clamp(0.0, 1.0);
+ let tone = (dark + fg * (1.0 - dark) * 0.65 - bg * dark * 0.65).clamp(0.0, 1.0);
+ let coarse = value_noise(SALT, q.x / cell_size, q.y / cell_size);
+ let fine = match (cell(q.x), cell(q.y)) {
+ (Some(i), Some(j)) => rand(SALT + 1, i, j, 2),
+ _ => 0.5,
+ };
+ let grain = 0.55 * coarse + 0.45 * fine;
+ let ink = if tone + (grain - 0.5) * spread > 0.5 { 1.0 } else { 0.0 };
+ *p = premultiply([(1.0 - ink) as f32; 3], f32::from(p[3]) / 255.0);
+ });
+}
diff --git a/crates/effects/src/pixel/sketch_ink.rs b/crates/effects/src/pixel/sketch_ink.rs
new file mode 100644
index 0000000000..2bd626e408
--- /dev/null
+++ b/crates/effects/src/pixel/sketch_ink.rs
@@ -0,0 +1,209 @@
+//! Effect › Sketch › Bas Relief, Charcoal, Photocopy and Stamp. Original filters built from public
+//! behaviour documentation: and
+//! (the Sketch effects
+//! redraw the object in the foreground and background colours, black on white here; Bas Relief
+//! carves low relief lit from a direction, Charcoal draws bold edges and sketches the midtones in
+//! diagonal strokes, Photocopy copies only the edges of large dark areas and takes the midtones to
+//! black or white, Stamp simplifies the image to solid black and white as a rubber stamp would).
+//! Visual approximations, not reproductions of a proprietary algorithm; the ranges and defaults
+//! are chosen for VectorCraft.
+//!
+//! All four keep the object's coverage, so they paint nothing outside it. Their sizes are in
+//! document points, whatever the raster's resolution.
+
+use std::f64::consts::FRAC_1_SQRT_2;
+
+use super::pixelate::{Place, cell, value_noise};
+use super::texture::{Light, Tones, premultiply};
+use super::{PixelSpace, blur_plane};
+
+const SALT_STROKES: u64 = 440;
+
+/// A pixel's size (points) at 72 ppi: how far the neighbours of a gradient add to a filter's reach.
+const MARGIN: f64 = 1.0;
+
+/// Redraw `p` as ink `ink` (0..1) of black on white paper, keeping its coverage.
+fn paint(p: &mut [u8; 4], ink: f64) {
+ let v = if ink.is_finite() { (1.0 - ink).clamp(0.0, 1.0) as f32 } else { 1.0 };
+ *p = premultiply([v; 3], f32::from(p[3]) / 255.0);
+}
+
+/// A smooth step from 0 at `t` ≤ 0 to 1 at `t` ≥ 1 (0 when `t` is not a number).
+fn ramp(t: f64) -> f64 {
+ let t = if t.is_finite() { t.clamp(0.0, 1.0) } else { 0.0 };
+ t * t * (3.0 - 2.0 * t)
+}
+
+/// The tone at (`x`, `y`) and its gradient per pixel, from central differences.
+fn gradient(tones: &Tones, x: usize, y: usize) -> (f64, f64, f64) {
+ let gx = 0.5 * (tones.get(x + 1, y) - tones.get(x.saturating_sub(1), y));
+ let gy = 0.5 * (tones.get(x, y + 1) - tones.get(x, y.saturating_sub(1)));
+ (tones.get(x, y), gx, gy)
+}
+
+/// The σ (points) Bas Relief softens the object by, for Detail `detail` (1..15) and Smoothness
+/// `smoothness` (1..15).
+fn relief_softness(detail: f64, smoothness: f64) -> f64 {
+ 0.2 + 0.15 * smoothness.clamp(1.0, 15.0) + 0.1 * (15.0 - detail.clamp(1.0, 15.0))
+}
+
+/// How far (document units) Bas Relief reaches: the softened tones and their neighbours.
+pub(super) fn relief_reach(detail: f64, smoothness: f64) -> f64 {
+ 3.0 * relief_softness(detail, smoothness) + MARGIN
+}
+
+/// Bas Relief: the object carved in low relief and lit from `light`. Surfaces facing the light turn
+/// white, those turned away black, flat areas grey with a hint of the object's own tones; `detail`
+/// (1..15) keeps finer features and `smoothness` (1..15) rounds the carving.
+pub(super) fn bas_relief(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, detail: f64, smoothness: f64, light: Light) {
+ if !(detail.is_finite() && smoothness.is_finite()) {
+ return;
+ }
+ let Some(place) = Place::new(space, w, h) else { return };
+ let sigma = relief_softness(detail, smoothness);
+ let tones = Tones::new(px, w, h, sigma / place.px);
+ let toward = light.toward();
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ let (tone, slope) = tones.slope(x, y, &place);
+ // A step from black to white, softened by σ, rises 0.4 per σ at its steepest.
+ let lit = -slope.dot(toward) * sigma;
+ paint(p, 1.0 - (0.5 + 0.2 * (tone - 0.5) + 2.5 * lit));
+ });
+}
+
+/// The σ (points) Charcoal softens the object by to find its edges, for Detail `detail` (0..5).
+fn charcoal_softness(detail: f64) -> f64 {
+ 0.25 + 0.25 * (5.0 - detail.clamp(0.0, 5.0)) + 0.25
+}
+
+/// The σ (points) that thickens Charcoal's edges, for Thickness `thickness` (1..7).
+fn charcoal_thickening(thickness: f64) -> f64 {
+ 0.35 * thickness.clamp(1.0, 7.0)
+}
+
+/// The distance (points) between the strokes sketching Charcoal's midtones.
+fn charcoal_spacing(thickness: f64) -> f64 {
+ 1.5 + 0.5 * thickness.clamp(1.0, 7.0)
+}
+
+/// How far (document units) Charcoal reaches: the edges, their thickening and the strokes' tones.
+pub(super) fn charcoal_reach(thickness: f64, detail: f64) -> f64 {
+ (3.0 * (charcoal_softness(detail) + charcoal_thickening(thickness)) + 2.0 * MARGIN).max(2.0 * charcoal_spacing(thickness) + MARGIN)
+}
+
+/// Charcoal: bold, `thickness` (1..7) wide edges, as fine as `detail` (0..5) says, and the
+/// midtones sketched in diagonal strokes; `balance` (0..100) sets how far into the lights the
+/// charcoal reaches (50 is even).
+pub(super) fn charcoal(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, thickness: f64, detail: f64, balance: f64) {
+ if !(thickness.is_finite() && detail.is_finite() && balance.is_finite()) {
+ return;
+ }
+ let Some(place) = Place::new(space, w, h) else { return };
+ let sigma = charcoal_softness(detail);
+ let spacing = charcoal_spacing(thickness);
+ let bias = (balance.clamp(0.0, 100.0) - 50.0) / 100.0 * 0.8;
+ // The edges: how much the softened tones change across σ, 1 for a step from black to white.
+ let edge_tones = Tones::new(px, w, h, sigma / place.px);
+ let mut edge: Vec = (0..w * h)
+ .map(|k| {
+ let (_, gx, gy) = gradient(&edge_tones, k % w, k / w);
+ let contrast = gx.hypot(gy) / place.px * sigma / 0.4;
+ let weakest = 0.35 - 0.2 * bias / 0.4;
+ ramp((contrast - weakest) / 0.3) as f32
+ })
+ .collect();
+ blur_plane(&mut edge, w, h, charcoal_thickening(thickness) / place.px);
+ // The strokes' tones are softer than the edges', so the strokes don't follow every speck.
+ let tones = Tones::new(px, w, h, 0.5 * spacing / place.px);
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ let bold = edge.get(y * w + x).map_or(0.0, |e| ((f64::from(*e) - 0.3) / 0.3).clamp(0.0, 1.0));
+ let dark = 1.0 - tones.get(x, y);
+ let share = ((dark + bias - 0.2) / 0.6).clamp(0.0, 1.0);
+ let q = place.at(x, y);
+ // Across the strokes, which run rising to the right, and along them.
+ let (across, along) = ((q.x + q.y) * FRAC_1_SQRT_2 / spacing, (q.x - q.y) * FRAC_1_SQRT_2 / spacing);
+ let stroke = match (share > 0.0, cell(across)) {
+ (true, Some(line)) => {
+ let f = across - line as f64;
+ // Each stroke breaks and swells along its length.
+ let swell = (0.6 + 0.8 * value_noise(SALT_STROKES, along / 6.0, line as f64)).clamp(0.0, 1.2);
+ let reach = (share * swell).min(1.0);
+ let soft = 2.0 * place.px / spacing;
+ (((reach - (2.0 * f - 1.0).abs()) / soft + 0.5).clamp(0.0, 1.0)) * f64::from(reach > 0.0)
+ }
+ _ => 0.0,
+ };
+ paint(p, bold.max(stroke));
+ });
+}
+
+/// The σ (points) of Photocopy's narrow softening for Detail `detail` (1..24): the less detail,
+/// the wider.
+fn copy_softness(detail: f64) -> f64 {
+ 0.15 * (25.0 - detail.clamp(1.0, 24.0))
+}
+
+/// How much wider Photocopy's second softening is than its first.
+const COPY_WIDER: f64 = 3.0;
+
+/// How far (document units) Photocopy reaches: the wide softening.
+pub(super) fn copy_reach(detail: f64) -> f64 {
+ 3.0 * COPY_WIDER * copy_softness(detail) + MARGIN
+}
+
+/// Photocopy: black where a pixel is darker than its surroundings, white elsewhere. Large dark
+/// areas copy only around their edges and midtones go to black or white. `detail` (1..24) keeps
+/// finer features and `darkness` (1..50) copies more of the dark.
+pub(super) fn photocopy(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, detail: f64, darkness: f64) {
+ if !(detail.is_finite() && darkness.is_finite()) {
+ return;
+ }
+ let Some(place) = Place::new(space, w, h) else { return };
+ let sigma = copy_softness(detail) / place.px;
+ let narrow = Tones::new(px, w, h, sigma);
+ let wide = Tones::new(px, w, h, COPY_WIDER * sigma);
+ // How much darker than its surroundings a pixel must be to print.
+ let threshold = 0.02 + 0.10 * (1.0 - (darkness.clamp(1.0, 50.0) - 1.0) / 49.0);
+ let soft = 0.02;
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ paint(p, ((wide.get(x, y) - narrow.get(x, y) - threshold) / soft + 0.5).clamp(0.0, 1.0));
+ });
+}
+
+/// The σ (points) Stamp softens the object by for Smoothness `smoothness` (1..50).
+fn stamp_softness(smoothness: f64) -> f64 {
+ 0.1 * smoothness.clamp(1.0, 50.0)
+}
+
+/// How far (document units) Stamp reaches: the softened tones and their neighbours.
+pub(super) fn stamp_reach(smoothness: f64) -> f64 {
+ 3.0 * stamp_softness(smoothness) + MARGIN
+}
+
+/// Stamp: the object as solid black and white, like a rubber stamp. `balance` (0..50) sets how much
+/// of the object prints black and `smoothness` (1..50) rounds the shapes.
+pub(super) fn stamp(px: &mut [[u8; 4]], w: usize, h: usize, space: &PixelSpace, balance: f64, smoothness: f64) {
+ if !(balance.is_finite() && smoothness.is_finite()) {
+ return;
+ }
+ let Some(place) = Place::new(space, w, h) else { return };
+ let tones = Tones::new(px, w, h, stamp_softness(smoothness) / place.px);
+ let threshold = 0.2 + 0.6 * balance.clamp(0.0, 50.0) / 50.0;
+ place.each(px, |x, y, p| {
+ if p[3] == 0 {
+ return;
+ }
+ let (tone, gx, gy) = gradient(&tones, x, y);
+ // A one pixel wide edge, whatever the softening.
+ paint(p, ((threshold - tone) / gx.hypot(gy).max(0.01) + 0.5).clamp(0.0, 1.0));
+ });
+}
diff --git a/crates/effects/src/pixel/tests.rs b/crates/effects/src/pixel/tests.rs
index 361c507332..7d45556c5f 100644
--- a/crates/effects/src/pixel/tests.rs
+++ b/crates/effects/src/pixel/tests.rs
@@ -1998,6 +1998,47 @@ fn brush_strokes_follow_the_object_at_any_resolution() {
}
}
+/// Chalk & Charcoal of `p` over `w` × `h` pixels of `src`, laid out by `s`.
+fn chalk_charcoal(p: serde_json::Value, src: &[u8], w: usize, h: usize, s: &PixelSpace) -> Vec {
+ let mut out = src.to_vec();
+ fx("sketch.chalkCharcoal", p).apply(&mut out, w, h, s);
+ out
+}
+
+#[test]
+fn chalk_charcoal_params_take_defaults_and_stay_in_range() {
+ assert_eq!(fx("sketch.chalkCharcoal", json!({})), PixelFx::ChalkCharcoal { chalk: 6.0, charcoal: 6.0, pressure: 2.0 });
+ assert_eq!(
+ fx("sketch.chalkCharcoal", json!({"chalkArea": 1e9, "charcoalArea": -2, "strokePressure": 99})),
+ PixelFx::ChalkCharcoal { chalk: 20.0, charcoal: 0.0, pressure: 5.0 }
+ );
+ let doc = crate::effect_info("sketch.chalkCharcoal").unwrap().params;
+ assert!(doc.contains("chalkArea") && doc.contains("charcoalArea") && doc.contains("strokePressure"), "{doc}");
+ let f = fx("sketch.chalkCharcoal", json!({"strokePressure": 5}));
+ assert_eq!(f.outset(Rect::new(0.0, 0.0, 100.0, 50.0)), 0.0);
+ assert!(f.reach().unwrap() > 0.0);
+}
+
+#[test]
+fn chalk_charcoal_draws_in_black_and_white_only() {
+ let (w, h) = (48, 48);
+ let src = image(w, h, |x, y| {
+ let c = [[230u8, 20, 20], [20, 200, 40], [30, 60, 220], [240, 220, 30]][(x / 12) % 4];
+ let a: u16 = if y < 24 { 255 } else { 128 };
+ [c[0], c[1], c[2]].map(|v| (u16::from(v) * a / 255) as u8).into_iter().chain([a as u8]).collect::>().try_into().unwrap()
+ });
+ let out = chalk_charcoal(json!({"chalkArea": 12, "charcoalArea": 12, "strokePressure": 4}), &src, w, h, &space(w, h));
+ for (p, q) in out.as_chunks::<4>().0.iter().zip(src.as_chunks::<4>().0) {
+ assert_eq!(p[3], q[3], "coverage kept");
+ if p[3] == 0 {
+ continue;
+ }
+ assert_eq!(p[0], p[1]);
+ assert_eq!(p[1], p[2]);
+ }
+ assert_ne!(out, src);
+}
+
/// Halftone Pattern of `p` over `w` × `h` pixels of `src`, laid out by `s`.
fn halftone(p: serde_json::Value, src: &[u8], w: usize, h: usize, s: &PixelSpace) -> Vec {
let mut out = src.to_vec();
@@ -2010,6 +2051,38 @@ fn period(values: &[u8]) -> usize {
(1..values.len()).find(|p| values.iter().zip(&values[*p..]).all(|(a, b)| a == b)).unwrap_or(values.len())
}
+#[test]
+fn graphic_pen_params_take_defaults_and_stay_in_range() {
+ use super::STROKE_DIRECTIONS;
+ assert_eq!(fx("sketch.graphicPen", json!({})), PixelFx::GraphicPen { length: 5.0, balance: 50.0, direction: StrokeDirection::RightDiagonal });
+ assert_eq!(
+ fx("sketch.graphicPen", json!({"strokeLength": 0, "lightDarkBalance": 200, "strokeDirection": "VERTICAL"})),
+ PixelFx::GraphicPen { length: 1.0, balance: 100.0, direction: StrokeDirection::Vertical }
+ );
+ let doc = crate::effect_info("sketch.graphicPen").unwrap().params;
+ assert!(STROKE_DIRECTIONS.iter().all(|(_, v)| doc.contains(&format!("\"{v}\""))), "{doc}");
+ let f = fx("sketch.graphicPen", json!({"strokeLength": 15}));
+ assert_eq!(f.outset(Rect::new(0.0, 0.0, 100.0, 50.0)), brushstrokes::stroke_reach(15.0));
+ assert_eq!(f.reach(), Some(brushstrokes::stroke_reach(15.0).max(brushstrokes::TONE_REACH)));
+ assert_eq!(
+ fx("sketch.graphicPen", json!({"strokeLength": 99})),
+ PixelFx::GraphicPen { length: 15.0, balance: 50.0, direction: StrokeDirection::RightDiagonal }
+ );
+}
+
+/// Graphic Pen on a mid-grey field draws both black ink and white paper.
+#[test]
+fn graphic_pen_draws_ink_and_paper_on_grey() {
+ let (w, h) = (48, 48);
+ let src = image(w, h, |_, _| grey(32));
+ let mut out = src.clone();
+ fx("sketch.graphicPen", json!({"strokeLength": 4, "lightDarkBalance": 50})).apply(&mut out, w, h, &space(w, h));
+ let lumas: Vec = out.as_chunks::<4>().0.iter().map(|p| p[0]).collect();
+ let (min, max) = lumas.iter().fold((255u8, 0u8), |(lo, hi), l| (lo.min(*l), hi.max(*l)));
+ assert!(min < 80 && max > 200, "min {min} max {max}");
+ assert_ne!(out, src, "the filter should change the raster");
+}
+
#[test]
fn halftone_pattern_params_take_defaults_and_stay_in_range() {
assert_eq!(fx("sketch.halftonePattern", json!({})), PixelFx::HalftonePattern { size: 1.0, contrast: 5.0, kind: HalftonePattern::Dot });
@@ -2033,6 +2106,44 @@ fn halftone_pattern_params_take_defaults_and_stay_in_range() {
assert_eq!(f.reach(), Some(0.0));
}
+#[test]
+fn note_paper_params_take_defaults_and_stay_in_range() {
+ assert_eq!(fx("sketch.notePaper", json!({})), PixelFx::NotePaper { balance: 25.0, graininess: 0.0, relief: 4.0 });
+ assert_eq!(
+ fx("sketch.notePaper", json!({"imageBalance": -1, "graininess": 20, "relief": 100})),
+ PixelFx::NotePaper { balance: 0.0, graininess: 10.0, relief: 50.0 }
+ );
+ let doc = crate::effect_info("sketch.notePaper").unwrap().params;
+ assert!(doc.contains("imageBalance") && doc.contains("graininess") && doc.contains("relief"), "{doc}");
+ let f = fx("sketch.notePaper", json!({"relief": 12}));
+ assert_eq!(f.outset(Rect::new(0.0, 0.0, 100.0, 50.0)), 0.0);
+ assert_eq!(f.reach(), Some(0.0));
+}
+
+/// Note Paper embosses a horizontal gradient and graininess adds fibre.
+#[test]
+fn note_paper_embosses_a_gradient_and_grain_changes_pixels() {
+ let (w, h) = (32, 32);
+ let src = image(w, h, |x, _| grey((x * 255 / (w - 1)) as u8));
+ let flat = {
+ let mut out = src.clone();
+ fx("sketch.notePaper", json!({"relief": 0, "graininess": 0})).apply(&mut out, w, h, &space(w, h));
+ out
+ };
+ let embossed = {
+ let mut out = src.clone();
+ fx("sketch.notePaper", json!({"relief": 50, "graininess": 0})).apply(&mut out, w, h, &space(w, h));
+ out
+ };
+ assert_ne!(flat, embossed, "relief changes the emboss");
+ let grainy = {
+ let mut out = src.clone();
+ fx("sketch.notePaper", json!({"relief": 0, "graininess": 10})).apply(&mut out, w, h, &space(w, h));
+ out
+ };
+ assert_ne!(flat, grainy, "graininess adds fibre");
+}
+
/// Line's rows repeat every Size points: Size pixels at 72 ppi, twice as many at 144 ppi.
#[test]
fn halftone_line_period_is_the_size_at_any_resolution() {
@@ -2077,6 +2188,41 @@ fn halftone_pattern_type_changes_the_pattern() {
}
}
+/// Plaster of `p` over `w` × `h` pixels of `src`, laid out by `s`.
+fn plaster(p: serde_json::Value, src: &[u8], w: usize, h: usize, s: &PixelSpace) -> Vec {
+ let mut out = src.to_vec();
+ fx("sketch.plaster", p).apply(&mut out, w, h, s);
+ out
+}
+
+#[test]
+fn plaster_params_take_defaults_and_stay_in_range() {
+ use super::texture::Light;
+ assert_eq!(fx("sketch.plaster", json!({})), PixelFx::Plaster { image_balance: 20.0, smoothness: 8.0, light: Light::Top });
+ assert_eq!(
+ fx("sketch.plaster", json!({"imageBalance": 0, "smoothness": 1e9, "lightDirection": "bottomRight"})),
+ PixelFx::Plaster { image_balance: 1.0, smoothness: 15.0, light: Light::BottomRight }
+ );
+ assert_eq!(fx("sketch.plaster", json!({"lightDirection": "nonsense"})), fx("sketch.plaster", json!({})));
+ let doc = crate::effect_info("sketch.plaster").unwrap().params;
+ assert!(doc.contains("\"bottomRight\""), "{doc}");
+ let f = fx("sketch.plaster", json!({"smoothness": 24}));
+ assert_eq!(f.reach(), Some(super::sketch::plaster_reach(15.0)));
+}
+
+/// Plaster changes the image and different light directions give different results.
+#[test]
+fn plaster_light_direction_shifts_shading() {
+ let (w, h) = (48, 32);
+ let src = image(w, h, |x, y| grey((16 + (x + y) % 200) as u8));
+ let s = space(w, h);
+ let base = plaster(json!({"imageBalance": 20, "smoothness": 6, "lightDirection": "top"}), &src, w, h, &s);
+ assert_ne!(base, src, "plaster changes opaque pixels");
+ let left = plaster(json!({"lightDirection": "left"}), &src, w, h, &s);
+ let right = plaster(json!({"lightDirection": "right"}), &src, w, h, &s);
+ assert_ne!(left, right, "light direction changes the relief shading");
+}
+
#[test]
fn halftone_contrast_sharpens_the_screen() {
let (w, h) = (64, 32);
@@ -2114,6 +2260,89 @@ fn halftone_draws_in_black_and_white_only() {
}
}
+fn chrome(p: serde_json::Value, src: &[u8], w: usize, h: usize, s: &PixelSpace) -> Vec {
+ let mut out = src.to_vec();
+ fx("sketch.chrome", p).apply(&mut out, w, h, s);
+ out
+}
+
+/// Reticulation of `p` over `w` × `h` pixels of `src`, laid out by `s`.
+fn reticulation(p: serde_json::Value, src: &[u8], w: usize, h: usize, s: &PixelSpace) -> Vec {
+ let mut out = src.to_vec();
+ fx("sketch.reticulation", p).apply(&mut out, w, h, s);
+ out
+}
+
+#[test]
+fn chrome_params_take_defaults_and_stay_in_range() {
+ assert_eq!(fx("sketch.chrome", json!({})), PixelFx::Chrome { detail: 4.0, smoothness: 4.0 });
+ assert_eq!(fx("sketch.chrome", json!({"detail": -1, "smoothness": 99})), PixelFx::Chrome { detail: 0.0, smoothness: 10.0 });
+ assert_eq!(fx("sketch.chrome", json!({"detail": "x"})), fx("sketch.chrome", json!({})));
+ let doc = crate::effect_info("sketch.chrome").unwrap().params;
+ assert!(doc.contains("detail") && doc.contains("smoothness"), "{doc}");
+ let f = fx("sketch.chrome", json!({}));
+ assert_eq!(f.outset(Rect::new(0.0, 0.0, 100.0, 50.0)), 0.0);
+ assert_eq!(f.reach(), Some(sketch::chrome_reach(4.0)));
+ assert_eq!(fx("sketch.chrome", json!({"smoothness": 10})).reach(), Some(sketch::chrome_reach(10.0)));
+}
+
+/// Chrome redraws in greyscale, keeps coverage, and more detail changes the pattern.
+#[test]
+fn chrome_draws_polished_greyscale_relief() {
+ let (w, h) = (64, 64);
+ let src = image(w, h, |x, y| {
+ let t = ((x + y) * 4) as u8;
+ [t, t / 2, 255 - t, 255]
+ });
+ let soft = chrome(json!({"detail": 0, "smoothness": 8}), &src, w, h, &space(w, h));
+ let sharp = chrome(json!({"detail": 10, "smoothness": 0}), &src, w, h, &space(w, h));
+ assert_ne!(soft, sharp);
+ for out in [&soft, &sharp] {
+ for (p, q) in out.as_chunks::<4>().0.iter().zip(src.as_chunks::<4>().0) {
+ assert_eq!(p[3], q[3], "coverage kept");
+ assert!(p[0] == p[1] && p[1] == p[2], "greyscale {p:?}");
+ }
+ assert!(share(out, |p| p[0] > 10 && p[0] < 245) > 0.05, "midtones");
+ }
+}
+
+#[test]
+fn reticulation_params_take_defaults_and_stay_in_range() {
+ assert_eq!(fx("sketch.reticulation", json!({})), PixelFx::Reticulation { density: 12.0, foreground: 6.0, background: 6.0 });
+ assert_eq!(
+ fx("sketch.reticulation", json!({"density": -5, "foregroundLevel": 99, "backgroundLevel": -1})),
+ PixelFx::Reticulation { density: 0.0, foreground: 50.0, background: 0.0 }
+ );
+ let f = fx("sketch.reticulation", json!({}));
+ assert_eq!(f.outset(Rect::new(0.0, 0.0, 100.0, 50.0)), 0.0);
+ assert_eq!(f.reach(), Some(0.0));
+}
+
+#[test]
+fn reticulation_draws_in_black_and_white_only() {
+ let (w, h) = (48, 48);
+ let src = image(w, h, |x, y| {
+ let c = [[230u8, 20, 20], [20, 200, 40], [30, 60, 220], [240, 220, 30]][(x / 12) % 4];
+ let a: u16 = if y < 24 { 255 } else { 128 };
+ [c[0], c[1], c[2]].map(|v| (u16::from(v) * a / 255) as u8).into_iter().chain([a as u8]).collect::>().try_into().unwrap()
+ });
+ let out = reticulation(json!({}), &src, w, h, &space(w, h));
+ for (p, q) in out.as_chunks::<4>().0.iter().zip(src.as_chunks::<4>().0) {
+ assert_eq!(p[3], q[3], "coverage kept");
+ assert!(p[0] == p[1] && p[1] == p[2] && (p[0] == 0 || p[0] == p[3]), "{p:?} from {q:?}");
+ }
+ assert!(share(&out, |p| p[0] == 0) > 0.05 && share(&out, |p| p[0] == p[3]) > 0.05, "ink and paper");
+}
+
+#[test]
+fn reticulation_density_changes_the_grain() {
+ let (w, h) = (64, 64);
+ let src = image(w, h, |_, _| grey(128));
+ let low = reticulation(json!({"density": 5}), &src, w, h, &space(w, h));
+ let high = reticulation(json!({"density": 45}), &src, w, h, &space(w, h));
+ assert_ne!(low, high);
+}
+
/// The distinct colours of the covered pixels.
fn colours(d: &[u8]) -> std::collections::BTreeSet<[u8; 4]> {
d.as_chunks::<4>().0.iter().filter(|p| p[3] > 0).copied().collect()
@@ -2148,7 +2377,12 @@ fn artistic_params_take_defaults_and_stay_in_range() {
fx("artistic.neonGlow", json!({"glowSize": -1e308, "glowBrightness": 80, "color": "#ff0000"})),
PixelFx::NeonGlow { size: -24.0, brightness: 50.0, colour: [1.0, 0.0, 0.0] }
);
- for id in ["artistic.cutout", "artistic.neonGlow", "artistic.posterEdges"] {
+ assert_eq!(fx("artistic.plasticWrap", json!({})), PixelFx::PlasticWrap { highlight: 20.0, detail: 12.0, smoothness: 15.0 });
+ assert_eq!(
+ fx("artistic.plasticWrap", json!({"highlightStrength": -1, "detail": 99, "smoothness": 0})),
+ PixelFx::PlasticWrap { highlight: 0.0, detail: 15.0, smoothness: 1.0 }
+ );
+ for id in ["artistic.cutout", "artistic.neonGlow", "artistic.plasticWrap", "artistic.posterEdges"] {
assert_eq!(fx(id, json!({})).outset(Rect::new(0.0, 0.0, 40.0, 30.0)), 0.0, "{id} keeps the object's shape");
}
}
@@ -2166,6 +2400,7 @@ fn artistic_filters_leave_invalid_coordinate_spaces_alone() {
let filters = [
PixelFx::Cutout { levels: 4.0, simplicity: 4.0, fidelity: 2.0 },
PixelFx::NeonGlow { size: 5.0, brightness: 15.0, colour },
+ PixelFx::PlasticWrap { highlight: 20.0, detail: 12.0, smoothness: 15.0 },
PixelFx::PosterEdges { thickness: 2.0, intensity: 1.0, posterization: 2.0 },
];
for f in &filters {
@@ -2196,6 +2431,26 @@ fn artistic_filters_leave_invalid_coordinate_spaces_alone() {
assert!(changed.is_empty(), "directly constructed non-finite parameters and invalid spaces are harmless: {changed:?}");
}
+#[test]
+fn plastic_wrap_adds_specular_highlights_and_keeps_coverage() {
+ let (w, h) = (48, 32);
+ let src = image(w, h, |x, y| grey((((x + y) * 5) % 200 + 30) as u8));
+ let mut none = src.clone();
+ fx("artistic.plasticWrap", json!({"highlightStrength": 0})).apply(&mut none, w, h, &space(w, h));
+ assert_eq!(none, src);
+ let mut out = src.clone();
+ fx("artistic.plasticWrap", json!({})).apply(&mut out, w, h, &space(w, h));
+ assert!(out != src, "defaults brighten some pixels");
+ assert!(out.as_chunks::<4>().0.iter().zip(src.as_chunks::<4>().0).all(|(o, s)| o[3] == s[3]));
+ let mut weak = src.clone();
+ let mut strong = src.clone();
+ fx("artistic.plasticWrap", json!({"highlightStrength": 4})).apply(&mut weak, w, h, &space(w, h));
+ fx("artistic.plasticWrap", json!({"highlightStrength": 20})).apply(&mut strong, w, h, &space(w, h));
+ let lift =
+ |a: &[u8], b: &[u8]| a.as_chunks::<4>().0.iter().zip(b.as_chunks::<4>().0).map(|(o, s)| i32::from(o[0]) - i32::from(s[0])).sum::();
+ assert!(lift(&strong, &src) > lift(&weak, &src), "stronger highlights lift more");
+}
+
#[test]
fn cutout_paints_a_few_flat_colours_and_keeps_coverage() {
let (w, h) = (64, 24);
diff --git a/crates/effects/src/pixel/tests_paint.rs b/crates/effects/src/pixel/tests_paint.rs
new file mode 100644
index 0000000000..e84e587c9a
--- /dev/null
+++ b/crates/effects/src/pixel/tests_paint.rs
@@ -0,0 +1,189 @@
+//! Artistic › Smudge Stick, Sponge and Watercolor.
+
+use serde_json::json;
+use vectorcraft_doc::Effect;
+use vectorcraft_geom::{Affine, Point};
+
+use super::*;
+use crate::{RasterFx, raster_effects};
+
+/// A `w` × `h` raster whose pixels are document points (origin top-left), of an object that fills it.
+fn space(w: usize, h: usize) -> PixelSpace {
+ let (w, h) = (w as f64, h as f64);
+ PixelSpace {
+ to_doc: Affine::IDENTITY,
+ px: 1.0,
+ center: Point::new(w / 2.0, h / 2.0),
+ channels: Channels::Rgb,
+ line: 1.0,
+ extent: 0.5 * w.hypot(h),
+ }
+}
+
+fn image(w: usize, h: usize, f: impl Fn(usize, usize) -> [u8; 4]) -> Vec {
+ (0..h).flat_map(|y| (0..w).map(move |x| (x, y))).flat_map(|(x, y)| f(x, y)).collect()
+}
+
+fn fx(id: &str, p: serde_json::Value) -> PixelFx {
+ let e = Effect { id: id.into(), params: p, visible: true };
+ match raster_effects(&[e]).first() {
+ Some(RasterFx::Pixel(p)) => p.clone(),
+ other => panic!("{id}: {other:?}"),
+ }
+}
+
+fn run(id: &str, p: serde_json::Value, src: &[u8], w: usize, h: usize) -> Vec {
+ let mut out = src.to_vec();
+ fx(id, p).apply(&mut out, w, h, &space(w, h));
+ out
+}
+
+fn grey(v: u8) -> [u8; 4] {
+ [v, v, v, 255]
+}
+
+/// The mean of channel 0 over the columns `x0..x1`.
+fn mean(d: &[u8], w: usize, x0: usize, x1: usize) -> f64 {
+ let rows = d.len() / 4 / w;
+ let sum: f64 = (0..rows).flat_map(|y| (x0..x1).map(move |x| (x, y))).map(|(x, y)| f64::from(d[(y * w + x) * 4])).sum();
+ sum / (rows * (x1 - x0)) as f64
+}
+
+/// The summed difference between horizontal neighbours of channel 0 over columns `x0..x1`.
+fn roughness(d: &[u8], w: usize, x0: usize, x1: usize) -> f64 {
+ let rows = d.len() / 4 / w;
+ (0..rows)
+ .flat_map(|y| (x0..x1 - 1).map(move |x| (x, y)))
+ .map(|(x, y)| (f64::from(d[(y * w + x) * 4]) - f64::from(d[(y * w + x + 1) * 4])).abs())
+ .sum()
+}
+
+fn spread(d: &[u8]) -> f64 {
+ let v: Vec = d.as_chunks::<4>().0.iter().map(|p| f64::from(p[0])).collect();
+ let m = v.iter().sum::() / v.len() as f64;
+ (v.iter().map(|x| (x - m).powi(2)).sum::() / v.len() as f64).sqrt()
+}
+
+/// No panic and the coverage kept on tiny, huge and non-finite spaces and parameters.
+fn survives(id: &str, params: &[serde_json::Value]) {
+ let (w, h) = (9, 7);
+ let src = image(w, h, |x, y| [(x * 25) as u8, (y * 30) as u8, 90, if x == 0 { 0 } else { 255 }]);
+ let tiny = PixelSpace { px: 1e-9, ..space(w, h) };
+ let huge = PixelSpace { px: 1e9, center: Point::new(f64::MAX, -1e300), ..space(w, h) };
+ let nan = PixelSpace { px: f64::NAN, ..space(w, h) };
+ for p in params {
+ for s in [tiny, huge, nan, space(w, h)] {
+ let mut out = src.clone();
+ fx(id, p.clone()).apply(&mut out, w, h, &s);
+ assert_eq!(out.len(), src.len());
+ }
+ }
+ // A size that doesn't match, and an empty raster, do nothing.
+ let mut odd = vec![1u8; 10];
+ fx(id, json!({})).apply(&mut odd, 3, 3, &space(3, 3));
+ assert_eq!(odd, vec![1u8; 10]);
+ fx(id, json!({})).apply(&mut [], 0, 0, &space(1, 1));
+}
+
+#[test]
+fn smudge_stick_smudges_the_dark_and_lightens_the_light() {
+ assert_eq!(fx("artistic.smudgeStick", json!({})), PixelFx::SmudgeStick { stroke: 2.0, highlight: 12.0, intensity: 10.0 });
+ assert_eq!(
+ fx("artistic.smudgeStick", json!({"strokeLength": 1e308, "highlightArea": -5, "intensity": "x"})),
+ PixelFx::SmudgeStick { stroke: 10.0, highlight: 0.0, intensity: 10.0 }
+ );
+ // A fine checkerboard of dark tones on the left, of light tones on the right, and a half
+ // transparent bottom.
+ let (w, h) = (64, 48);
+ let src = image(w, h, |x, y| {
+ let on = (x + y) % 2 == 0;
+ let v = match (x < 32, on) {
+ (true, true) => 20,
+ (true, false) => 70,
+ (false, true) => 190,
+ (false, false) => 240,
+ };
+ if y < 40 { grey(v) } else { [v / 2, v / 2, v / 2, 128] }
+ });
+ let out = run("artistic.smudgeStick", json!({}), &src, w, h);
+ assert_eq!(out, run("artistic.smudgeStick", json!({}), &src, w, h), "draws the same twice");
+ assert!(out.as_chunks::<4>().0.iter().zip(src.as_chunks::<4>().0).all(|(o, s)| o[3] == s[3]), "coverage kept");
+ // The dark detail is smudged away, the light areas brighter.
+ assert!(roughness(&out, w, 4, 28) < 0.5 * roughness(&src, w, 4, 28));
+ assert!(mean(&out, w, 36, 60) > mean(&src, w, 36, 60) + 10.0);
+ // Intensity 0 leaves the light areas unlightened.
+ let flat = run("artistic.smudgeStick", json!({"intensity": 0}), &src, w, h);
+ assert!(mean(&flat, w, 36, 60) < mean(&out, w, 36, 60) - 5.0);
+ survives(
+ "artistic.smudgeStick",
+ &[json!({}), json!({"strokeLength": 1e308, "highlightArea": 1e308, "intensity": 1e308}), json!({"strokeLength": "NaN"})],
+ );
+}
+
+#[test]
+fn sponge_dabs_contrasting_blobs_and_keeps_the_hue() {
+ assert_eq!(fx("artistic.sponge", json!({})), PixelFx::Sponge { brush: 2.0, definition: 12.0, smoothness: 5.0 });
+ assert_eq!(
+ fx("artistic.sponge", json!({"brushSize": -1, "definition": 1e308, "smoothness": 0})),
+ PixelFx::Sponge { brush: 0.0, definition: 25.0, smoothness: 1.0 }
+ );
+ let (w, h) = (80, 60);
+ let flat = image(w, h, |_, y| if y < 50 { [200, 90, 60, 255] } else { [100, 45, 30, 128] });
+ let out = run("artistic.sponge", json!({"definition": 25}), &flat, w, h);
+ assert_eq!(out, run("artistic.sponge", json!({"definition": 25}), &flat, w, h), "draws the same twice");
+ assert!(out.as_chunks::<4>().0.iter().zip(flat.as_chunks::<4>().0).all(|(o, s)| o[3] == s[3]), "coverage kept");
+ // A flat colour breaks up into lighter and darker blobs of the same hue.
+ let top = &out[..w * 50 * 4];
+ assert!(spread(top) > 15.0, "{}", spread(top));
+ assert!(top.as_chunks::<4>().0.iter().all(|p| p[0] >= p[1] && p[1] >= p[2]), "red stays the strongest channel");
+ // Definition 0 leaves a flat colour as it is; more definition, more contrast.
+ let none = run("artistic.sponge", json!({"definition": 0}), &flat, w, h);
+ assert!(spread(&none[..w * 50 * 4]) < 1.0);
+ let some = run("artistic.sponge", json!({"definition": 8}), &flat, w, h);
+ assert!(spread(&some[..w * 50 * 4]) < spread(top));
+ survives("artistic.sponge", &[json!({}), json!({"brushSize": 1e308, "definition": 1e308, "smoothness": 1e308}), json!({"brushSize": "NaN"})]);
+}
+
+#[test]
+fn watercolor_simplifies_detail_and_saturates_edges() {
+ assert_eq!(fx("artistic.watercolor", json!({})), PixelFx::Watercolor { detail: 9.0, shadow: 1.0, texture: 1 });
+ assert_eq!(
+ fx("artistic.watercolor", json!({"brushDetail": 99, "shadowIntensity": -1, "texture": 2.6})),
+ PixelFx::Watercolor { detail: 14.0, shadow: 0.0, texture: 3 }
+ );
+ // Noisy grey on the left, a step from light red to dark blue on the right, a transparent row.
+ let (w, h) = (64, 48);
+ let src = image(w, h, |x, y| {
+ if y >= 44 {
+ return [0; 4];
+ }
+ if x < 32 {
+ grey(if (x * 7 + y * 13) % 5 < 2 { 90 } else { 150 })
+ } else if x < 48 {
+ [200, 120, 120, 255]
+ } else {
+ [60, 70, 110, 255]
+ }
+ });
+ let few = run("artistic.watercolor", json!({"brushDetail": 1}), &src, w, h);
+ let many = run("artistic.watercolor", json!({"brushDetail": 14}), &src, w, h);
+ assert_eq!(few, run("artistic.watercolor", json!({"brushDetail": 1}), &src, w, h), "draws the same twice");
+ assert!(few.as_chunks::<4>().0.iter().zip(src.as_chunks::<4>().0).all(|(o, s)| o[3] == s[3]), "coverage kept, nothing painted outside");
+ assert!(roughness(&few, w, 4, 28) < 0.5 * roughness(&src, w, 4, 28), "less detail, simpler");
+ assert!(roughness(&few, w, 4, 28) < roughness(&many, w, 4, 28));
+ // Colour is saturated where the tones change, and shadows deepen with Shadow Intensity.
+ let chroma = |d: &[u8], x: usize, y: usize| {
+ let i = (y * w + x) * 4;
+ f64::from(d[i].max(d[i + 1]).max(d[i + 2])) - f64::from(d[i].min(d[i + 1]).min(d[i + 2]))
+ };
+ assert!(chroma(&few, 47, 20) > chroma(&src, 47, 20) || chroma(&few, 48, 20) > chroma(&src, 48, 20));
+ assert!(mean(&run("artistic.watercolor", json!({"shadowIntensity": 10}), &src, w, h), w, 4, 28) < mean(&few, w, 4, 28));
+ // Texture adds paper grain to a flat colour.
+ let flat = image(w, h, |_, _| grey(128));
+ let (t1, t3) = (run("artistic.watercolor", json!({"texture": 1}), &flat, w, h), run("artistic.watercolor", json!({"texture": 3}), &flat, w, h));
+ assert!(spread(&t3) > spread(&t1) && spread(&t1) > 0.2);
+ survives(
+ "artistic.watercolor",
+ &[json!({}), json!({"brushDetail": -1e308, "shadowIntensity": 1e308, "texture": 1e308}), json!({"brushDetail": "NaN"})],
+ );
+}
diff --git a/crates/effects/src/pixel/tests_sketch.rs b/crates/effects/src/pixel/tests_sketch.rs
new file mode 100644
index 0000000000..d97cc89f8f
--- /dev/null
+++ b/crates/effects/src/pixel/tests_sketch.rs
@@ -0,0 +1,181 @@
+//! Sketch › Bas Relief, Charcoal, Photocopy and Stamp.
+
+use serde_json::json;
+use vectorcraft_doc::Effect;
+use vectorcraft_geom::{Affine, Point, Rect};
+
+use super::*;
+use crate::{RasterFx, raster_effects};
+
+/// A `w` × `h` raster whose pixels are document points (origin top-left), of an object that fills it.
+fn space(w: usize, h: usize) -> PixelSpace {
+ let (w, h) = (w as f64, h as f64);
+ PixelSpace {
+ to_doc: Affine::IDENTITY,
+ px: 1.0,
+ center: Point::new(w / 2.0, h / 2.0),
+ channels: Channels::Rgb,
+ line: 1.0,
+ extent: 0.5 * w.hypot(h),
+ }
+}
+
+fn image(w: usize, h: usize, f: impl Fn(usize, usize) -> [u8; 4]) -> Vec {
+ (0..h).flat_map(|y| (0..w).map(move |x| (x, y))).flat_map(|(x, y)| f(x, y)).collect()
+}
+
+fn fx(id: &str, p: serde_json::Value) -> PixelFx {
+ let e = Effect { id: id.into(), params: p, visible: true };
+ match raster_effects(&[e]).first() {
+ Some(RasterFx::Pixel(p)) => p.clone(),
+ other => panic!("{id}: {other:?}"),
+ }
+}
+
+fn run(id: &str, p: serde_json::Value, src: &[u8], w: usize, h: usize) -> Vec {
+ let mut out = src.to_vec();
+ fx(id, p).apply(&mut out, w, h, &space(w, h));
+ out
+}
+
+fn grey(v: u8) -> [u8; 4] {
+ [v, v, v, 255]
+}
+
+/// Channel 0 of pixel (`x`, `y`).
+fn at(d: &[u8], w: usize, x: usize, y: usize) -> u8 {
+ d[(y * w + x) * 4]
+}
+
+/// How many pixels of channel 0 are darker than 128.
+fn black(d: &[u8]) -> usize {
+ d.as_chunks::<4>().0.iter().filter(|p| p[0] < 128).count()
+}
+
+/// No panic and the coverage kept on tiny, huge and non-finite spaces and parameters.
+fn survives(id: &str, params: &[serde_json::Value]) {
+ let (w, h) = (9, 7);
+ let src = image(w, h, |x, y| [(x * 25) as u8, (y * 30) as u8, 90, if x == 0 { 0 } else { 255 }]);
+ let tiny = PixelSpace { px: 1e-9, ..space(w, h) };
+ let huge = PixelSpace { px: 1e9, center: Point::new(f64::MAX, -1e300), ..space(w, h) };
+ let nan = PixelSpace { px: f64::NAN, ..space(w, h) };
+ for p in params {
+ for s in [tiny, huge, nan, space(w, h)] {
+ let mut out = src.clone();
+ fx(id, p.clone()).apply(&mut out, w, h, &s);
+ assert_eq!(out.len(), src.len());
+ let alphas = |d: &[u8]| d.as_chunks::<4>().0.iter().map(|p| p[3]).collect::>();
+ if s.px == 1.0 {
+ assert_eq!(alphas(&out), alphas(&src), "{id}: coverage kept");
+ }
+ }
+ }
+ // A size that doesn't match, and an empty raster, do nothing.
+ let mut odd = vec![1u8; 10];
+ fx(id, json!({})).apply(&mut odd, 3, 3, &space(3, 3));
+ assert_eq!(odd, vec![1u8; 10]);
+ fx(id, json!({})).apply(&mut [], 0, 0, &space(1, 1));
+}
+
+#[test]
+fn photocopy_copies_the_edges_of_dark_areas() {
+ assert_eq!(fx("sketch.photocopy", json!({})), PixelFx::Photocopy { detail: 7.0, darkness: 25.0 });
+ assert_eq!(fx("sketch.photocopy", json!({"detail": 1e308, "darkness": -5})), PixelFx::Photocopy { detail: 24.0, darkness: 1.0 });
+ let (w, h) = (64, 16);
+ let src = image(w, h, |x, _| grey(if x < 32 { 30 } else { 230 }));
+ let out = run("sketch.photocopy", json!({"detail": 20}), &src, w, h);
+ // Black just on the dark side of the edge; white in the dark area's middle and in the light.
+ assert!(at(&out, w, 30, 8) < 64, "edge {}", at(&out, w, 30, 8));
+ assert!(at(&out, w, 6, 8) > 192, "dark area {}", at(&out, w, 6, 8));
+ assert!(at(&out, w, 50, 8) > 192, "light area {}", at(&out, w, 50, 8));
+ assert_eq!(out, run("sketch.photocopy", json!({"detail": 20}), &src, w, h), "deterministic");
+ // A higher Darkness copies more.
+ let more = run("sketch.photocopy", json!({"detail": 20, "darkness": 50}), &src, w, h);
+ let less = run("sketch.photocopy", json!({"detail": 20, "darkness": 1}), &src, w, h);
+ assert!(black(&more) >= black(&less));
+ survives("sketch.photocopy", &[json!({}), json!({"detail": 1e308, "darkness": "NaN"}), json!({"detail": -1e308, "darkness": [1]})]);
+}
+
+#[test]
+fn stamp_prints_solid_black_and_white() {
+ assert_eq!(fx("sketch.stamp", json!({})), PixelFx::Stamp { balance: 25.0, smoothness: 5.0 });
+ assert_eq!(fx("sketch.stamp", json!({"lightDarkBalance": 1e308, "smoothness": -1})), PixelFx::Stamp { balance: 50.0, smoothness: 1.0 });
+ let (w, h) = (64, 8);
+ let src = image(w, h, |x, _| grey((x * 4) as u8));
+ let few = run("sketch.stamp", json!({"lightDarkBalance": 0}), &src, w, h);
+ let many = run("sketch.stamp", json!({"lightDarkBalance": 50}), &src, w, h);
+ assert!(black(&many) > black(&few), "{} vs {}", black(&many), black(&few));
+ // Pure black and white, but for the one pixel wide edges.
+ let mixed = many.as_chunks::<4>().0.iter().filter(|p| p[0] != 0 && p[0] != 255).count();
+ assert!(mixed * 10 < many.len() / 4, "{mixed} grey pixels");
+ assert_eq!(at(&many, w, 0, 4), 0);
+ assert_eq!(at(&many, w, 63, 4), 255);
+ survives(
+ "sketch.stamp",
+ &[json!({}), json!({"lightDarkBalance": "NaN", "smoothness": 1e308}), json!({"lightDarkBalance": -1e308, "smoothness": null})],
+ );
+}
+
+#[test]
+fn charcoal_draws_bold_edges_and_sketches_the_midtones() {
+ assert_eq!(fx("sketch.charcoal", json!({})), PixelFx::Charcoal { thickness: 1.0, detail: 1.0, balance: 50.0 });
+ assert_eq!(
+ fx("sketch.charcoal", json!({"thickness": 1e308, "detail": -5, "lightDarkBalance": "x"})),
+ PixelFx::Charcoal { thickness: 7.0, detail: 0.0, balance: 50.0 }
+ );
+ let (w, h) = (64, 48);
+ // Black on the left, white on the right: a bold line at the edge, nothing in the white.
+ let step = image(w, h, |x, _| grey(if x < 32 { 0 } else { 255 }));
+ let out = run("sketch.charcoal", json!({}), &step, w, h);
+ assert!((28..36).any(|x| at(&out, w, x, 24) < 64), "edge");
+ assert!((48..64).all(|x| at(&out, w, x, 24) == 255), "white stays white");
+ // A midtone is sketched in strokes, more of it the more the balance reaches into the lights.
+ let mid = image(w, h, |_, _| grey(128));
+ let sketched = run("sketch.charcoal", json!({}), &mid, w, h);
+ let (n, total) = (black(&sketched), w * h);
+ assert!(n > total / 50 && n < total * 9 / 10, "{n} of {total}");
+ let darker = run("sketch.charcoal", json!({"lightDarkBalance": 100}), &mid, w, h);
+ let lighter = run("sketch.charcoal", json!({"lightDarkBalance": 0}), &mid, w, h);
+ assert!(black(&darker) > black(&lighter));
+ assert_eq!(sketched, run("sketch.charcoal", json!({}), &mid, w, h), "deterministic");
+ let white = image(w, h, |_, _| grey(255));
+ assert_eq!(black(&run("sketch.charcoal", json!({"lightDarkBalance": 0}), &white, w, h)), 0);
+ survives(
+ "sketch.charcoal",
+ &[json!({}), json!({"thickness": 1e308, "detail": "NaN", "lightDarkBalance": [1]}), json!({"thickness": -1e308, "detail": 1e308})],
+ );
+}
+
+#[test]
+fn bas_relief_lights_the_surfaces_facing_the_light() {
+ assert_eq!(fx("sketch.basRelief", json!({})), PixelFx::BasRelief { detail: 13.0, smoothness: 3.0, light: Light::Bottom });
+ assert_eq!(
+ fx("sketch.basRelief", json!({"detail": 0, "smoothness": 1e308, "lightDirection": "Top"})),
+ PixelFx::BasRelief { detail: 1.0, smoothness: 15.0, light: Light::Top }
+ );
+ // Dark above, light below: the edge is lit from one side and shaded from the other.
+ let (w, h) = (16, 48);
+ let src = image(w, h, |_, y| grey(if y < 24 { 20 } else { 235 }));
+ let below = run("sketch.basRelief", json!({"lightDirection": "bottom"}), &src, w, h);
+ let above = run("sketch.basRelief", json!({"lightDirection": "top"}), &src, w, h);
+ let edge = (0..h).map(|y| (y, i32::from(at(&below, w, 8, y)) - i32::from(at(&above, w, 8, y)))).max_by_key(|(_, d)| d.abs());
+ assert!(edge.is_some_and(|(_, d)| d.abs() > 100), "{edge:?}");
+ // Flat areas are grey.
+ for y in [2, 45] {
+ let v = at(&below, w, 8, y);
+ assert!((90..190).contains(&v), "flat {v}");
+ }
+ survives(
+ "sketch.basRelief",
+ &[json!({}), json!({"detail": "NaN", "smoothness": 1e308, "lightDirection": 3}), json!({"detail": -1e308, "smoothness": null})],
+ );
+}
+
+#[test]
+fn sketch_filters_reach_beyond_nothing_they_do_not_paint() {
+ for id in ["sketch.basRelief", "sketch.charcoal", "sketch.photocopy", "sketch.stamp"] {
+ let f = fx(id, json!({}));
+ assert_eq!(f.outset(Rect::new(0.0, 0.0, 50.0, 50.0)), 0.0, "{id} keeps the object's coverage");
+ assert!(f.reach().is_some_and(|r| r.is_finite() && r > 0.0), "{id} reach");
+ }
+}
diff --git a/crates/effects/src/pixel/texture.rs b/crates/effects/src/pixel/texture.rs
index c3ef214d71..18c95681d8 100644
--- a/crates/effects/src/pixel/texture.rs
+++ b/crates/effects/src/pixel/texture.rs
@@ -128,7 +128,7 @@ impl Light {
}
/// The unit vector towards the light (document axes, y down).
- fn toward(self) -> Vec2 {
+ pub(super) fn toward(self) -> Vec2 {
let d = FRAC_1_SQRT_2;
match self {
Light::Bottom => Vec2::new(0.0, 1.0),
@@ -269,7 +269,7 @@ impl Tones {
}
/// The tone at pixel (`x`, `y`) and its slope per document unit along the document's axes.
- fn slope(&self, x: usize, y: usize, place: &Place) -> (f64, Vec2) {
+ pub(super) fn slope(&self, x: usize, y: usize, place: &Place) -> (f64, Vec2) {
let gx = 0.5 * (self.get(x + 1, y) - self.get(x.saturating_sub(1), y));
let gy = 0.5 * (self.get(x, y + 1) - self.get(x, y.saturating_sub(1)));
// Per pixel → per document unit: through the transpose of the document → pixel map.
diff --git a/crates/effects/src/reshape.rs b/crates/effects/src/reshape.rs
index e0c469718b..ce844a0765 100644
--- a/crates/effects/src/reshape.rs
+++ b/crates/effects/src/reshape.rs
@@ -7,12 +7,14 @@
//! warp bends a line of type as a whole. An image is clipped by its reshaped frame. Raster effects
//! (shadows, glows, blur, feather) stay on the result for the renderer and exporters. Type without
//! inline graphics whose own fills or strokes have geometry effects is outlined too: each of those
-//! effects reshapes the whole outline that its fill or stroke paints.
+//! effects reshapes the whole outline that its fill or stroke paints. An image's own fills and
+//! strokes paint only the shape that a Convert to Shape or Outline Object effect on them gives
+//! them ([`image_rows`]).
use std::sync::Arc;
use vectorcraft_doc::{Appearance, AppearanceItem, Effect, Node, NodeKind};
-use vectorcraft_geom::{Affine, FillRule, PathData, Rect, shapes};
+use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Rect, Shape, shapes};
use crate::{GeomContext, apply_one, is_geometry, merged_params};
@@ -44,11 +46,75 @@ pub fn has_gradient_copies(n: &Node) -> bool {
}
/// Is `n` type without inline graphics that has a fill or stroke of its own that paints and has a
-/// visible geometry effect? Such an effect reshapes the whole outline that its fill or stroke
+/// visible geometry effect, or an image with a fill or stroke of its own that paints a shape
+/// ([`image_rows`])? On type, such an effect reshapes the whole outline that its fill or stroke
/// paints ([`outline_text`], which leaves inline graphics out).
pub fn has_item_geometry(n: &Node) -> bool {
- let NodeKind::Text(t) = &n.kind else { return false };
- t.runs.iter().all(|r| r.inline.is_none()) && n.appearance.items.iter().any(|i| crate::paints(i) && crate::has_geometry(i.effects()))
+ match &n.kind {
+ NodeKind::Text(t) => {
+ t.runs.iter().all(|r| r.inline.is_none()) && n.appearance.items.iter().any(|i| crate::paints(i) && crate::has_geometry(i.effects()))
+ }
+ NodeKind::Image(_) => n.appearance.items.iter().any(shapes_image),
+ _ => false,
+ }
+}
+
+/// Does effect `e` give an image's fill or stroke a shape to paint (a visible Convert to Shape or
+/// Outline Object)?
+fn gives_shape(e: &Effect) -> bool {
+ e.visible
+ && matches!(e.id.as_str(), "convertToShape.rectangle" | "convertToShape.roundedRectangle" | "convertToShape.ellipse" | "path.outlineObject")
+}
+
+/// Does `item`, a fill or stroke of an image, paint something: does it paint and carry an effect
+/// that gives it a shape ([`gives_shape`])?
+fn shapes_image(item: &AppearanceItem) -> bool {
+ crate::paints(item) && item.effects().iter().any(gives_shape)
+}
+
+/// The fills and strokes of `items` (an image's own) that paint something ([`shapes_image`]), each
+/// without the effects before its first Convert to Shape or Outline Object. Convert to Shape sizes
+/// its shape from the image's box, and Outline Object gives the image's frame. The others paint
+/// nothing.
+fn image_rows(items: &[AppearanceItem]) -> Vec {
+ items
+ .iter()
+ .filter(|i| shapes_image(i))
+ .map(|i| {
+ let mut i = i.clone();
+ let fx = i.effects_mut();
+ let first = fx.iter().position(gives_shape).unwrap_or(0);
+ fx.drain(..first);
+ i
+ })
+ .collect()
+}
+
+/// The shapes that the image `n`'s own fills and strokes paint ([`image_rows`]), each with its fill
+/// rule and the fill or stroke that paints it: the paths (or compound paths) along its frame that
+/// [`reshape`] makes, 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.
+pub fn image_paint(n: &Node) -> Vec<(BezPath, FillRule, AppearanceItem)> {
+ if !matches!(n.kind, NodeKind::Image(_)) || !has_item_geometry(n) {
+ return vec![];
+ }
+ let Some(art) = reshape(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::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()));
+ }
+ });
+ out
}
/// The glyph outlines of type `t` in text space with its underline and strikethrough bars: one
@@ -186,11 +252,13 @@ pub(crate) fn outline_nested_text(n: &mut Node, clipping: bool) {
/// `n` (see [`needs_outline`]) with its object-level geometry effects and its perspective applied:
/// its [`outline_art`] reshaped as one piece, or for an image the image clipped by its reshaped
-/// frame. Type's own fills and strokes keep their effects on its whole outline. The result is a
-/// group with `n`'s id, name, visibility, transparency, opacity mask and remaining (raster)
-/// effects; `None` when `n` has no visible geometry effect, no perspective and is not type with
-/// a geometry effect on a fill or stroke of its own ([`has_item_geometry`]), or has no art (a
-/// symbol instance without `symbol_art`).
+/// frame. Type's own fills and strokes keep their effects on its whole outline. An image's own
+/// fills and strokes that paint a shape ([`image_rows`]) become paths along its frame below and
+/// above it, reshaped with it, and keep their effects from their first Convert to Shape or Outline
+/// Object on. The result is a group with `n`'s id, name, visibility, transparency, opacity mask
+/// and remaining (raster) effects; `None` when `n` has no visible geometry effect, no perspective
+/// and is not type or an image with a fill or stroke of its own that [`has_item_geometry`] counts,
+/// or has no art (a symbol instance without `symbol_art`).
pub fn reshape(n: &Node, symbol_art: Option<&Node>) -> Option {
if (geometry_effects(n).is_empty() && n.projection().is_none() && !has_item_geometry(n)) || !(needs_outline(n) || has_gradient_copies(n)) {
return None;
@@ -200,14 +268,17 @@ pub fn reshape(n: &Node, symbol_art: Option<&Node>) -> Option {
/// `n` (see [`needs_outline`], or a path with [`has_gradient_copies`]) as plain art for Expand
/// Appearance: [`reshape`]d when it has
-/// geometry effects, else type with fills or strokes of its own outlined, in the same form. `None`
-/// when it has neither.
+/// geometry effects, else type with fills or strokes of its own outlined, or an image with fills
+/// or strokes of its own that paint a shape, in the same form. `None` when it has none of these.
pub fn expand_outlined(n: &Node, symbol_art: Option<&Node>) -> Option {
// A path whose Transform effect copies it with a gradient: each copy an object of its own.
if has_gradient_copies(n) {
return as_art(n, symbol_art);
}
- let own_paint = matches!(n.kind, NodeKind::Text(_)) && !n.appearance.items.is_empty();
+ let own_paint = match n.kind {
+ NodeKind::Text(_) => !n.appearance.items.is_empty(),
+ _ => has_item_geometry(n),
+ };
if !needs_outline(n) || (geometry_effects(n).is_empty() && !own_paint) {
return None;
}
@@ -220,12 +291,28 @@ pub(crate) fn as_art(n: &Node, symbol_art: Option<&Node>) -> Option {
let mut art = match &n.kind {
NodeKind::Image(im) => {
let frame = shapes::rectangle(Rect::new(0.0, 0.0, im.width as f64, im.height as f64)).transformed(im.xf);
- let mut clip = Node::path(n.id, frame, Appearance::default());
- if let NodeKind::Path { clipping, .. } = &mut clip.kind {
- *clipping = true;
- }
let image = Node::new(n.id, n.kind.clone());
- Node::new(n.id, NodeKind::Group { children: vec![Arc::new(clip), Arc::new(image)], clip: true })
+ let clipped = || {
+ let mut clip = Node::path(n.id, frame.clone(), Appearance::default());
+ if let NodeKind::Path { clipping, .. } = &mut clip.kind {
+ *clipping = true;
+ }
+ Node::new(n.id, NodeKind::Group { children: vec![Arc::new(clip), Arc::new(image.clone())], clip: true })
+ };
+ // The fills and strokes that paint a shape, as paths along the frame below and above
+ // the image.
+ let (below, above) = n.appearance.split_contents();
+ let (below, above) = (image_rows(below), image_rows(above));
+ if below.is_empty() && above.is_empty() {
+ clipped()
+ } else {
+ let rows = |items: Vec| {
+ (!items.is_empty()).then(|| Arc::new(Node::path(n.id, frame.clone(), Appearance { items, ..Default::default() })))
+ };
+ // Without geometry effects, the image is not clipped.
+ let image = if fx.is_empty() { image.clone() } else { clipped() };
+ Node::group(n.id, rows(below).into_iter().chain([Arc::new(image)]).chain(rows(above)).collect())
+ }
}
_ => outline_art(n, symbol_art)?,
};
@@ -234,7 +321,8 @@ pub(crate) fn as_art(n: &Node, symbol_art: Option<&Node>) -> Option {
if let Some(h) = n.projection() {
project_leaves(&mut art, &h);
}
- // The art is a group with `n`'s id (a clip group for an image).
+ // The art is a group with `n`'s id (for an image without fills or strokes that paint, a clip
+ // group).
let mut out = art;
out.name = n.name.clone();
out.visible = n.visible;
diff --git a/crates/effects/src/solids.rs b/crates/effects/src/solids.rs
index d28ab56e50..d4c461f073 100644
--- a/crates/effects/src/solids.rs
+++ b/crates/effects/src/solids.rs
@@ -212,8 +212,12 @@ fn region(path: &PathData, rule: FillRule, item: &AppearanceItem) -> (PathData,
}
/// The 3D art of one effect `fx` on `path` (already through the effects before it).
-/// Extrude & Bevel and Inflate build a solid from the outline, painted with the top visible fill
-/// (or, without one, the top stroke); Rotate turns every fill and stroke, each in its own paint.
+/// Rotate turns every fill and stroke, each in its own paint. Extrude & Bevel and Inflate build a
+/// solid from the path for the top visible fill and one from the outline of each visible stroke,
+/// each in its own paint. When every one is opaque with normal blending and no colored light makes
+/// a surface one composite or masks it, their faces are drawn in one back-to-front order (where
+/// depths tie, as for the caps turned toward the viewer, in the order of the appearance);
+/// otherwise each solid is a surface of its own, in that order.
fn art_for(n: &Node, fx: &Effect, path: &PathData, rule: FillRule, items: &[&AppearanceItem]) -> Option>> {
let b = path.bounds()?;
let p = crate::merged_params(&fx.id, &fx.params);
@@ -229,12 +233,72 @@ fn art_for(n: &Node, fx: &Effect, path: &PathData, rule: FillRule, items: &[&App
}
return Some(out);
}
- let item = items.iter().rev().find(|i| matches!(i, AppearanceItem::Fill(_))).or_else(|| items.last())?;
- let (paint, opacity, blend) = paint_of(item);
- // A loaded file or a shape edited past the limits keeps drawing its source path instead of
- // failing the frame; commands validate the same evaluator and report its errors.
- let f = facets(&fx.id, path, rule, b, &p).ok()?;
- Some(vec![Arc::new(surface(n, f, &paint, opacity, blend, colored))])
+ let top_fill = items.iter().rposition(|i| matches!(i, AppearanceItem::Fill(_)));
+ let parts: Vec<(&AppearanceItem, PathData, FillRule)> = items
+ .iter()
+ .enumerate()
+ .filter(|(k, i)| Some(*k) == top_fill || matches!(i, AppearanceItem::Stroke(_)))
+ .map(|(_, i)| {
+ let (area, rule) = region(path, rule, i);
+ (*i, area, rule)
+ })
+ .collect();
+ // The solids share the bounds of all their shapes: one center to turn, twist and taper about,
+ // and Inflate's grid reaches over the strokes' outlines.
+ let bounds = parts.iter().filter_map(|(_, area, _)| area.bounds()).reduce(|a, c| a.union(c)).unwrap_or(b);
+ let built = if fx.id == INFLATE {
+ // One eye for every puff, as far away as the highest needs.
+ let shapes: Vec<(&PathData, FillRule)> = parts.iter().map(|(_, area, rule)| (area, *rule)).collect();
+ vectorcraft_three_d::inflate_together(&shapes, bounds, inflate_options(&p), view_options(&p))
+ } else {
+ parts.iter().map(|(_, area, rule)| facets(&fx.id, area, *rule, bounds, &p)).collect()
+ };
+ let mut solids = vec![];
+ for ((item, _, _), f) in parts.iter().zip(built) {
+ let item: &AppearanceItem = item;
+ match f {
+ Ok(f) => solids.push((item, f)),
+ // A stroke's outline past the limits is left out; the fill's solid still draws.
+ Err(_) if matches!(item, AppearanceItem::Stroke(_)) => {}
+ // A loaded file or a shape edited past the limits keeps drawing its source path
+ // instead of failing the frame; commands validate the same evaluator and report its
+ // errors.
+ Err(_) => return None,
+ }
+ }
+ if solids.is_empty() {
+ return None;
+ }
+ let opaque = solids.iter().all(|(item, _)| {
+ let (_, opacity, blend) = paint_of(item);
+ opacity >= 1.0 && blend == BlendMode::Normal
+ });
+ let surfaces: Vec<(Vec, Node)> = solids
+ .into_iter()
+ .map(|(item, f)| {
+ let depths: Vec = f.iter().map(|f| f.depth).collect();
+ let (paint, opacity, blend) = paint_of(item);
+ (depths, surface(n, f, &paint, opacity, blend, colored))
+ })
+ .collect();
+ // One order takes a plain group of faces from each solid, one face for each facet. With
+ // colored lights a surface can instead be one clipped composite of all its facets, or carry an
+ // opacity mask, and then it stays whole.
+ let plain = surfaces.iter().all(|(depths, s)| {
+ s.extras().mask.is_none() && matches!(&s.kind, NodeKind::Group { children, clip: false } if children.len() == depths.len())
+ });
+ if !opaque || !plain {
+ return Some(surfaces.into_iter().map(|(_, s)| Arc::new(s)).collect());
+ }
+ let mut faces = vec![];
+ for (depths, s) in surfaces {
+ if let NodeKind::Group { children, .. } = s.kind {
+ faces.extend(depths.into_iter().zip(children));
+ }
+ }
+ // A stable sort: faces at the same depth keep the order of the appearance.
+ faces.sort_by(|a, b| a.0.total_cmp(&b.0));
+ Some(vec![Arc::new(Node::group(n.id, faces.into_iter().map(|(_, face)| face).collect()))])
}
fn geometry(path: &PathData, fx: &[Effect], ctx: &GeomContext) -> PathData {
diff --git a/crates/effects/src/tests_solids.rs b/crates/effects/src/tests_solids.rs
index 335c0b8b69..61b5a7f575 100644
--- a/crates/effects/src/tests_solids.rs
+++ b/crates/effects/src/tests_solids.rs
@@ -1,6 +1,6 @@
use serde_json::json;
use vectorcraft_doc::{Document, NodeId};
-use vectorcraft_geom::{Affine, BezPath};
+use vectorcraft_geom::{Affine, BezPath, Point, Shape};
use super::*;
@@ -44,7 +44,8 @@ fn every_solid_draws_shaded_faces_and_leaves_the_source_editable() {
let art = solid_art(&n).unwrap_or_else(|| panic!("{id}"));
assert_eq!(n.path_data(), Some(&source), "{id}");
assert!(!faces(&art).is_empty(), "{id}");
- // The faces are the fill's red, shaded: never brighter, never another hue.
+ // The faces are the fill's red or the stroke's black, shaded: never brighter, never another
+ // hue.
for f in faces(&art) {
let [r, g, b] = fill_rgb(f);
assert!(r <= 0.8 + 1e-6 && (g * 4.0 - r).abs() < 1e-4 && (b * 8.0 - r).abs() < 1e-4 || id == ROTATE, "{id}: {r} {g} {b}");
@@ -76,12 +77,229 @@ fn rotate_turns_every_fill_and_stroke_and_the_solids_use_the_top_fill() {
n.appearance.effects[0].params = json!({"rotationX": 0, "rotationY": 60, "rotationZ": 0});
let b = solid_art(&n).unwrap().children().unwrap()[1].visual_bounds().unwrap();
assert!((b.width() - 104.0 * 0.5 - 0.75).abs() < 1e-6, "{b:?}");
- // Extrude & Bevel paints one surface with the top fill.
+ // Extrude & Bevel draws the fill's solid and the stroke's, both opaque, as one surface.
let mut n = square_node();
n.appearance.effects.push(fx(EXTRUDE, json!({})));
assert_eq!(solid_art(&n).unwrap().children().unwrap().len(), 1);
}
+const BLUE: Color = Color::Rgb { r: 0.1, g: 0.3, b: 0.9 };
+
+/// `b` with a red fill and a 6 pt blue stroke above it, on the path.
+fn stroked(b: &BezPath) -> Node {
+ Node::path(NodeId(1), PathData::from_bezpath(b), Appearance::basic(Paint::solid(RED), Paint::solid(BLUE), 6.0))
+}
+
+/// A `width` × 100 pt rectangle at (100, 100), stroked.
+fn stroked_rect(width: f64) -> Node {
+ let mut b = BezPath::new();
+ b.move_to((100.0, 100.0));
+ b.line_to((100.0 + width, 100.0));
+ b.line_to((100.0 + width, 200.0));
+ b.line_to((100.0, 200.0));
+ b.close_path();
+ stroked(&b)
+}
+
+/// Is `face` in the stroke's blue (rather than the fill's red)?
+fn blue(face: &Node) -> bool {
+ let [r, _, b] = fill_rgb(face);
+ b > r
+}
+
+/// The bounds of the faces' own paths (without their seam strokes).
+fn extent(faces: &[&Node]) -> Rect {
+ faces.iter().filter_map(|f| f.path_data()?.bounds()).reduce(|a, b| a.union(b)).unwrap()
+}
+
+fn assert_rect(r: Rect, x0: f64, y0: f64, x1: f64, y1: f64) {
+ assert!([r.x0 - x0, r.y0 - y0, r.x1 - x1, r.y1 - y1].iter().all(|d| d.abs() < 1e-6), "{r:?}");
+}
+
+/// Extrude & Bevel and Inflate build a solid from each stroke's outline as well as from the path
+/// for the fill: seen straight on, the stroke's faces reach 3 pt (half its width) outside the
+/// fill's, and they are drawn in the stroke's paint.
+#[test]
+fn a_stroke_builds_a_solid_from_its_outline_beside_the_fill() {
+ for id in [EXTRUDE, INFLATE] {
+ let mut n = stroked_rect(100.0);
+ n.appearance.effects.push(fx(id, json!({"rotationX": 0, "rotationY": 0, "rotationZ": 0})));
+ let art = solid_art(&n).unwrap();
+ let (strokes, fills): (Vec<&Node>, Vec<&Node>) = faces(&art).into_iter().partition(|f| blue(f));
+ assert!(!strokes.is_empty(), "{id}: the stroke draws");
+ assert_rect(extent(&fills), 100.0, 100.0, 200.0, 200.0);
+ assert_rect(extent(&strokes), 97.0, 97.0, 203.0, 203.0);
+ // Its own blue, shaded: never brighter, never another hue.
+ for f in &strokes {
+ let [r, g, b] = fill_rgb(f);
+ assert!(b <= 0.9 + 1e-6 && (r * 9.0 - b).abs() < 1e-4 && (g * 3.0 - b).abs() < 1e-4, "{id}: {r} {g} {b}");
+ }
+ }
+}
+
+/// Turned, the extrusion's walls show in both paints, and the front caps, which nothing of either
+/// solid can hide, are drawn last: the fill's, then the stroke's above it, equally lit. Without
+/// depth the two flat shapes are drawn in the same order. A stroke below the fill has its cap
+/// drawn below the fill's.
+#[test]
+fn the_front_caps_are_drawn_last_in_the_order_of_the_appearance() {
+ // A triangle wider than deep, so the near ends of the walls lie nearer than the middle of the
+ // caps; the mean of its outline's points is not the mean of the stroke's.
+ let mut b = BezPath::new();
+ b.move_to((100.0, 100.0));
+ b.line_to((400.0, 100.0));
+ b.line_to((100.0, 200.0));
+ b.close_path();
+ for params in [json!({}), json!({"depth": 120, "bevel": "rounded"}), json!({"depth": 0})] {
+ let mut n = stroked(&b);
+ n.appearance.effects.push(fx(EXTRUDE, params.clone()));
+ n.appearance.items.reverse();
+ let art = solid_art(&n).unwrap();
+ let [.., stroke_cap, fill_cap] = faces(&art)[..] else { panic!("{params}: two caps") };
+ assert!(blue(stroke_cap) && !blue(fill_cap), "{params}: the stroke below");
+ n.appearance.items.reverse();
+ let art = solid_art(&n).unwrap();
+ let faces = faces(&art);
+ let flat = params["depth"] == json!(0);
+ assert!(if flat { faces.len() == 2 } else { faces.len() > 4 }, "{params}: {} faces", faces.len());
+ let [.., fill_cap, stroke_cap] = faces.as_slice() else { panic!("{params}: two caps") };
+ assert!(!blue(fill_cap) && blue(stroke_cap), "{params}");
+ // The stroke's cap is a ring: its outline and the hole the fill shows through.
+ assert_eq!(stroke_cap.path_data().unwrap().subpaths.len(), 2, "{params}");
+ assert_eq!(fill_cap.path_data().unwrap().subpaths.len(), 1, "{params}");
+ let shade = |f: &Node, i: usize, of: f32| fill_rgb(f)[i] / of;
+ assert!((shade(fill_cap, 0, 0.8) - shade(stroke_cap, 2, 0.9)).abs() < 1e-5, "{params}: one plane, one light");
+ if !flat {
+ assert!(faces.iter().filter(|f| blue(f)).count() > 2 && faces.iter().filter(|f| !blue(f)).count() > 1, "{params}: walls of both");
+ }
+ }
+}
+
+/// A stroked open path builds a ribbon, the stroke's outline, not the area the path would enclose
+/// if it were closed: for an L of two 100 pt legs, a 6 pt band with butt ends and a mitered corner.
+#[test]
+fn a_stroked_open_path_builds_a_ribbon() {
+ let mut b = BezPath::new();
+ b.move_to((100.0, 100.0));
+ b.line_to((200.0, 100.0));
+ b.line_to((200.0, 200.0));
+ for id in [EXTRUDE, INFLATE] {
+ let mut n = Node::path(NodeId(1), PathData::from_bezpath(&b), Appearance::basic(Paint::None, Paint::solid(BLUE), 6.0));
+ n.appearance.effects.push(fx(id, json!({"rotationX": 0, "rotationY": 0, "rotationZ": 0, "volume": 0})));
+ let art = solid_art(&n).unwrap();
+ let faces = faces(&art);
+ assert!(faces.iter().all(|f| blue(f)), "{id}");
+ assert_rect(extent(&faces), 100.0, 97.0, 203.0, 200.0);
+ let area: f64 = faces.iter().map(|f| f.path_data().unwrap().to_bezpath().area().abs()).sum();
+ // 6 × 200 less the 3 × 3 the legs share, plus the 3 × 3 miter.
+ assert!((area - 1200.0).abs() < 1e-6, "{id}: {area}");
+ }
+}
+
+/// A stroke whose outline takes more points than a solid takes is left out, and the fill's solid
+/// still draws.
+#[test]
+fn a_stroke_past_the_limits_is_left_out() {
+ // 1,500 corners: within the 2,048 points of the fill's solid, but not the stroke's outline.
+ let points: Vec = (0..1500)
+ .map(|k| {
+ let (s, c) = (k as f64 * std::f64::consts::TAU / 1500.0).sin_cos();
+ let r = if k % 2 == 0 { 100.0 } else { 96.0 };
+ Point::new(200.0 + r * c, 200.0 + r * s)
+ })
+ .collect();
+ let path = PathData::single(vectorcraft_geom::SubPath::polyline(&points, true));
+ for id in [EXTRUDE, INFLATE] {
+ let mut n = Node::path(NodeId(1), path.clone(), Appearance::basic(Paint::solid(RED), Paint::solid(BLUE), 2.0));
+ n.appearance.effects.push(fx(id, json!({})));
+ let art = solid_art(&n).unwrap_or_else(|| panic!("{id}: the fill's solid draws"));
+ assert!(!faces(&art).is_empty() && faces(&art).iter().all(|f| !blue(f)), "{id}");
+ }
+}
+
+/// At no volume Inflate's front is flat: turned, the fill's cells are all drawn before the stroke's,
+/// whatever their depths, as the extrusion's caps are. When the fill puffs, a stroke too narrow to
+/// puff on the grid stays flat and keeps its depths: the fill's puff is drawn over its far side.
+#[test]
+fn a_flat_inflate_draws_the_strokes_front_above_the_fills() {
+ // On the 100 pt square's grid (cells 101 / 48 pt apart from 99.5) no grid point falls inside a
+ // 1 pt stroke, so the stroke stays flat.
+ for (volume, width, length) in [(0.0, 6.0, 300.0), (50.0, 1.0, 100.0)] {
+ let mut n = stroked_rect(length);
+ if let Some(AppearanceItem::Stroke(s)) = n.appearance.items.iter_mut().find(|i| matches!(i, AppearanceItem::Stroke(_))) {
+ s.width = width;
+ }
+ n.appearance.effects.push(fx(INFLATE, json!({ "volume": volume })));
+ let art = solid_art(&n).unwrap();
+ let faces = faces(&art);
+ let first_blue = faces.iter().position(|f| blue(f)).unwrap();
+ let last_red = faces.iter().rposition(|f| !blue(f)).unwrap();
+ assert_eq!(last_red < first_blue, volume == 0.0, "{volume}: red at {last_red}, blue from {first_blue} of {}", faces.len());
+ }
+}
+
+/// With Perspective one eye sees the fill's puff and the stroke's, however much higher one rises:
+/// seen from behind, the back of a stroke aligned outside meets the fill's back exactly.
+#[test]
+fn inflate_sees_the_fill_and_the_stroke_from_one_eye() {
+ let mut n = stroked_rect(100.0);
+ if let Some(AppearanceItem::Stroke(s)) = n.appearance.items.iter_mut().find(|i| matches!(i, AppearanceItem::Stroke(_))) {
+ s.align = vectorcraft_doc::StrokeAlign::Outside;
+ }
+ let params = json!({"volume": 100, "depth": 100, "perspectiveAngle": 120, "rotationX": 15, "rotationY": 160, "rotationZ": 0});
+ n.appearance.effects.push(fx(INFLATE, params));
+ let art = solid_art(&n).unwrap();
+ let [.., fill_back, stroke_back] = faces(&art)[..] else { panic!("two backs") };
+ assert!(!blue(fill_back) && blue(stroke_back));
+ let fill = fill_back.path_data().unwrap().bounds().unwrap();
+ // The ring's inner contour: the smaller of its two.
+ let rims = stroke_back.path_data().unwrap().subpaths.iter().filter_map(|s| PathData::new(vec![s.clone()]).bounds());
+ let hole = rims.reduce(|a, b| a.intersect(b)).unwrap();
+ assert_rect(hole, fill.x0, fill.y0, fill.x1, fill.y1);
+}
+
+/// A stroke with its own transparency or blending is a surface of its own above the fill's, so its
+/// opacity applies to the stroke as a whole.
+#[test]
+fn a_translucent_stroke_is_a_surface_of_its_own() {
+ for (opacity, blend) in [(0.5, BlendMode::Normal), (1.0, BlendMode::Multiply)] {
+ let mut n = stroked_rect(100.0);
+ if let Some(AppearanceItem::Stroke(s)) = n.appearance.items.iter_mut().find(|i| matches!(i, AppearanceItem::Stroke(_))) {
+ s.opacity = opacity;
+ s.blend = blend;
+ }
+ n.appearance.effects.push(fx(EXTRUDE, json!({})));
+ let art = solid_art(&n).unwrap();
+ let surfaces = art.children().unwrap();
+ assert_eq!(surfaces.len(), 2);
+ assert_eq!((surfaces[0].opacity, surfaces[0].blend), (1.0, BlendMode::Normal));
+ assert_eq!((surfaces[1].opacity, surfaces[1].blend), (opacity, blend));
+ assert!(surfaces[0].children().unwrap().iter().all(|f| !blue(f)) && surfaces[1].children().unwrap().iter().all(|f| blue(f)));
+ }
+}
+
+/// With a light that is not white, a fill in a gradient with transparent stops is drawn with an
+/// opacity mask over its whole surface: the fill's solid and the stroke's stay surfaces of their
+/// own, and the mask stays on the fill's. Under a white light the same object is one surface.
+#[test]
+fn a_masked_surface_under_a_colored_light_stays_whole() {
+ use vectorcraft_doc::color::{Gradient, GradientKind, GradientPaint, GradientStop};
+ let mut half = GradientStop::new(1.0, RED);
+ half.opacity = 0.5;
+ let gradient = GradientPaint::new(Gradient { kind: GradientKind::Linear, stops: vec![GradientStop::new(0.0, RED), half] });
+ for (lights, surfaces) in [(json!({"lights": [{"color": "#ff8080"}]}), 2), (json!({}), 1)] {
+ let mut n = stroked_rect(100.0);
+ if let Some(AppearanceItem::Fill(f)) = n.appearance.items.iter_mut().find(|i| matches!(i, AppearanceItem::Fill(_))) {
+ f.paint = Paint::Gradient(Box::new(gradient.clone()));
+ }
+ n.appearance.effects.push(fx(EXTRUDE, lights.clone()));
+ let art = solid_art(&n).unwrap();
+ let drawn = art.children().unwrap();
+ assert_eq!(drawn.len(), surfaces, "{lights}");
+ assert_eq!(drawn[0].extras().mask.is_some(), surfaces == 2, "{lights}");
+ }
+}
+
#[test]
fn transparency_stays_on_the_whole_surface_and_items_take_their_own_effect() {
let mut n = square_node();
@@ -230,9 +448,9 @@ fn effects_before_it_shape_the_solid_and_effects_after_it_bend_the_result() {
let mut n = square_node();
n.appearance.effects.push(fx("path.offsetPath", json!({"offset": 20})));
n.appearance.effects.push(fx(EXTRUDE, json!({"rotationX": 0, "rotationY": 0, "rotationZ": 0, "perspectiveAngle": 0})));
- // Straight on, the extrusion shows its front: the offset square.
+ // Straight on, the extrusion shows its front: the offset square and its 4 pt stroke.
let b = solid_art(&n).unwrap().visual_bounds().unwrap();
- assert!((b.width() - 140.0 - 0.75).abs() < 1e-6, "{b:?}");
+ assert!((b.width() - 144.0 - 0.75).abs() < 1e-6, "{b:?}");
n.appearance.effects.push(fx("distort.twist", json!({"angle": 30})));
let art = solid_art(&n).unwrap();
assert!(art.appearance.effects.iter().any(|e| e.id == "distort.twist"), "applied to the result as a whole");
@@ -316,6 +534,9 @@ fn colored_solid_inflate_batches_channels_and_clips_once_per_surface() {
}
let (groups, clips, paths) = count(&art);
assert!(paths > 1000, "exercise a tessellated surface");
- assert_eq!(clips, 1);
- assert_eq!(groups, 7, "group count must not grow with triangle count");
+ // The fill's solid and the stroke's, each one composite with its own clip.
+ let surfaces = art.children().unwrap().len();
+ assert_eq!(surfaces, 2);
+ assert_eq!(clips, surfaces);
+ assert_eq!(groups, 1 + 6 * surfaces, "group count must not grow with triangle count");
}
diff --git a/crates/engine/src/cmd/appearance.rs b/crates/engine/src/cmd/appearance.rs
index 7c9f6337cf..84dc1f3c04 100644
--- a/crates/engine/src/cmd/appearance.rs
+++ b/crates/engine/src/cmd/appearance.rs
@@ -15,7 +15,9 @@
//! layer's own fills and strokes paint its members' geometry and its effects apply to them as one
//! piece; the Contents row (type: Characters) is the slot that says which of its fills and strokes
//! paint below the members and which above ([`Appearance::contents_at`], moved by
-//! `appearance.moveItem {from: "contents"}`).
+//! `appearance.moveItem {from: "contents"}`). An image's own fills and strokes paint only the
+//! shape that a Convert to Shape or Outline Object effect on them gives them, below or above the
+//! image as its Contents row says; new ones go right below that row.
use serde_json::{Value, json};
use vectorcraft_color::{BlendMode, Paint};
@@ -36,7 +38,7 @@ pub fn specs() -> Vec {
"Add New Fill",
["Window", "Appearance"],
None,
- "{ids?|id?, target?: \"object\"|\"contents\"} add a fill on top of each selected object's own stack (a copy of its top fill; type without one: its characters' fill; else the default fill)",
+ "{ids?|id?, target?: \"object\"|\"contents\"} add a fill on top of each selected object's own stack, on an image right below its Contents row (a copy of its top fill; type without one: its characters' fill; else the default fill)",
has_doc,
|s, p| add_item(s, p, true)
),
@@ -45,7 +47,7 @@ pub fn specs() -> Vec {
"Add New Stroke",
["Window", "Appearance"],
None,
- "{ids?|id?, target?} add a stroke on top of each selected object's own stack (a copy of its top stroke, else the default stroke)",
+ "{ids?|id?, target?} add a stroke on top of each selected object's own stack, on an image right below its Contents row (a copy of its top stroke, else the default stroke)",
has_doc,
|s, p| add_item(s, p, false)
),
@@ -408,6 +410,9 @@ fn set_active_item(s: &mut Session, p: &Value) -> Result {
fn add_item(s: &mut Session, p: &Value, fill: bool) -> Result {
let ids = require_targets(s, p, if fill { "appearance.addFill" } else { "appearance.addStroke" })?;
let defaults = s.paint.clone();
+ // Where the new item went in on the active item's object, when it is an image.
+ let active = s.active_appearance_item.as_ref().and_then(|a| a.objects.first().copied());
+ let mut inserted = None;
s.edit(if fill { "Add New Fill" } else { "Add New Stroke" }, |d, _| {
for id in &ids {
if let Some(n) = d.node_mut(*id) {
@@ -429,11 +434,23 @@ fn add_item(s: &mut Session, p: &Value, fill: bool) -> Result {
} else {
AppearanceItem::Stroke(StrokeLayer::new(paint, n.appearance.stroke_width().max(1.0)))
};
- n.appearance.items.push(item);
+ if matches!(n.kind, NodeKind::Image(_)) {
+ // On an image it goes right below the Contents row (the image).
+ let k = n.appearance.contents_at();
+ n.appearance.items.insert(k, item);
+ n.appearance.set_contents_at(k + 1);
+ if active == Some(*id) {
+ inserted = Some(k);
+ }
+ } else {
+ n.appearance.items.push(item);
+ }
}
}
Ok(())
})?;
+ // The rows above the new item move up by one.
+ s.remap_appearance_item(&ids, |a| Some(a + usize::from(inserted.is_some_and(|k| k <= a))));
ok()
}
@@ -478,7 +495,7 @@ fn transfer(s: &mut Session, p: &Value) -> Result {
if let (Some(f), Some(t)) = (src.geometric_bounds(), to.geometric_bounds()) {
ap.rebase_gradients(f, t);
}
- // Only groups, layers and type have a Contents (Characters) row to keep a slot for.
+ // Only groups, layers, type and images have a Contents (Characters) row to keep a slot for.
if to.contents_label().is_none() {
ap.contents_index = None;
}
@@ -717,7 +734,7 @@ fn move_contents(s: &mut Session, ids: &[NodeId], to: usize) -> Result {
n.appearance.set_contents_at(to);
slot.get_or_insert(n.appearance.contents_at());
}
- slot.ok_or_else(|| bad("appearance.moveItem", "only groups, layers and type have a Contents (Characters) row"))?;
+ slot.ok_or_else(|| bad("appearance.moveItem", "only groups, layers, type and images have a Contents (Characters) row"))?;
Ok(count_changed(d, &before, ids))
})?;
Ok(json!({ "contents": slot }))
diff --git a/crates/engine/src/cmd/brushsym.rs b/crates/engine/src/cmd/brushsym.rs
index ba69114081..61e9949935 100644
--- a/crates/engine/src/cmd/brushsym.rs
+++ b/crates/engine/src/cmd/brushsym.rs
@@ -89,7 +89,7 @@ pub fn specs() -> Vec {
"Brush Options…",
[],
None,
- "{name, params?: {…fields to change (brush.get shows them; values outside their ranges are clamped). calligraphic: angle −180..180°, roundness 0..100%, size 0..1296 pt, variation: [angle°, roundness%, size pt], modes: [fixed|random|pressure for angle, roundness, size] (pressure goes from value − variation at the lightest pen pressure to value + variation at the heaviest). scatter: size [a, b] 1..10000%, spacing [a, b] 1..10000%, scatter [a, b] −1000..1000%, rotation [a, b] −180..180°, modes: [fixed|random|pressure for size, spacing, scatter, rotation] (fixed: a; random: between a and b; pressure: a at the lightest pen pressure to b at the heaviest), rotation_relative_to_path. art: width 1..1000%, scale: {mode: proportional|stretch|betweenGuides, start, end: 0..1 of the art length}, direction: leftToRight|rightToLeft|topToBottom|bottomToTop, flip_along, flip_across. pattern: scale 1..10000%, spacing 0..10000%, fit: stretch|addSpace|approximate, flip_along, flip_across. scatter, art and pattern: colorization: {method: none|tints|tintsAndShades|hueShift, key: colour (hueShift: the art colour that becomes the stroke colour)}}, newName? (trimmed; blank: the name 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°, roundness 0..100%, size 0..1296 pt, variation: [angle°, roundness%, size pt], modes: [fixed|random|pressure for angle, roundness, size] (pressure goes from value − variation at the lightest pen pressure to value + variation at the heaviest). scatter: size [a, b] 1..10000%, spacing [a, b] 1..10000%, scatter [a, b] −1000..1000%, rotation [a, b] −180..180°, modes: [fixed|random|pressure for size, spacing, scatter, rotation] (fixed: a; random: between a and b; pressure: a at the lightest pen pressure to b at the heaviest), rotation_relative_to_path. art: width 1..1000%, 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. scatter, art and pattern: colorization: {method: none|tints|tintsAndShades|hueShift, key: colour (hueShift: the art colour that becomes the stroke colour)}}, newName? (trimmed; blank: the name is kept)} edit a brush definition (strokes using it update) → {name}",
has_doc,
brush_options
),
diff --git a/crates/engine/src/cmd/clipboard.rs b/crates/engine/src/cmd/clipboard.rs
index 5dae8205a5..23a6b9dfad 100644
--- a/crates/engine/src/cmd/clipboard.rs
+++ b/crates/engine/src/cmd/clipboard.rs
@@ -21,7 +21,7 @@ use vectorcraft_color::Swatch;
use vectorcraft_doc::{Document, GraphicStyle, ImageBlob, Node, NodeId, PatternDef, Symbol, TextStyleDef};
use vectorcraft_geom::Rect;
-pub use flavours::{BITMAP, EMF, EPS, FILE_HEAD, Flavour, PASTE_ORDER, PDF, PNG, SVG, TEXT, file_flavour, is_address, names_a_picture};
+pub use flavours::{AI, BITMAP, EMF, EPS, FILE_HEAD, Flavour, PASTE_ORDER, PDF, PNG, SVG, TEXT, file_flavour, is_address, names_a_picture};
pub(crate) use resources::SwatchChoices;
use super::*;
diff --git a/crates/engine/src/cmd/clipboard/flavours.rs b/crates/engine/src/cmd/clipboard/flavours.rs
index 725b8c5d99..e4ff731404 100644
--- a/crates/engine/src/cmd/clipboard/flavours.rs
+++ b/crates/engine/src/cmd/clipboard/flavours.rs
@@ -30,6 +30,10 @@ pub const EMF: &str = "image/emf";
/// An EPS (or other PostScript) picture: what drawing and typesetting apps copy as vector art
/// beside, or instead of, a PDF (#1499).
pub const EPS: &str = "application/postscript";
+/// A `.ai` or `.ait` file whose bytes are a PDF, copied in a file manager ([`file_flavour`]): Paste
+/// reads it as `document.open` does, from its editing data. The type is VectorCraft's own: no
+/// system clipboard carries it, and Paste asks for [`PDF`] to get it.
+pub const AI: &str = "application/x-ai";
/// What Paste reads from other apps, best first: vector art before text, text before bitmaps
/// (word processors offer a picture of copied text too).
pub const PASTE_ORDER: [&str; 6] = [SVG, PDF, EPS, EMF, TEXT, BITMAP];
@@ -71,8 +75,9 @@ pub const FILE_HEAD: usize = 4096;
/// What a file copied in a file manager pastes as, if one of `mimes` (`image/*`: any bitmap):
/// SVG, PDF, EPS, a Windows metafile or a bitmap (its own `image/…` type), told from its first
-/// [`FILE_HEAD`] bytes and its name. A `.ai` or `.ait` file pastes as PDF when its bytes are a
-/// PDF and as EPS when they are PostScript. The file's bytes are that flavour's data.
+/// [`FILE_HEAD`] bytes and its name. A `.ai` or `.ait` file is [`AI`] when its bytes are a PDF (it
+/// pastes when PDF is asked for) and EPS when they are PostScript. The file's bytes are that
+/// flavour's data.
pub fn file_flavour(name: &str, head: &[u8], mimes: &[&str]) -> Option<&'static str> {
let f = fileio::detect(name, head)?;
let (asked, mime) = match f.id {
@@ -83,7 +88,7 @@ pub fn file_flavour(name: &str, head: &[u8], mimes: &[&str]) -> Option<&'static
"pdf" => (PDF, PDF),
"ps" => (EPS, EPS),
"eps" => (EPS, EPS),
- "ai" | "ait" if head.starts_with(b"%PDF") => (PDF, PDF),
+ "ai" | "ait" if head.starts_with(b"%PDF") => (PDF, AI),
"ai" | "ait" if vectorcraft_pdf::is_postscript(head) => (EPS, EPS),
"emf" | "wmf" => (EMF, EMF),
_ if f.raster => (BITMAP, f.mime),
@@ -122,6 +127,13 @@ pub struct Flavour {
const COPY_PNG_SIDE: f64 = 4096.0;
/// Most bytes of text `clipboard.importText` takes.
const MAX_TEXT: usize = 1 << 20;
+/// Most bytes of images the SVG markup may embed and still go out as plain text. A paste reads the
+/// clipboard's text first (eframe reads it on every paste key; on Linux and macOS it is the one
+/// format the app writes, and checking that the clipboard still holds our copy reads it again), so
+/// a placed photo in it made each paste move megabytes of base64 through the system clipboard on
+/// the UI thread, and on a GNOME desktop the app stopped responding (#2213). A copy with more image
+/// data than this offers its SVG under its own type and its PNG, not as text.
+const COPY_TEXT_IMAGE_BYTES: usize = 1 << 20;
pub fn specs() -> Vec {
vec![
@@ -157,7 +169,7 @@ pub fn specs() -> Vec {
"Clipboard Formats",
[],
None,
- "{} → {flavours: [mime…]} what Copy offers other apps for the current clipboard, best first, by the Clipboard Handling preferences: text/plain (a type-only copy's text, else the SVG markup with copyAsSvg), image/svg+xml (copyAsSvg), application/pdf (copyAsPdf), image/png (always; PDF and PNG only for objects with an area); the app publishes them on Copy and Cut",
+ "{} → {flavours: [mime…]} what Copy offers other apps for the current clipboard, best first, by the Clipboard Handling preferences: text/plain (a type-only copy's text, else the SVG markup with copyAsSvg when the images it embeds total at most 1 MiB), image/svg+xml (copyAsSvg), application/pdf (copyAsPdf), image/png (always; PDF and PNG only for objects with an area); the app publishes them on Copy and Cut",
always,
flavours
),
@@ -184,7 +196,7 @@ pub fn specs() -> Vec {
"Load PDF into Clipboard",
[],
None,
- "{dataBase64, page?: 1, password? (an encrypted PDF), center?: [x, y]} replace the clipboard with the objects of one PDF page (with the images, patterns and swatches they use), centred on `center` (default: the first artboard) → {count, warnings}; then run edit.paste",
+ "{dataBase64, page?: 1, password? (an encrypted PDF), editingData?: false (true: the data is a .ai or .ait file, read as document.open reads it; when document.open would use its editing data, every object of that data comes in, each layer's objects in stacking order and a hidden layer's objects hidden; else page `page`), center?: [x, y]} replace the clipboard with the objects of one PDF page, or of a .ai file's editing data (with the images, patterns and swatches they use), centred on `center` (default: the first artboard) → {count, warnings}; then run edit.paste",
has_doc,
import_pdf
),
@@ -202,7 +214,7 @@ pub fn specs() -> Vec {
"Load EPS into Clipboard",
[],
None,
- "{dataBase64 (EPS or other PostScript bytes), center?: [x, y]} replace the clipboard with the picture's objects as document.open reads an EPS (editable paths, type and images, with the images, patterns and swatches they use), centred on `center` (default: the first artboard) → {count, warnings}; then run edit.paste",
+ "{dataBase64 (EPS or other PostScript bytes), center?: [x, y]} replace the clipboard with the picture's objects as document.open reads an EPS (editable paths, type and images, with the images, patterns and swatches they use; a hidden layer's objects hidden), centred on `center` (default: the first artboard) → {count, warnings}; then run edit.paste",
has_doc,
import_eps
),
@@ -263,12 +275,17 @@ impl Clipboard {
fileio::encode_with_warnings(&doc, "pdf", &json!({ "preserveEditing": false })).map(Some)
}
+ /// Bytes of the encoded images the objects show (what their SVG embeds as base64).
+ fn image_bytes(&self) -> usize {
+ self.images.values().fold(0usize, |sum, b| sum.saturating_add(b.bytes.len()))
+ }
+
/// The MIME types of [`Self::flavours`], without making them.
pub fn flavour_types(&self, svg: bool, pdf: bool) -> Vec<&'static str> {
if self.is_empty() {
return vec![];
}
- let text = svg || self.nodes.iter().all(type_only);
+ let text = (svg && self.image_bytes() <= COPY_TEXT_IMAGE_BYTES) || self.nodes.iter().all(type_only);
// Art without an area (a lone guide-like line) has no page or picture.
let area = self.bounds().is_some_and(|b| b.width() > 0.0 && b.height() > 0.0);
[(TEXT, text), (SVG, svg), (PDF, pdf && area), (PNG, area)].into_iter().filter_map(|(m, on)| on.then_some(m)).collect()
@@ -452,8 +469,19 @@ fn import_eps(s: &mut Session, p: &Value) -> Result {
/// Replace the clipboard with the objects of the picture `bytes`, read as the file `name` is
/// opened (command `cmd`).
fn import_picture(s: &mut Session, p: &Value, cmd: &str, name: &str, bytes: &[u8]) -> Result {
- let mut loaded = fileio::load(name, bytes).map_err(|e| bad(cmd, e.to_string()))?;
+ let loaded = fileio::load(name, bytes).map_err(|e| bad(cmd, e.to_string()))?;
+ import_loaded(s, p, cmd, loaded)
+}
+
+/// Replace the clipboard with every object of `loaded`, a file read as `document.open` reads it
+/// (command `cmd`). The layers are left out, and the objects of a hidden layer come in hidden.
+fn import_loaded(s: &mut Session, p: &Value, cmd: &str, mut loaded: fileio::Loaded) -> Result {
loaded.doc.drop_edit_modes();
+ for layer in loaded.doc.layers.iter_mut().filter(|l| !l.visible) {
+ for object in std::sync::Arc::make_mut(layer).children_mut().into_iter().flatten() {
+ std::sync::Arc::make_mut(object).visible = false;
+ }
+ }
let clip = Clipboard::from_document(&loaded.doc);
if clip.is_empty() {
return Err(bad(cmd, "the picture has no objects"));
@@ -469,7 +497,19 @@ fn import_pdf(s: &mut Session, p: &Value) -> Result {
None | Some(Value::Null) => 1,
Some(v) => v.as_u64().filter(|n| (1..=100_000).contains(n)).ok_or_else(|| bad(C, "page must be a whole number from 1"))? as usize,
};
+ let editing = match p.get("editingData").filter(|v| !v.is_null()) {
+ None => false,
+ Some(v) => v.as_bool().ok_or_else(|| bad(C, "editingData must be true or false"))?,
+ };
let opts = fileio::LoadOptions { password: str_param(p, "password").map(str::to_string), ..Default::default() };
+ // A copied .ai file pastes every object of its editing data, as document.open reads the file.
+ // When document.open would not use that copy, the file pastes its page, as a PDF does.
+ if editing
+ && let Ok(loaded) = fileio::load_with("Clipboard.ai", &bytes, &opts)
+ && (loaded.editing_data || loaded.restored)
+ {
+ return import_loaded(s, p, C, loaded);
+ }
let (mut doc, warnings) = fileio::page_document(&bytes, page - 1, &opts).map_err(|e| bad(C, e.to_string()))?;
doc.drop_edit_modes();
let clip = Clipboard::from_document(&doc);
diff --git a/crates/engine/src/cmd/effectcmd.rs b/crates/engine/src/cmd/effectcmd.rs
index d0f0d16143..e4660bf67a 100644
--- a/crates/engine/src/cmd/effectcmd.rs
+++ b/crates/engine/src/cmd/effectcmd.rs
@@ -408,6 +408,7 @@ fn expandable(n: &Node) -> bool {
!n.appearance.items.is_empty() || !n.appearance.effects.is_empty() || children.iter().any(|c| expandable(c))
}
NodeKind::Text(_) => !n.appearance.items.is_empty() || !n.appearance.effects.is_empty(),
+ NodeKind::Image(_) => effects::has_item_geometry(n) || !n.appearance.effects.is_empty(),
_ => !n.appearance.effects.is_empty(),
}
}
diff --git a/crates/engine/src/cmd/expand.rs b/crates/engine/src/cmd/expand.rs
index 3fec18331f..ebeacf63a4 100644
--- a/crates/engine/src/cmd/expand.rs
+++ b/crates/engine/src/cmd/expand.rs
@@ -290,7 +290,7 @@ fn expand_fills(d: &mut Document, l: &Node, to: GradientTo) -> Option {
for item in &l.appearance.items {
// Items that paint nothing go; a gradient that can't be expanded stays.
let art = gradient_fill(item).and_then(|(f, g)| {
- let (fl, path, bounds) = fill_shape(l, f, &path, bounds)?;
+ let (fl, path, bounds) = fill_shape(l, item, &path, bounds)?;
gradient_art(d, &fl, &path, bounds, f, g, to)
});
let Some(art) = art else {
@@ -363,15 +363,16 @@ fn reshaped(l: &Node) -> Option {
Some(m)
}
-/// Path `l` (outline `path`, box `bounds`) as fill `f` paints it on the canvas, with its outline
-/// and box: when the fill has visible geometry effects, `l` with the outline they make of `path`
-/// as a plain path, and that outline's box.
-fn fill_shape(l: &Node, f: &FillLayer, path: &PathData, bounds: Rect) -> Option<(Node, PathData, Rect)> {
+/// Path `l` (outline `path`, box `bounds`) as its fill `item` paints it on the canvas, with its
+/// outline and box: when the fill has visible geometry effects, `l` with the outline they make of
+/// `path` as a plain path, and that outline's box.
+fn fill_shape(l: &Node, item: &AppearanceItem, path: &PathData, bounds: Rect) -> Option<(Node, PathData, Rect)> {
use vectorcraft_render::effects::{GeomContext, apply_geometry_with, has_geometry};
- if !has_geometry(&f.effects) {
+ if !has_geometry(item.effects()) {
return Some((l.clone(), path.clone(), bounds));
}
- let outline = apply_geometry_with(&f.effects, path, bounds, &GeomContext::of(l));
+ // In the fill's context, as drawing runs them: a plug-in effect is told which fill it is on.
+ let outline = apply_geometry_with(item.effects(), path, bounds, &GeomContext::of(l).item(item));
let b = outline.bounds()?;
Some((with_path(l, outline.clone()), outline, b))
}
@@ -432,7 +433,7 @@ fn expand_patterns(d: &mut Document, l: &Node) -> Option {
for item in &l.appearance.items {
let fill = pattern_fill(d, item).map(|(f, def, xf)| (f, def.clone(), xf));
let tiles = fill.and_then(|(f, def, xf)| {
- let (fl, _, bounds) = fill_shape(l, f, &path, bounds)?;
+ let (fl, _, bounds) = fill_shape(l, item, &path, bounds)?;
let t = pattern_tiles(d, &def, xf, bounds);
(!t.is_empty()).then_some((f, fl, t))
});
diff --git a/crates/engine/src/cmd/fileio/encode.rs b/crates/engine/src/cmd/fileio/encode.rs
index 8dda63ee4a..ae705ca483 100644
--- a/crates/engine/src/cmd/fileio/encode.rs
+++ b/crates/engine/src/cmd/fileio/encode.rs
@@ -411,6 +411,9 @@ pub fn encode_all(doc: &Document, format: &str, p: &Value) -> Result {
/// [`encode_all`] of `doc` as it is.
fn encode_all_of(doc: &Document, format: &str, p: &Value) -> Result {
let f = super::writable(C, Some(format), None)?;
+ if let Some(plugin) = vectorcraft_plugins::export::by_format(f.id) {
+ return plugin_file(doc, &plugin, f, p);
+ }
let failed = vectorcraft_render::decode_failures();
let mut enc = encode_files(doc, f, p)?;
// Baking, flattening and drawing stop early when cancelled and leave a truncated result.
@@ -432,6 +435,32 @@ fn encode_all_of(doc: &Document, format: &str, p: &Value) -> Result {
Ok(enc)
}
+/// 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.
+fn plugin_file(doc: &Document, plugin: &vectorcraft_plugins::Plugin, f: &Format, p: &Value) -> Result {
+ use vectorcraft_plugins::{Error, export};
+ let doc = &*doc.without_edit_modes();
+ 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));
+ let extension = listed.or(f.extensions.first().copied()).unwrap_or_default();
+ let name = super::file_stem(path.unwrap_or(&super::default_name(doc, extension)));
+ let params = p.get("params").cloned().unwrap_or(Value::Null);
+ let target = export::Target { extension, name: &name };
+ let out = export::run(plugin, vectorcraft_format::json_part(&file), ¶ms, target).map_err(|e| match e {
+ Error::Cancelled => EngineError::Cancelled,
+ Error::Params(why) => bad(C, why),
+ e => EngineError::Other(e.to_string()),
+ })?;
+ // The plug-in's output, so reported as its other output errors are.
+ let invalid = || EngineError::Other(Error::Output("`dataBase64` is not valid base64".into()).to_string());
+ let bytes = vectorcraft_format::base64_decode(&out.data_base64).ok_or_else(invalid)?;
+ Ok(Encoded { warnings: out.warnings, ..Encoded::one(bytes) })
+}
+
/// [`encode_all`] without the font substitution warning.
fn encode_files(doc: &Document, f: &Format, p: &Value) -> Result {
let doc = &*doc.without_edit_modes();
diff --git a/crates/engine/src/cmd/fileio/load.rs b/crates/engine/src/cmd/fileio/load.rs
index f50728c43c..748843179d 100644
--- a/crates/engine/src/cmd/fileio/load.rs
+++ b/crates/engine/src/cmd/fileio/load.rs
@@ -26,6 +26,9 @@ pub struct Loaded {
/// Only a stand-in picture of the file (an Affinity document whose native data couldn't be
/// read): Open shows it with its warning; Place, templates and libraries refuse it.
pub preview_only: bool,
+ /// A PDF, or a `.ai` or `.ait` that holds a PDF, read through the editor's own copy of its art
+ /// that it carries (its layers), not from its PDF part alone.
+ pub editing_data: bool,
}
impl Loaded {
@@ -159,17 +162,17 @@ pub fn load(name: &str, bytes: &[u8]) -> Result {
/// of its art, which it carries: its layers and hidden objects as they were, and the art outside
/// its artboard (its PDF part has only what is on the artboards), as an EPS of the editor is read.
/// Anything else as it was. `unit`: the size in points of a unit of the PDF part's user space (its
-/// first page's `UserUnit`).
-fn through_editing_data(bytes: &[u8], opts: &LoadOptions, doc: Document, warnings: Vec, unit: f64) -> (Document, Vec) {
+/// first page's `UserUnit`) → (document, warnings, whether its layers were read).
+fn through_editing_data(bytes: &[u8], opts: &LoadOptions, doc: Document, warnings: Vec, unit: f64) -> (Document, Vec, bool) {
if opts.pages.is_some() || !opts.layers || !opts.editing_data {
- return (doc, warnings);
+ return (doc, warnings, false);
}
- let Some(private) = vectorcraft_pdf::illustrator_data(bytes, opts.password.as_deref()) else { return (doc, warnings) };
+ let Some(private) = vectorcraft_pdf::illustrator_data(bytes, opts.password.as_deref()) else { return (doc, warnings, false) };
let outlined = opts.text_as == vectorcraft_pdf::TextAs::Outlines;
let (doc, mut warnings, read) = vectorcraft_eps::layered_ai(&private, doc, warnings, outlined, opts.trust_editing_data, unit);
// The layers weren't read (or couldn't be): the notes of reading the PDF part still hold.
if !read {
- return (doc, warnings);
+ return (doc, warnings, false);
}
// The layers' text objects hold type and the stroked paths around it, which can include stroked
// glyphs the PDF part kept as outlines: without any such glyph in the document, the warnings on
@@ -180,7 +183,7 @@ fn through_editing_data(bytes: &[u8], opts: &LoadOptions, doc: Document, warning
// The layers hold the art that the PDF part leaves out or, in a PDF, that the import clipped
// to the page.
warnings.retain(|w| w != vectorcraft_pdf::OFF_ARTBOARD_NOTE && w != vectorcraft_pdf::PAST_PAGE_NOTE);
- (doc, warnings)
+ (doc, warnings, true)
}
/// A `.ai` saved without PDF compatibility (its PDF part is a placeholder page) from the editor's
@@ -212,6 +215,7 @@ pub fn load_with(name: &str, bytes: &[u8], opts: &LoadOptions) -> Result
let title = file_name(name);
let mut converted = false;
let mut preview_only = false;
+ let mut editing_data = false;
let (mut doc, mut warnings, restored) = match format.id {
// EPS, .ps and PostScript .ai: the document our EPS files carry, else the PostScript read.
_ if matches!(format.id, "eps" | "ps") || vectorcraft_pdf::is_postscript(bytes) => {
@@ -246,13 +250,20 @@ pub fn load_with(name: &str, bytes: &[u8], opts: &LoadOptions) -> Result
// Pages of text alone: the editing copy alone where it reads, as for a file
// saved without its PDF part (#1387: else the page, which is the art).
let alone = r.only_text.then(|| from_editing_data_alone(bytes, opts)).flatten().and_then(|read| read.ok());
- Ok(alone.unwrap_or_else(|| through_editing_data(bytes, opts, r.document, r.warnings, r.user_unit)))
+ let (doc, warnings, read) = match alone {
+ Some((doc, warnings)) => (doc, warnings, true),
+ None => through_editing_data(bytes, opts, r.document, r.warnings, r.user_unit),
+ };
+ editing_data = read;
+ Ok((doc, warnings))
}
// Saved without its PDF part: the editing copy is all the file has (`pages` that
// name every page read it as the whole file).
Err(e) if e.to_string() == vectorcraft_pdf::PdfError::PlaceholderOnly.to_string() => {
let whole = LoadOptions { pages: None, ..opts.clone() };
- from_editing_data_alone(bytes, if every_page(bytes, opts) { &whole } else { opts }).unwrap_or(Err(e))
+ from_editing_data_alone(bytes, if every_page(bytes, opts) { &whole } else { opts })
+ .unwrap_or(Err(e))
+ .inspect(|_| editing_data = true)
}
Err(e) => Err(e),
})?
@@ -298,7 +309,7 @@ pub fn load_with(name: &str, bytes: &[u8], opts: &LoadOptions) -> Result
doc.title = title;
}
warnings.extend(doc.images.values().filter_map(|b| too_large_note(&b.bytes)));
- Ok(Loaded { doc, format, warnings, restored, converted, preview_only })
+ Ok(Loaded { doc, format, warnings, restored, converted, preview_only, editing_data })
}
/// Import SVG text, reading the files its images link to (relative links from `folder`, the SVG's
diff --git a/crates/engine/src/cmd/fileio/mod.rs b/crates/engine/src/cmd/fileio/mod.rs
index a827e93d9a..c360fd813d 100644
--- a/crates/engine/src/cmd/fileio/mod.rs
+++ b/crates/engine/src/cmd/fileio/mod.rs
@@ -127,7 +127,7 @@ pub fn specs() -> Vec {
"Export Document",
[],
None,
- "{path?, format?: svg|svgz|pdf|ai|png|jpg|webp|gif|png8|txt|dxf|eps|emf|wmf|tiff|bmp|tga|psd|vectorcraft|template (default: from the path's extension, else png; png8 writes an indexed .png; ait, a .ait template, is written by file.saveAsTemplate), selectedOnly?: false (the selected objects alone, in their layers), artboard?: 0, artboards?: [i…], rect?: [x, y, width, height] (raster formats: that area of the page in points, y down, instead of an artboard; not with artboard, artboards, range or useArtboards), range?: \"1-3, 5\" | \"all\" (1-based; PDF and .ai write one page per artboard, default all; SVG writes one file per artboard, {stem}-{artboard}.svg; raster formats write one artboard), useArtboards?: true (raster: one file per chosen artboard, default all, {stem}-{artboard}.{ext}; pdf/ai: every page) | false (pdf/ai/raster: the bounds of the visible art; SVG has it as an SVG option), ppi?: 72 (raster formats: pixels per inch, stored in the file; wins over scale), scale?: 1 (pixels per point), background?: transparent|white|black|\"#rrggbb\" (jpg: white when transparent), antiAlias?: none|art (default)|type (text snapped to pixels), interlaced?: false (png, Adam7), embedIcc?: true (png: an sRGB chunk marks the colours as sRGB), quality?: 90 (jpg: 0–100), colorModel?: rgb|cmyk|gray (jpg), method?: baseline|optimized|progressive, scans?: 3 (3–5, progressive), embedIcc?: true, imageMap?: none|client|server (an HTML or NCSA map of the objects with a URL, written as .html / .map), colors?: 256 (gif/png8: 2–256), reduction?: perceptual|selective (default)|adaptive|web|blackWhite|gray, dither?: none|diffusion (default)|pattern|noise, ditherAmount?: 100, transparency?: true, matte?: white|\"#rrggbb\"|none, interlaced?, lossless?: true (webp: lossy WebP isn't available yet: written lossless, with a warning), encoding?: utf8|utf16 (txt: the stories in stacking order, back to front, a thread once; utf16 with a byte order mark), lineEndings?: lf|crlf, selectionOnly?: false, svg?: {styling, outlineText, images, objectIds, decimals, minify, responsive, useArtboards, preserveEditing, metadata, fewerTspans, hiddenLayers, encoding, profile, embedFonts} (see document.formats), …the SVG options given flat instead, …the PDF options of document.exportPdf, …the DXF options of document.exportDxf (useArtboards: one drawing per artboard), …the EPS options of document.exportEps (useArtboards: one file per artboard, {stem}_{artboard}.eps; else the visible art), …emf and wmf write one picture of the artboard (useArtboards: true one file per chosen artboard, false the bounds of the visible art; EMF keeps curves, clipping, transparent images and gradients as images clipped to their shape; WMF flattens curves into polygons behind a placeable header; what a format leaves out comes back in warnings), colorModel?: rgb|cmyk|gray (tiff: rgb keeps transparency as an alpha channel), lzw?: true, byteOrder?: little|big, embedIcc?: true, colorModel?: rgb|gray (bmp), depth?: 24 (bmp: 1 black and white, 4|8 a palette by reduction and dither, 16, 24, 32 with alpha), fileFormat?: windows|os2 (1, 4, 8 or 24 bits), rle?: false (4 and 8 bits, windows), flipRows?: false (top-down rows), depth?: 24 (tga: 16 one-bit alpha, 24, 32 with alpha), colorModel?: rgb|cmyk|gray (psd), layers?: true (each top-level layer a pixel layer with its opacity and blend mode; a background colour is a Background layer; false: one flat image, on white), maxEditability?: false (layers and sublayers become groups, each object a layer named as in the Layers panel, text by its text; clipping, masked or knockout layers stay one layer), hiddenLayers?: false (hidden layers and objects written hidden instead of left out), embedIcc?: true (at most 30000 pixels a side; formats without alpha are flattened on white)} → {path, format, bytes, warnings, files?: [path…] (several), linked?: [path…] (linked images, image maps)}; no path → {dataBase64, format, bytes, warnings, files?: [{name, dataBase64}], linked?: [{name, dataBase64}]}. Never changes the document's path",
+ "{path?, format?: svg|svgz|pdf|ai|png|jpg|webp|gif|png8|txt|dxf|eps|emf|wmf|tiff|bmp|tga|psd|vectorcraft|template (default: from the path's extension, else png; png8 writes an indexed .png; ait, a .ait template, is written by file.saveAsTemplate; an exporter plug-in's format is plugin., which an extension only it lists picks too), params?: {…} (an exporter plug-in's parameters; missing ones take their defaults, see plugin.info), selectedOnly?: false (the selected objects alone, in their layers), artboard?: 0, artboards?: [i…], rect?: [x, y, width, height] (raster formats: that area of the page in points, y down, instead of an artboard; not with artboard, artboards, range or useArtboards), range?: \"1-3, 5\" | \"all\" (1-based; PDF and .ai write one page per artboard, default all; SVG writes one file per artboard, {stem}-{artboard}.svg; raster formats write one artboard), useArtboards?: true (raster: one file per chosen artboard, default all, {stem}-{artboard}.{ext}; pdf/ai: every page) | false (pdf/ai/raster: the bounds of the visible art; SVG has it as an SVG option), ppi?: 72 (raster formats: pixels per inch, stored in the file; wins over scale), scale?: 1 (pixels per point), background?: transparent|white|black|\"#rrggbb\" (jpg: white when transparent), antiAlias?: none|art (default)|type (text snapped to pixels), interlaced?: false (png, Adam7), embedIcc?: true (png: an sRGB chunk marks the colours as sRGB), quality?: 90 (jpg: 0–100), colorModel?: rgb|cmyk|gray (jpg), method?: baseline|optimized|progressive, scans?: 3 (3–5, progressive), embedIcc?: true, imageMap?: none|client|server (an HTML or NCSA map of the objects with a URL, written as .html / .map), colors?: 256 (gif/png8: 2–256), reduction?: perceptual|selective (default)|adaptive|web|blackWhite|gray, dither?: none|diffusion (default)|pattern|noise, ditherAmount?: 100, transparency?: true, matte?: white|\"#rrggbb\"|none, interlaced?, lossless?: true (webp: lossy WebP isn't available yet: written lossless, with a warning), encoding?: utf8|utf16 (txt: the stories in stacking order, back to front, a thread once; utf16 with a byte order mark), lineEndings?: lf|crlf, selectionOnly?: false, svg?: {styling, outlineText, images, objectIds, decimals, minify, responsive, useArtboards, preserveEditing, metadata, fewerTspans, hiddenLayers, encoding, profile, embedFonts} (see document.formats), …the SVG options given flat instead, …the PDF options of document.exportPdf, …the DXF options of document.exportDxf (useArtboards: one drawing per artboard), …the EPS options of document.exportEps (useArtboards: one file per artboard, {stem}_{artboard}.eps; else the visible art), …emf and wmf write one picture of the artboard (useArtboards: true one file per chosen artboard, false the bounds of the visible art; EMF keeps curves, clipping, transparent images and gradients as images clipped to their shape; WMF flattens curves into polygons behind a placeable header; what a format leaves out comes back in warnings), colorModel?: rgb|cmyk|gray (tiff: rgb keeps transparency as an alpha channel), lzw?: true, byteOrder?: little|big, embedIcc?: true, colorModel?: rgb|gray (bmp), depth?: 24 (bmp: 1 black and white, 4|8 a palette by reduction and dither, 16, 24, 32 with alpha), fileFormat?: windows|os2 (1, 4, 8 or 24 bits), rle?: false (4 and 8 bits, windows), flipRows?: false (top-down rows), depth?: 24 (tga: 16 one-bit alpha, 24, 32 with alpha), colorModel?: rgb|cmyk|gray (psd), layers?: true (each top-level layer a pixel layer with its opacity and blend mode; a background colour is a Background layer; false: one flat image, on white), maxEditability?: false (layers and sublayers become groups, each object a layer named as in the Layers panel, text by its text; clipping, masked or knockout layers stay one layer), hiddenLayers?: false (hidden layers and objects written hidden instead of left out), embedIcc?: true (at most 30000 pixels a side; formats without alpha are flattened on white)} → {path, format, bytes, warnings, files?: [path…] (several), linked?: [path…] (linked images, image maps)}; no path → {dataBase64, format, bytes, warnings, files?: [{name, dataBase64}], linked?: [{name, dataBase64}]}. Never changes the document's path",
has_doc,
export::export
),
@@ -199,7 +199,7 @@ pub fn specs() -> Vec {
"File Formats",
[],
None,
- "{} → {formats: [{id, label, extensions, mime, read, write, raster, options: {name: {type, default, description}}}], readable: [id…], writable: [id…], openExtensions: [ext…], unsupported: [{id, label, extensions, hint}] (formats asked for that can be neither opened nor written, such as DWG and PICT, with what to use instead)}",
+ "{} → {formats: [{id, label, extensions, mime, read, write, raster, options: {name: {type, default, description}}, plugin?: the id of the exporter plug-in that adds the format (its id is plugin.; see plugin.list)}], readable: [id…], writable: [id…], openExtensions: [ext…], unsupported: [{id, label, extensions, hint}] (formats asked for that can be neither opened nor written, such as DWG and PICT, with what to use instead)}",
always,
formats
),
@@ -661,7 +661,7 @@ pub const FORMATS: &[Format] = &[
Format { id: "psd", label: "PSD", extensions: &["psd"], mime: "image/x-psd", read: true, write: true, raster: true, options: PSD_OPTIONS },
// Affinity Photo's `.afphoto` opens by its content but isn't listed: Finder shouldn't offer a
// vector app for a raster editor's documents.
- reader("affinity", "Affinity", &["af", "afdesign", "afpub"], "application/vnd.affinity", false),
+ reader("affinity", "Affinity", &["af", "afdesign", "afpub"], "application/x-affinity", false),
// Photoshop's large document format: read like a PSD (its merged image), never written.
reader("psb", "PSB", &["psb"], "image/x-psb", true),
// PostScript programs, read as EPS files are; Print to PostScript writes them, exports don't.
@@ -706,17 +706,19 @@ pub const OPEN_EXTS: &[&str] = &[
"afpub",
];
-/// Extensions in [`OPEN_EXTS`] the desktop packaging doesn't associate with VectorCraft: Photoshop
-/// documents belong to raster editors, so Finder and file managers don't offer a vector app for
-/// them, and the packaging declares no `.epsf`, `.ps` or Targa type. The macOS bundle doesn't
-/// declare JPEG XL images either. File › Open and Place still read them all.
+/// Extensions in [`OPEN_EXTS`] the packaging declares no type for: Photoshop documents belong to
+/// raster editors, so Finder and file managers don't offer a vector app for them, and there is no
+/// `.epsf`, `.ps`, Targa or JPEG XL type (File › Open and Place still read them all). On Linux the
+/// desktop entry's EPS type (shared-mime-info's) also covers `.epsf`, so file managers offer
+/// VectorCraft for it.
pub const UNASSOCIATED_EXTS: &[&str] = &["psd", "psb", "epsf", "ps", "tga", "vda", "icb", "vst", "jxl"];
/// The extension that picks each writable format when exporting (the format's first; PNG-8 shares
/// `.png` with PNG, so `.png` comes once), in [`FORMATS`] order.
pub fn export_extensions() -> Vec<&'static str> {
let mut v: Vec<&'static str> = Vec::new();
- for e in FORMATS.iter().filter(|f| f.write).filter_map(|f| f.extensions.first()) {
+ let added = plugin_formats();
+ for e in FORMATS.iter().chain(added.iter().copied()).filter(|f| f.write).filter_map(|f| f.extensions.first()) {
if !v.contains(e) {
v.push(e);
}
@@ -804,10 +806,47 @@ pub fn place_filters() -> impl Iterator Option<&'static Format> {
let k = id_or_ext.trim_start_matches('.').to_ascii_lowercase();
- FORMATS.iter().find(|f| f.id == k).or_else(|| FORMATS.iter().find(|f| f.extensions.contains(&k.as_str())))
+ FORMATS.iter().find(|f| f.id == k).or_else(|| FORMATS.iter().find(|f| f.extensions.contains(&k.as_str()))).or_else(|| {
+ let added = plugin_formats();
+ added.iter().find(|f| f.id.eq_ignore_ascii_case(&k)).or_else(|| added.iter().find(|f| f.extensions.contains(&k.as_str()))).copied()
+ })
+}
+
+/// The formats the installed exporter plug-ins add ([`vectorcraft_plugins::export`]), by plug-in
+/// id: write only, with the plug-in's name as the label and its extensions. Each is made once for
+/// each installation of its plug-in, its strings interned, so formats live as long as the catalogues
+/// that hold them.
+pub fn plugin_formats() -> Vec<&'static Format> {
+ use vectorcraft_plugins::{export, registry};
+ static MADE: std::sync::Mutex> = std::sync::Mutex::new(Vec::new());
+ let mut made = MADE.lock().unwrap_or_else(|e| e.into_inner());
+ export::installed()
+ .iter()
+ .map(|p| {
+ if let Some((_, f)) = made.iter().find(|(serial, _)| *serial == p.serial()) {
+ return *f;
+ }
+ let m = p.manifest();
+ let extensions: Vec<&'static str> = m.extensions.iter().map(|e| registry::intern(e)).collect();
+ let f: &'static Format = Box::leak(Box::new(Format {
+ id: registry::intern(&export::format_id(&m.id)),
+ label: registry::intern(&m.name),
+ extensions: Box::leak(extensions.into_boxed_slice()),
+ mime: "application/octet-stream",
+ read: false,
+ write: true,
+ raster: false,
+ options: &[],
+ }));
+ made.push((p.serial(), f));
+ f
+ })
+ .collect()
}
/// The lower-case extension of a file name or path (empty when it has none).
@@ -862,9 +901,18 @@ fn writable(cmd: &str, format_param: Option<&str>, path: Option<&str>) -> Result
}
fn formats(_: &mut Session, _: &Value) -> Result {
- let ids = |pick: fn(&Format) -> bool| FORMATS.iter().filter(|f| pick(f)).map(|f| f.id).collect::>();
+ let added = plugin_formats();
+ let all = || FORMATS.iter().chain(added.iter().copied());
+ let ids = |pick: fn(&Format) -> bool| all().filter(|f| pick(f)).map(|f| f.id).collect::>();
+ let listed = |f: &Format| {
+ let mut v = f.to_json();
+ if let Some(id) = vectorcraft_plugins::export::plugin_id(f.id) {
+ v["plugin"] = json!(id);
+ }
+ v
+ };
Ok(json!({
- "formats": FORMATS.iter().map(Format::to_json).collect::>(),
+ "formats": all().map(listed).collect::>(),
"readable": ids(|f| f.read),
"writable": ids(|f| f.write),
"openExtensions": OPEN_EXTS,
diff --git a/crates/engine/src/cmd/fileio/pdfimport.rs b/crates/engine/src/cmd/fileio/pdfimport.rs
index 200cc5c443..e747be71fa 100644
--- a/crates/engine/src/cmd/fileio/pdfimport.rs
+++ b/crates/engine/src/cmd/fileio/pdfimport.rs
@@ -143,13 +143,13 @@ pub(super) fn import(bytes: &[u8], o: &LoadOptions, editor_document: bool) -> Re
}
/// Page `page` (0-based) of a PDF as a document of one artboard (its `o.crop` box) and one
-/// layer of what it shows (text as outlines: it looks as printed), and the import notes.
+/// layer of what it shows, with the same text choice as Open, and the import notes.
pub fn page_document(bytes: &[u8], page: usize, o: &LoadOptions) -> Result<(Document, Vec)> {
let opts = ImportOptions {
pages: Some(vec![page]),
crop: o.crop,
password: o.password.clone(),
- text_as: TextAs::Outlines,
+ text_as: o.text_as,
layers: false,
..Default::default()
};
@@ -183,15 +183,22 @@ pub(super) fn pdf_info(_: &mut Session, p: &Value) -> Result {
})
.collect();
let mut out = json!({"pages": pages.len(), "needsPassword": false, "pageInfo": pages});
- if let Some(n) = p.get("thumbnail").and_then(Value::as_u64) {
- let page = usize::try_from(n).ok().and_then(|n| n.checked_sub(1)).filter(|i| *i < info.pages.len());
- let page = page.ok_or_else(|| bad(INFO, format!("thumbnail: no page {n} (the PDF has {})", info.pages.len())))?;
+ if let Some(page) = thumbnail_page(p, info.pages.len(), "PDF")? {
let (doc, _) = page_document(&bytes, page, &o)?;
out["thumbnail"] = json!(thumbnail(&doc, p)?);
}
Ok(out)
}
+/// The page (0-based) `document.pdfInfo`'s `thumbnail` names, from 1 to `count`; `None` when it is
+/// absent or null. Any other value (0, a negative or fractional number, a string) is an error that
+/// names the pages the `what` has.
+fn thumbnail_page(p: &Value, count: usize, what: &str) -> Result