mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-10-25 10:17:02 -06:00
dotCooCoo
62fd793603
Object > Expand with Fill expanded gradient fills only. A pattern fill stayed a live pattern, and object.expand.info did not report it, so the dialog's Fill option was disabled for it. In the reference app, Expand with Fill turns a pattern fill into the pattern's tiles, and the shape becomes their clipping mask. The Fill step now turns each visible pattern fill of a path or compound path into a clip group shaped like the object, holding the tiles the pattern lays over the object's box with fresh ids. The group isolates the tiles' blending and takes the fill's opacity, blend mode and other effects. Geometry effects of the fill or the object, such as Offset Path, shape the group's outline and the box the tiles cover. A path in the tile art with a random Transform effect is baked with its own id first, and a path with a brush that varies at random (calligraphic or scatter with Random variation, or bristle) is baked where the pattern defines it first, so every tile matches the canvas. The object's other fills and strokes stay on copies of it in paint order, and Expand stays one undo step. Type with a pattern fill expands the same way once Object outlines it, and object.expand.info reports pattern fills under fill. It also reports gradient fills under a new gradient key, and the dialog enables Expand Gradient To only when the selection has one. A pattern fill stays as it is when it lays no tiles over the box, when a group or type in its art has a random Transform effect, when the pattern is scaled, rotated, reflected, stretched or sheared and its art holds a symbol instance, and when the pattern is rotated, reflected, stretched or sheared, or scaled while its art has geometry effects, and its art has raster or 3D effects, or a geometry effect on a group or type. PatternDef gains instances_in_with, which places the tiles with a given Scaling. Expand has stroke weights, effect distances and the tiles' own pattern paints scale with the pattern's transform. When the pattern is rotated, reflected, stretched or sheared, or scaled while its art has geometry effects such as Roughen, the strokes and geometry effects of the tiles' paths become filled art first (bake_appearance, and Outline Stroke's conversion for brushed strokes), and their live shapes become plain paths, in their opacity masks too. Tiles place their opacity masks with them, unlinked ones included (place_art), which also fixes unlinked masks in pattern tiles in PDF, EPS, EMF and WMF export and in Distort Pattern Fills. Faults in the shared code are fixed for every caller. assemble dropped the effects of a sole part, so Expand lost a lone gradient fill's own effects and Outline Stroke lost those of a stroke with a gradient along or across it. Outline Stroke also dropped a brushed stroke's raster effects from its brush art. Expand replaced an object whose gradient fill could not be expanded with a plain copy; it now leaves it as it was. Expand left the geometry effects of a gradient fill, and with Object off those of the object, on the expanded art, where they reshaped every strip; they now shape the clip group's outline, and the gradient fits it, as for pattern fills. bake_appearance dropped a stroke's raster effects from its filled outline and filled the outline of a stroke with a gradient along or across it with a gradient across the outline's box; it now keeps the effects and makes the gradient meshes clipped to the outline, as Outline Stroke does. Envelope Options > Distort Appearance uses it too. PatternDef::offsets_covering overflowed on a region too large to count in integers, as for a pattern scaled by 1e-20; it now gives no offsets. Docs: docs/mcp.md, docs/control-protocol.md, docs/target-app-parity.md.
855 lines
35 KiB
Rust
855 lines
35 KiB
Rust
//! Pattern swatches (Object → Pattern) and live Repeats (Object → Repeat): data and pure math.
|
||
//!
|
||
//! **Patterns.** A [`PatternDef`] is a named tile: art plus a tile rectangle and a tile type
|
||
//! (grid, brick by row/column, hex by column/row). Pattern space has the tile's top-left at the
|
||
//! origin; instance `(i, j)` is the art translated by `-tile.origin + tile_offset(i, j)`. A
|
||
//! [`Paint::Pattern`] maps pattern space into the document with its own `xf` (identity = tiles
|
||
//! anchored at the document origin, like Illustrator's ruler origin). Every tiling is periodic
|
||
//! on a rectangular *super-tile* ([`PatternDef::period`]), which is what renderers rasterize and
|
||
//! what SVG `<pattern>` elements repeat.
|
||
//!
|
||
//! **Repeats.** A [`RepeatSpec`] holds source art and a radial / grid / mirror arrangement; the
|
||
//! instances are the source under [`repeat_transforms`] (evaluated on demand like blends).
|
||
|
||
use std::sync::Arc;
|
||
|
||
use serde::{Deserialize, Serialize};
|
||
use vectorcraft_color::Paint;
|
||
use vectorcraft_geom::{Affine, Point, Rect, Vec2};
|
||
|
||
use crate::appearance::AppearanceItem;
|
||
use crate::node::{Node, NodeId, NodeKind};
|
||
|
||
fn half() -> f64 {
|
||
0.5
|
||
}
|
||
fn five() -> u32 {
|
||
5
|
||
}
|
||
fn seventy() -> f32 {
|
||
70.0
|
||
}
|
||
fn yes() -> bool {
|
||
true
|
||
}
|
||
fn three() -> u32 {
|
||
3
|
||
}
|
||
fn full_turn() -> f64 {
|
||
360.0
|
||
}
|
||
|
||
// =====================================================================================
|
||
// Patterns
|
||
// =====================================================================================
|
||
|
||
/// Pattern Options → Tile Type.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Serialize, Deserialize)]
|
||
#[serde(tag = "type", rename_all = "camelCase")]
|
||
pub enum TileType {
|
||
#[default]
|
||
Grid,
|
||
/// Rows shifted horizontally by `offset` × tile width (0.5 = half brick).
|
||
BrickByRow {
|
||
#[serde(default = "half")]
|
||
offset: f64,
|
||
},
|
||
/// Columns shifted vertically by `offset` × tile height.
|
||
BrickByColumn {
|
||
#[serde(default = "half")]
|
||
offset: f64,
|
||
},
|
||
/// Hexagonal tiles in columns: columns ¾ tile width apart, odd columns shifted half a tile down.
|
||
HexByColumn,
|
||
/// Hexagonal tiles in rows: rows ¾ tile height apart, odd rows shifted half a tile right.
|
||
HexByRow,
|
||
}
|
||
|
||
impl TileType {
|
||
pub fn id(&self) -> &'static str {
|
||
match self {
|
||
TileType::Grid => "grid",
|
||
TileType::BrickByRow { .. } => "brickByRow",
|
||
TileType::BrickByColumn { .. } => "brickByColumn",
|
||
TileType::HexByColumn => "hexByColumn",
|
||
TileType::HexByRow => "hexByRow",
|
||
}
|
||
}
|
||
pub fn label(&self) -> &'static str {
|
||
match self {
|
||
TileType::Grid => "Grid",
|
||
TileType::BrickByRow { .. } => "Brick by Row",
|
||
TileType::BrickByColumn { .. } => "Brick by Column",
|
||
TileType::HexByColumn => "Hex by Column",
|
||
TileType::HexByRow => "Hex by Row",
|
||
}
|
||
}
|
||
/// Parse an id (`grid`, `brickByRow`, `brick-row`, …) with an optional brick offset.
|
||
pub fn parse(s: &str, offset: Option<f64>) -> Option<Self> {
|
||
let o = offset.unwrap_or(0.5);
|
||
Some(match s.to_ascii_lowercase().replace(['-', '_', ' '], "").as_str() {
|
||
"grid" => TileType::Grid,
|
||
"brickbyrow" | "brickrow" | "brick" => TileType::BrickByRow { offset: o },
|
||
"brickbycolumn" | "brickcolumn" | "brickcol" => TileType::BrickByColumn { offset: o },
|
||
"hexbycolumn" | "hexcolumn" | "hexcol" | "hex" => TileType::HexByColumn,
|
||
"hexbyrow" | "hexrow" => TileType::HexByRow,
|
||
_ => return None,
|
||
})
|
||
}
|
||
pub const IDS: [&'static str; 5] = ["grid", "brickByRow", "brickByColumn", "hexByColumn", "hexByRow"];
|
||
|
||
/// Column / row steps for a `w`×`h` tile (the hex types pack columns/rows at ¾).
|
||
pub fn steps(&self, w: f64, h: f64) -> (f64, f64) {
|
||
match self {
|
||
TileType::HexByColumn => (w * 0.75, h),
|
||
TileType::HexByRow => (w, h * 0.75),
|
||
_ => (w, h),
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Position of instance (column `i`, row `j`) for a `w`×`h` tile. `(0, 0)` is at the origin.
|
||
pub fn tile_offset(tt: TileType, w: f64, h: f64, i: i64, j: i64) -> Vec2 {
|
||
let (i_f, j_f) = (i as f64, j as f64);
|
||
let frac = |v: f64| v - v.floor();
|
||
match tt {
|
||
TileType::Grid => Vec2::new(i_f * w, j_f * h),
|
||
TileType::BrickByRow { offset } => Vec2::new(i_f * w + frac(j_f * offset) * w, j_f * h),
|
||
TileType::BrickByColumn { offset } => Vec2::new(i_f * w, j_f * h + frac(i_f * offset) * h),
|
||
TileType::HexByColumn => Vec2::new(i_f * w * 0.75, j_f * h + if i.rem_euclid(2) == 1 { h / 2.0 } else { 0.0 }),
|
||
TileType::HexByRow => Vec2::new(i_f * w + if j.rem_euclid(2) == 1 { w / 2.0 } else { 0.0 }, j_f * h * 0.75),
|
||
}
|
||
}
|
||
|
||
/// Smallest `q` in 1..=24 with `q·offset` (almost) an integer (24 when none is).
|
||
fn brick_repeat(offset: f64) -> f64 {
|
||
for q in 1..=24 {
|
||
let v = q as f64 * offset;
|
||
if (v - v.round()).abs() < 1e-6 {
|
||
return q as f64;
|
||
}
|
||
}
|
||
24.0
|
||
}
|
||
|
||
/// Size of the rectangular super-tile a tiling repeats on.
|
||
pub fn tile_period(tt: TileType, w: f64, h: f64) -> (f64, f64) {
|
||
match tt {
|
||
TileType::Grid => (w, h),
|
||
TileType::BrickByRow { offset } => (w, h * brick_repeat(offset)),
|
||
TileType::BrickByColumn { offset } => (w * brick_repeat(offset), h),
|
||
TileType::HexByColumn => (w * 1.5, h),
|
||
TileType::HexByRow => (w, h * 1.5),
|
||
}
|
||
}
|
||
|
||
/// Pattern Options → Overlap.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct Overlap {
|
||
/// Right in front (default: left in front).
|
||
#[serde(default)]
|
||
pub right_in_front: bool,
|
||
/// Bottom in front (default: top in front).
|
||
#[serde(default)]
|
||
pub bottom_in_front: bool,
|
||
}
|
||
|
||
/// A pattern swatch definition.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct PatternDef {
|
||
pub name: String,
|
||
/// Tile rectangle in the art's coordinates.
|
||
pub tile: Rect,
|
||
#[serde(default)]
|
||
pub tile_type: TileType,
|
||
pub art: Vec<Arc<Node>>,
|
||
#[serde(default)]
|
||
pub overlap: Overlap,
|
||
/// Size Tile to Art: the tile is the art bounds grown by the spacing.
|
||
#[serde(default)]
|
||
pub size_tile_to_art: bool,
|
||
#[serde(default)]
|
||
pub h_spacing: f64,
|
||
#[serde(default)]
|
||
pub v_spacing: f64,
|
||
/// Pattern editing preview: copies per side (3, 5, 7, 9).
|
||
#[serde(default = "five")]
|
||
pub copies: u32,
|
||
/// Dim Copies to (percent opacity of the preview copies).
|
||
#[serde(default = "seventy")]
|
||
pub dim_copies: f32,
|
||
#[serde(default = "yes")]
|
||
pub show_tile_edge: bool,
|
||
/// Show Swatch Bounds: pattern editing mode outlines the part of the tiling the swatch repeats
|
||
/// (the tile, or the period of a brick or hex tiling), dashed.
|
||
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
||
pub show_swatch_bounds: bool,
|
||
}
|
||
|
||
impl PatternDef {
|
||
/// A pattern of `art` whose tile is the art's bounds.
|
||
pub fn new(name: &str, art: Vec<Arc<Node>>) -> Self {
|
||
let tile = crate::live::nodes_bounds(&art).unwrap_or(Rect::new(0.0, 0.0, 10.0, 10.0));
|
||
Self {
|
||
name: name.to_string(),
|
||
tile,
|
||
tile_type: TileType::Grid,
|
||
art,
|
||
overlap: Overlap::default(),
|
||
size_tile_to_art: false,
|
||
h_spacing: 0.0,
|
||
v_spacing: 0.0,
|
||
copies: 5,
|
||
dim_copies: 70.0,
|
||
show_tile_edge: true,
|
||
show_swatch_bounds: false,
|
||
}
|
||
}
|
||
pub fn width(&self) -> f64 {
|
||
self.tile.width().max(1e-3)
|
||
}
|
||
pub fn height(&self) -> f64 {
|
||
self.tile.height().max(1e-3)
|
||
}
|
||
/// Visual bounds of the art (stroke included).
|
||
pub fn art_bounds(&self) -> Option<Rect> {
|
||
self.art.iter().fold(None, |acc, n| vectorcraft_geom::union_opt(acc, n.visual_bounds()))
|
||
}
|
||
/// Re-derive the tile from the art (Size Tile to Art).
|
||
pub fn fit_tile_to_art(&mut self) {
|
||
if let Some(b) = crate::live::nodes_bounds(&self.art) {
|
||
self.tile = Rect::new(b.x0 - self.h_spacing / 2.0, b.y0 - self.v_spacing / 2.0, b.x1 + self.h_spacing / 2.0, b.y1 + self.v_spacing / 2.0);
|
||
}
|
||
}
|
||
/// Offset of instance (column `i`, row `j`) in pattern space.
|
||
pub fn offset(&self, i: i64, j: i64) -> Vec2 {
|
||
tile_offset(self.tile_type, self.width(), self.height(), i, j)
|
||
}
|
||
/// The rectangular period of the tiling (the super-tile).
|
||
pub fn period(&self) -> (f64, f64) {
|
||
tile_period(self.tile_type, self.width(), self.height())
|
||
}
|
||
/// The swatch bounds (Show Swatch Bounds): the period of the tiling from the tile's origin.
|
||
pub fn swatch_bounds(&self) -> Rect {
|
||
let (w, h) = self.period();
|
||
Rect::from_origin_size(self.tile.origin(), (w, h))
|
||
}
|
||
/// Maps the art's coordinates into pattern space for instance offset `o`.
|
||
pub fn instance_xf(&self, o: Vec2) -> Affine {
|
||
Affine::translate(o - self.tile.origin().to_vec2())
|
||
}
|
||
/// Offsets (pattern space) of every instance whose art touches `region` (pattern space), in
|
||
/// paint order: the instances "in front" per [`Overlap`] come last.
|
||
pub fn offsets_covering(&self, region: Rect) -> Vec<Vec2> {
|
||
let (w, h) = (self.width(), self.height());
|
||
// Art extent relative to the tile's origin (at least the tile itself).
|
||
let ab = self.art_bounds().unwrap_or(self.tile).union(self.tile) - self.tile.origin().to_vec2();
|
||
let (sx, sy) = self.tile_type.steps(w, h);
|
||
// Shifts of brick/hex rows or columns are < one tile.
|
||
// A region whose tile indices do not fit in integers (or are not finite) gives none, as does
|
||
// one with more than 250,000 positions or none.
|
||
let index = |v: f64| (v.abs() < 9.0e18).then_some(v as i64);
|
||
let (Some(i0), Some(i1), Some(j0), Some(j1)) = (
|
||
index(((region.x0 - ab.x1 - w) / sx).floor()),
|
||
index(((region.x1 - ab.x0 + w) / sx).ceil()),
|
||
index(((region.y0 - ab.y1 - h) / sy).floor()),
|
||
index(((region.y1 - ab.y0 + h) / sy).ceil()),
|
||
) else {
|
||
return vec![];
|
||
};
|
||
let (i0, i1, j0, j1) = (i0 - 1, i1 + 1, j0 - 1, j1 + 1);
|
||
let (ni, nj) = (i1.saturating_sub(i0), j1.saturating_sub(j0));
|
||
if ni < 1 || nj < 1 || ni.saturating_mul(nj) > 250_000 {
|
||
return vec![];
|
||
}
|
||
let mut out = vec![];
|
||
let rows: Vec<i64> = if self.overlap.bottom_in_front { (j0..=j1).collect() } else { (j0..=j1).rev().collect() };
|
||
for &j in &rows {
|
||
let cols: Vec<i64> = if self.overlap.right_in_front { (i0..=i1).collect() } else { (i0..=i1).rev().collect() };
|
||
for i in cols {
|
||
let o = self.offset(i, j);
|
||
let r = ab + o;
|
||
if r.x0 < region.x1 && r.x1 > region.x0 && r.y0 < region.y1 && r.y1 > region.y0 {
|
||
out.push(o);
|
||
}
|
||
}
|
||
}
|
||
out
|
||
}
|
||
/// Offsets of the pattern-editing preview copies (`copies`×`copies` around the tile, the
|
||
/// centre `(0, 0)` excluded).
|
||
pub fn preview_offsets(&self) -> Vec<Vec2> {
|
||
let k = (self.copies.clamp(1, 15) / 2) as i64;
|
||
let mut out = vec![];
|
||
for j in -k..=k {
|
||
for i in -k..=k {
|
||
if (i, j) != (0, 0) {
|
||
out.push(self.offset(i, j));
|
||
}
|
||
}
|
||
}
|
||
out
|
||
}
|
||
/// Instances covering `region` (document space) as plain nodes for a pattern painted with
|
||
/// `paint_xf` (pattern space → document), fresh-id-less (id 0). Used by exporters and Distort
|
||
/// Pattern Fills; Expand uses [`Self::instances_in_with`].
|
||
pub fn instances_in(&self, paint_xf: Affine, region: Rect) -> Vec<Node> {
|
||
self.instances_in_with(paint_xf, region, false)
|
||
}
|
||
/// [`Self::instances_in`], each instance placed with `scaling` (what scales with `paint_xf`
|
||
/// besides geometry).
|
||
pub fn instances_in_with(&self, paint_xf: Affine, region: Rect, scaling: impl Into<crate::node::Scaling>) -> Vec<Node> {
|
||
let scaling = scaling.into();
|
||
let inv = paint_xf.inverse();
|
||
let pr = inv.transform_rect_bbox(region);
|
||
let mut out = vec![];
|
||
for o in self.offsets_covering(pr) {
|
||
let m = paint_xf * self.instance_xf(o);
|
||
for a in &self.art {
|
||
let mut n = (**a).clone();
|
||
place_art(&mut n, m, scaling);
|
||
zero_ids(&mut n);
|
||
out.push(n);
|
||
}
|
||
}
|
||
out
|
||
}
|
||
}
|
||
|
||
/// Transform pattern art `n` by `m` with `scaling`, as a pattern places its art: the opacity masks
|
||
/// in it move with it, unlinked ones included (the canvas draws a tile's art and masks together).
|
||
pub fn place_art(n: &mut Node, m: Affine, scaling: impl Into<crate::node::Scaling>) {
|
||
let scaling = scaling.into();
|
||
n.transform(m, scaling);
|
||
place_unlinked_masks(n, m, scaling);
|
||
}
|
||
|
||
/// Transform the art of the unlinked opacity masks of `n` and its descendants by `m`, the masks
|
||
/// inside mask art included.
|
||
fn place_unlinked_masks(n: &mut Node, m: Affine, scaling: crate::node::Scaling) {
|
||
if let Some(mask) = n.extras_if_any().and_then(|e| e.mask.as_mut()) {
|
||
let linked = mask.linked;
|
||
let art = Arc::make_mut(&mut mask.art);
|
||
// A linked mask's art moved with `n`; an unlinked one's moves here.
|
||
if !linked {
|
||
art.transform(m, scaling);
|
||
}
|
||
place_unlinked_masks(art, m, scaling);
|
||
}
|
||
for c in n.children_mut().into_iter().flatten() {
|
||
place_unlinked_masks(Arc::make_mut(c), m, scaling);
|
||
}
|
||
}
|
||
|
||
fn zero_ids(n: &mut Node) {
|
||
n.id = NodeId(0);
|
||
if let Some(ch) = n.children_mut() {
|
||
for c in ch.iter_mut() {
|
||
zero_ids(Arc::make_mut(c));
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Pattern editing mode state (lives in the document so undo and the renderer see it).
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub struct PatternEdit {
|
||
/// Pattern being edited.
|
||
pub pattern: String,
|
||
/// The temporary layer holding the tile art while editing.
|
||
pub layer: NodeId,
|
||
/// The definition before editing (restored by Cancel); `None` when Make created it.
|
||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||
pub original: Option<PatternDef>,
|
||
}
|
||
|
||
/// Name of the temporary pattern-editing layer.
|
||
pub const PATTERN_EDIT_LAYER: &str = "Pattern Editing Mode";
|
||
|
||
/// A pattern paint (identity placement).
|
||
pub fn pattern_paint(name: &str) -> Paint {
|
||
Paint::Pattern { pattern: name.to_string(), xf: Affine::IDENTITY }
|
||
}
|
||
|
||
/// Does `n` (not its children) paint any fill/stroke with pattern `name` (any pattern for `None`)?
|
||
pub fn uses_pattern(n: &Node, name: Option<&str>) -> bool {
|
||
n.appearance.items.iter().any(|it| {
|
||
let p = match it {
|
||
AppearanceItem::Fill(f) => &f.paint,
|
||
AppearanceItem::Stroke(s) => &s.paint,
|
||
};
|
||
matches!(p, Paint::Pattern { pattern, .. } if name.is_none_or(|nm| nm == pattern))
|
||
})
|
||
}
|
||
|
||
/// Transform Patterns without Transform Objects: `m` moves the pattern tiles of `n` and of
|
||
/// everything inside it, and the art stays where it is.
|
||
pub fn transform_patterns_only(n: &mut Node, m: Affine) {
|
||
transform_pattern_paints(n, m);
|
||
for c in n.children_mut().into_iter().flatten() {
|
||
transform_patterns_only(Arc::make_mut(c), m);
|
||
}
|
||
}
|
||
|
||
/// Apply `m` to the pattern placement of every pattern paint of `n` (Transform Patterns).
|
||
pub fn transform_pattern_paints(n: &mut Node, m: Affine) {
|
||
// Without pattern paints there is nothing to change: don't copy the shared appearance.
|
||
let patterned = |it: &AppearanceItem| {
|
||
matches!(it, AppearanceItem::Fill(f) if matches!(f.paint, Paint::Pattern { .. }))
|
||
|| matches!(it, AppearanceItem::Stroke(s) if matches!(s.paint, Paint::Pattern { .. }))
|
||
};
|
||
if !n.appearance.items.iter().any(patterned) {
|
||
return;
|
||
}
|
||
for it in n.appearance.items.iter_mut() {
|
||
let p = match it {
|
||
AppearanceItem::Fill(f) => &mut f.paint,
|
||
AppearanceItem::Stroke(s) => &mut s.paint,
|
||
};
|
||
if let Paint::Pattern { xf, .. } = p {
|
||
*xf = m * *xf;
|
||
}
|
||
}
|
||
}
|
||
|
||
// =====================================================================================
|
||
// Repeat
|
||
// =====================================================================================
|
||
|
||
/// The arrangement of a Repeat object.
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
#[serde(tag = "type", rename_all = "camelCase")]
|
||
pub enum RepeatKind {
|
||
/// Copies rotated around `center`; the source's centre is kept `radius` from it.
|
||
#[serde(rename_all = "camelCase")]
|
||
Radial {
|
||
instances: u32,
|
||
radius: f64,
|
||
center: Point,
|
||
#[serde(default)]
|
||
reverse_overlap: bool,
|
||
#[serde(default)]
|
||
start_angle: f64,
|
||
#[serde(default = "full_turn")]
|
||
end_angle: f64,
|
||
},
|
||
/// Copies on a grid (tile = source bounds + spacing), optionally brick/hex offset and with
|
||
/// alternate rows/columns flipped.
|
||
#[serde(rename_all = "camelCase")]
|
||
Grid {
|
||
h_spacing: f64,
|
||
v_spacing: f64,
|
||
#[serde(default = "three")]
|
||
rows: u32,
|
||
#[serde(default = "three")]
|
||
cols: u32,
|
||
#[serde(default)]
|
||
grid_type: TileType,
|
||
/// Flip alternate rows vertically.
|
||
#[serde(default)]
|
||
flip_rows: bool,
|
||
/// Flip alternate columns horizontally.
|
||
#[serde(default)]
|
||
flip_cols: bool,
|
||
},
|
||
/// The source plus its reflection across the axis through `center` at `angle` degrees
|
||
/// (90 = vertical axis).
|
||
Mirror { angle: f64, center: Point },
|
||
}
|
||
|
||
impl RepeatKind {
|
||
pub fn label(&self) -> &'static str {
|
||
match self {
|
||
RepeatKind::Radial { .. } => "Radial Repeat",
|
||
RepeatKind::Grid { .. } => "Grid Repeat",
|
||
RepeatKind::Mirror { .. } => "Mirror Repeat",
|
||
}
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
pub struct RepeatSpec {
|
||
pub kind: RepeatKind,
|
||
pub source: Vec<Arc<Node>>,
|
||
}
|
||
|
||
/// 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();
|
||
let (s2, c2) = t.sin_cos();
|
||
Affine::translate(c.to_vec2()) * Affine::new([c2, s2, s2, -c2, 0.0, 0.0]) * Affine::translate(-c.to_vec2())
|
||
}
|
||
|
||
/// Instance transforms of a repeat (source space → document), in paint order.
|
||
pub fn repeat_transforms(kind: &RepeatKind, source_bounds: Option<Rect>) -> Vec<Affine> {
|
||
let b = source_bounds.unwrap_or(Rect::new(0.0, 0.0, 1.0, 1.0));
|
||
match kind {
|
||
RepeatKind::Radial { instances, radius, center, reverse_overlap, start_angle, end_angle } => {
|
||
let n = (*instances).clamp(1, 1000);
|
||
let c0 = b.center();
|
||
let mut d = c0 - *center;
|
||
if d.hypot() < 1e-9 {
|
||
d = Vec2::new(0.0, -1.0);
|
||
}
|
||
let pre = Affine::translate(*center + d.normalize() * radius.max(0.0) - c0);
|
||
let sweep = end_angle - start_angle;
|
||
let full = (sweep.abs() - 360.0).abs() < 1e-9;
|
||
let step = if full || n == 1 { sweep / n as f64 } else { sweep / (n - 1) as f64 };
|
||
let mut v: Vec<Affine> = (0..n)
|
||
.map(|k| {
|
||
let a = (start_angle + step * k as f64).to_radians();
|
||
Affine::translate(center.to_vec2()) * Affine::rotate(a) * Affine::translate(-center.to_vec2()) * pre
|
||
})
|
||
.collect();
|
||
if *reverse_overlap {
|
||
v.reverse();
|
||
}
|
||
v
|
||
}
|
||
RepeatKind::Grid { h_spacing, v_spacing, rows, cols, grid_type, flip_rows, flip_cols } => {
|
||
let (w, h) = ((b.width() + h_spacing).max(1e-3), (b.height() + v_spacing).max(1e-3));
|
||
let mut v = vec![];
|
||
for j in 0..(*rows).clamp(1, 500) as i64 {
|
||
for i in 0..(*cols).clamp(1, 500) as i64 {
|
||
let o = tile_offset(*grid_type, w, h, i, j);
|
||
let c = b.center();
|
||
let mut flip = Affine::IDENTITY;
|
||
if *flip_cols && i % 2 == 1 {
|
||
flip = reflect_about(c, 90.0) * flip;
|
||
}
|
||
if *flip_rows && j % 2 == 1 {
|
||
flip = reflect_about(c, 0.0) * flip;
|
||
}
|
||
v.push(Affine::translate(o) * flip);
|
||
}
|
||
}
|
||
v
|
||
}
|
||
RepeatKind::Mirror { angle, center } => vec![Affine::IDENTITY, reflect_about(*center, *angle)],
|
||
}
|
||
}
|
||
|
||
impl RepeatSpec {
|
||
pub fn source_bounds(&self) -> Option<Rect> {
|
||
crate::live::nodes_bounds(&self.source)
|
||
}
|
||
pub fn transforms(&self) -> Vec<Affine> {
|
||
repeat_transforms(&self.kind, self.source_bounds())
|
||
}
|
||
/// Evaluated instances: one group of the (transformed) source per instance (ids 0).
|
||
pub fn expand(&self) -> Vec<Node> {
|
||
self.transforms()
|
||
.into_iter()
|
||
.map(|m| {
|
||
let children = self
|
||
.source
|
||
.iter()
|
||
.map(|s| {
|
||
let mut n = (**s).clone();
|
||
n.transform(m, false);
|
||
zero_ids(&mut n);
|
||
Arc::new(n)
|
||
})
|
||
.collect();
|
||
Node::group(NodeId(0), children)
|
||
})
|
||
.collect()
|
||
}
|
||
/// Geometric bounds of all instances.
|
||
pub fn bounds(&self) -> Option<Rect> {
|
||
self.copies_bounds(self.source_bounds()?)
|
||
}
|
||
/// The bounds of all instances of a source measuring `source`, each placed by its transform
|
||
/// ([`Self::transforms`]).
|
||
pub(crate) fn copies_bounds(&self, source: Rect) -> Option<Rect> {
|
||
self.transforms().into_iter().fold(None, |acc, m| vectorcraft_geom::union_opt(acc, Some(m.transform_rect_bbox(source))))
|
||
}
|
||
/// Apply a document transform (source + arrangement parameters).
|
||
pub fn transform(&mut self, a: Affine, scaling: impl Into<crate::node::Scaling>) {
|
||
let scaling = scaling.into();
|
||
for c in self.source.iter_mut() {
|
||
Arc::make_mut(c).transform(a, scaling);
|
||
}
|
||
let s = a.determinant().abs().sqrt();
|
||
match &mut self.kind {
|
||
RepeatKind::Radial { radius, center, .. } => {
|
||
*center = a * *center;
|
||
*radius *= s;
|
||
}
|
||
RepeatKind::Grid { h_spacing, v_spacing, .. } => {
|
||
*h_spacing *= s;
|
||
*v_spacing *= s;
|
||
}
|
||
RepeatKind::Mirror { angle, center } => {
|
||
*center = a * *center;
|
||
let d = a * Point::new(angle.to_radians().cos(), angle.to_radians().sin()) - a * Point::ZERO;
|
||
*angle = d.y.atan2(d.x).to_degrees();
|
||
}
|
||
}
|
||
}
|
||
/// Default radial repeat around the source (centre below it, radius = its height × 1.2).
|
||
pub fn radial(source: Vec<Arc<Node>>, instances: u32, radius: Option<f64>) -> Self {
|
||
let b = crate::live::nodes_bounds(&source).unwrap_or(Rect::new(0.0, 0.0, 10.0, 10.0));
|
||
let r = radius.unwrap_or((b.height().max(b.width()) * 1.2).max(10.0));
|
||
let center = b.center() + Vec2::new(0.0, r);
|
||
Self { kind: RepeatKind::Radial { instances, radius: r, center, reverse_overlap: false, start_angle: 0.0, end_angle: 360.0 }, source }
|
||
}
|
||
pub fn grid(source: Vec<Arc<Node>>, h_spacing: f64, v_spacing: f64) -> Self {
|
||
Self {
|
||
kind: RepeatKind::Grid { h_spacing, v_spacing, rows: 3, cols: 3, grid_type: TileType::Grid, flip_rows: false, flip_cols: false },
|
||
source,
|
||
}
|
||
}
|
||
/// Mirror across an axis at `angle` through a point `offset` beyond the source's right edge
|
||
/// (vertical axis) or below it (other angles pass through the right-edge midpoint).
|
||
pub fn mirror(source: Vec<Arc<Node>>, angle: f64, offset: f64) -> Self {
|
||
let b = crate::live::nodes_bounds(&source).unwrap_or(Rect::new(0.0, 0.0, 10.0, 10.0));
|
||
let center = Point::new(b.x1 + offset, b.center().y);
|
||
Self { kind: RepeatKind::Mirror { angle, center }, source }
|
||
}
|
||
}
|
||
|
||
/// Is this a Repeat object?
|
||
pub fn is_repeat(n: &Node) -> bool {
|
||
matches!(n.kind, NodeKind::Repeat(_))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use crate::Appearance;
|
||
use vectorcraft_geom::shapes;
|
||
|
||
fn sq(x: f64, y: f64, s: f64) -> Arc<Node> {
|
||
Arc::new(Node::path(NodeId(1), shapes::rectangle(Rect::new(x, y, x + s, y + s)), Appearance::default()))
|
||
}
|
||
|
||
fn close(a: Vec2, b: Vec2) -> bool {
|
||
(a - b).hypot() < 1e-9
|
||
}
|
||
|
||
#[test]
|
||
fn grid_offsets() {
|
||
assert!(close(tile_offset(TileType::Grid, 10.0, 20.0, 2, 3), Vec2::new(20.0, 60.0)));
|
||
assert!(close(tile_offset(TileType::Grid, 10.0, 20.0, -1, -1), Vec2::new(-10.0, -20.0)));
|
||
assert_eq!(tile_period(TileType::Grid, 10.0, 20.0), (10.0, 20.0));
|
||
}
|
||
|
||
#[test]
|
||
fn brick_by_row_offsets() {
|
||
let t = TileType::BrickByRow { offset: 0.5 };
|
||
assert!(close(tile_offset(t, 10.0, 20.0, 0, 1), Vec2::new(5.0, 20.0)));
|
||
assert!(close(tile_offset(t, 10.0, 20.0, 0, 2), Vec2::new(0.0, 40.0)));
|
||
assert!(close(tile_offset(t, 10.0, 20.0, 1, -1), Vec2::new(15.0, -20.0)));
|
||
assert_eq!(tile_period(t, 10.0, 20.0), (10.0, 40.0));
|
||
let t3 = TileType::BrickByRow { offset: 1.0 / 3.0 };
|
||
assert_eq!(tile_period(t3, 10.0, 20.0), (10.0, 60.0));
|
||
}
|
||
|
||
#[test]
|
||
fn brick_by_column_offsets() {
|
||
let t = TileType::BrickByColumn { offset: 0.25 };
|
||
assert!(close(tile_offset(t, 10.0, 20.0, 1, 0), Vec2::new(10.0, 5.0)));
|
||
assert!(close(tile_offset(t, 10.0, 20.0, 3, 1), Vec2::new(30.0, 35.0)));
|
||
assert_eq!(tile_period(t, 10.0, 20.0), (40.0, 20.0));
|
||
}
|
||
|
||
#[test]
|
||
fn hex_offsets() {
|
||
let c = TileType::HexByColumn;
|
||
assert!(close(tile_offset(c, 10.0, 20.0, 1, 0), Vec2::new(7.5, 10.0)));
|
||
assert!(close(tile_offset(c, 10.0, 20.0, 2, 1), Vec2::new(15.0, 20.0)));
|
||
assert!(close(tile_offset(c, 10.0, 20.0, -1, 0), Vec2::new(-7.5, 10.0)));
|
||
assert_eq!(tile_period(c, 10.0, 20.0), (15.0, 20.0));
|
||
let r = TileType::HexByRow;
|
||
assert!(close(tile_offset(r, 10.0, 20.0, 0, 1), Vec2::new(5.0, 15.0)));
|
||
assert!(close(tile_offset(r, 10.0, 20.0, 1, 2), Vec2::new(10.0, 30.0)));
|
||
assert_eq!(tile_period(r, 10.0, 20.0), (10.0, 30.0));
|
||
}
|
||
|
||
#[test]
|
||
fn tilings_are_periodic_on_their_period() {
|
||
// Every instance shifted by the period is again an instance.
|
||
for tt in [
|
||
TileType::Grid,
|
||
TileType::BrickByRow { offset: 0.5 },
|
||
TileType::BrickByColumn { offset: 0.25 },
|
||
TileType::HexByColumn,
|
||
TileType::HexByRow,
|
||
] {
|
||
let (w, h) = (10.0, 20.0);
|
||
let (pw, ph) = tile_period(tt, w, h);
|
||
let all: Vec<Vec2> = (-8..8).flat_map(|j| (-8..8).map(move |i| tile_offset(tt, w, h, i, j))).collect();
|
||
for o in all.iter().filter(|o| o.x.abs() < 30.0 && o.y.abs() < 30.0) {
|
||
for d in [Vec2::new(pw, 0.0), Vec2::new(0.0, ph)] {
|
||
assert!(all.iter().any(|p| close(*p, *o + d)), "{tt:?} {o:?}+{d:?}");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn tile_type_parse() {
|
||
assert_eq!(TileType::parse("brickByRow", Some(0.25)), Some(TileType::BrickByRow { offset: 0.25 }));
|
||
assert_eq!(TileType::parse("hex-by-row", None), Some(TileType::HexByRow));
|
||
assert_eq!(TileType::parse("nope", None), None);
|
||
for id in TileType::IDS {
|
||
assert_eq!(TileType::parse(id, None).unwrap().id(), id);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn covering_offsets_and_overlap_order() {
|
||
let def = PatternDef::new("p", vec![sq(0.0, 0.0, 10.0)]);
|
||
let offs = def.offsets_covering(Rect::new(0.0, 0.0, 30.0, 20.0));
|
||
// 3×2 tiles fully inside, plus neighbours touching the edges are excluded (strict overlap).
|
||
assert_eq!(offs.len(), 6, "{offs:?}");
|
||
// Left/top in front: the top-left tile is drawn last.
|
||
assert!(close(*offs.last().unwrap(), Vec2::ZERO));
|
||
let mut d2 = def.clone();
|
||
d2.overlap = Overlap { right_in_front: true, bottom_in_front: true };
|
||
assert!(close(*d2.offsets_covering(Rect::new(0.0, 0.0, 30.0, 20.0)).last().unwrap(), Vec2::new(20.0, 10.0)));
|
||
}
|
||
|
||
#[test]
|
||
fn a_region_too_large_to_count_has_no_offsets() {
|
||
// A pattern scaled by 1e-20 covers a 100 pt square with a region of 1e22 pt.
|
||
let def = PatternDef::new("p", vec![sq(0.0, 0.0, 10.0)]);
|
||
assert!(def.offsets_covering(Rect::new(-1e22, -1e22, 1e22, 1e22)).is_empty());
|
||
assert!(def.offsets_covering(Rect::new(f64::NEG_INFINITY, 0.0, f64::INFINITY, 10.0)).is_empty());
|
||
// Far out, a region one tile wide and 1e12 pt tall still counts its rows.
|
||
assert!(def.offsets_covering(Rect::new(1e18, 0.0, 1e18, 1e12)).is_empty());
|
||
let tiny = Affine::scale(1e-20);
|
||
assert!(def.instances_in(tiny, Rect::new(0.0, 0.0, 100.0, 100.0)).is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn instances_follow_paint_xf() {
|
||
let def = PatternDef::new("p", vec![sq(100.0, 100.0, 10.0)]);
|
||
let n = def.instances_in(Affine::translate((3.0, 0.0)), Rect::new(0.0, 0.0, 20.0, 10.0));
|
||
let xs: Vec<f64> = n.iter().filter_map(|n| n.geometric_bounds()).map(|b| b.x0).collect();
|
||
assert!(xs.contains(&3.0) && xs.contains(&-7.0) && xs.contains(&13.0), "{xs:?}");
|
||
assert!(n.iter().all(|n| n.id == NodeId(0)));
|
||
}
|
||
|
||
#[test]
|
||
fn instances_carry_unlinked_masks_with_them() {
|
||
let mut art = (*sq(100.0, 100.0, 10.0)).clone();
|
||
let mut mask = crate::node::OpacityMask::new((*sq(100.0, 100.0, 5.0)).clone(), true);
|
||
mask.linked = false;
|
||
art.extras_mut().mask = Some(Box::new(mask));
|
||
let def = PatternDef::new("p", vec![Arc::new(art)]);
|
||
for n in def.instances_in(Affine::translate((3.0, 0.0)), Rect::new(0.0, 0.0, 20.0, 10.0)) {
|
||
let (b, m) = (n.geometric_bounds().unwrap(), n.extras().mask.as_ref().unwrap());
|
||
assert_eq!(m.art.geometric_bounds().unwrap().origin(), b.origin(), "the mask moves with its art");
|
||
assert!(!m.linked, "the mask stays unlinked");
|
||
}
|
||
// An unlinked mask inside a linked mask's art moves too.
|
||
let mut inner = (*sq(100.0, 100.0, 5.0)).clone();
|
||
let mut nested = crate::node::OpacityMask::new((*sq(100.0, 100.0, 2.0)).clone(), true);
|
||
nested.linked = false;
|
||
inner.extras_mut().mask = Some(Box::new(nested));
|
||
let mut art = (*sq(100.0, 100.0, 10.0)).clone();
|
||
art.extras_mut().mask = Some(Box::new(crate::node::OpacityMask::new(inner, true)));
|
||
let def = PatternDef::new("p", vec![Arc::new(art)]);
|
||
for n in def.instances_in(Affine::translate((3.0, 0.0)), Rect::new(0.0, 0.0, 20.0, 10.0)) {
|
||
let outer = n.extras().mask.as_ref().unwrap();
|
||
let nested = outer.art.extras().mask.as_ref().unwrap();
|
||
assert_eq!(nested.art.geometric_bounds().unwrap().origin(), n.geometric_bounds().unwrap().origin());
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn preview_offsets_count() {
|
||
let mut def = PatternDef::new("p", vec![sq(0.0, 0.0, 10.0)]);
|
||
assert_eq!(def.preview_offsets().len(), 24);
|
||
def.copies = 3;
|
||
assert_eq!(def.preview_offsets().len(), 8);
|
||
}
|
||
|
||
#[test]
|
||
fn radial_transforms() {
|
||
let r = RepeatSpec::radial(vec![sq(-5.0, -105.0, 10.0)], 4, Some(100.0));
|
||
let RepeatKind::Radial { center, .. } = r.kind else { panic!() };
|
||
assert!((center - Point::new(0.0, -0.0)).hypot() < 1e-9, "{center:?}");
|
||
let cs: Vec<Point> = r.transforms().iter().map(|m| *m * Point::new(0.0, -100.0)).collect();
|
||
assert!((cs[0] - Point::new(0.0, -100.0)).hypot() < 1e-9);
|
||
assert!((cs[1] - Point::new(100.0, 0.0)).hypot() < 1e-9, "{cs:?}");
|
||
assert!((cs[2] - Point::new(0.0, 100.0)).hypot() < 1e-9);
|
||
assert_eq!(r.expand().len(), 4);
|
||
}
|
||
|
||
#[test]
|
||
fn radial_radius_is_authoritative() {
|
||
let mut r = RepeatSpec::radial(vec![sq(-5.0, -105.0, 10.0)], 6, Some(100.0));
|
||
if let RepeatKind::Radial { radius, .. } = &mut r.kind {
|
||
*radius = 50.0;
|
||
}
|
||
let m = r.transforms()[0];
|
||
assert!((m * Point::new(0.0, -100.0) - Point::new(0.0, -50.0)).hypot() < 1e-9);
|
||
}
|
||
|
||
#[test]
|
||
fn grid_repeat_transforms() {
|
||
let g = RepeatSpec::grid(vec![sq(0.0, 0.0, 10.0)], 5.0, 2.0);
|
||
let t = g.transforms();
|
||
assert_eq!(t.len(), 9);
|
||
assert!((t[1] * Point::ZERO - Point::new(15.0, 0.0)).hypot() < 1e-9);
|
||
assert!((t[3] * Point::ZERO - Point::new(0.0, 12.0)).hypot() < 1e-9);
|
||
assert_eq!(g.bounds(), Some(Rect::new(0.0, 0.0, 40.0, 34.0)));
|
||
}
|
||
|
||
#[test]
|
||
fn grid_repeat_flip() {
|
||
let mut g = RepeatSpec::grid(vec![sq(0.0, 0.0, 10.0)], 0.0, 0.0);
|
||
if let RepeatKind::Grid { flip_cols, .. } = &mut g.kind {
|
||
*flip_cols = true;
|
||
}
|
||
let t = g.transforms();
|
||
// Column 1 is mirrored about the source centre, then moved one tile right.
|
||
assert!((t[1] * Point::new(0.0, 0.0) - Point::new(20.0, 0.0)).hypot() < 1e-9);
|
||
}
|
||
|
||
#[test]
|
||
fn mirror_transforms() {
|
||
let m = RepeatSpec::mirror(vec![sq(0.0, 0.0, 10.0)], 90.0, 5.0);
|
||
let t = m.transforms();
|
||
assert_eq!(t.len(), 2);
|
||
assert!((t[1] * Point::new(0.0, 3.0) - Point::new(30.0, 3.0)).hypot() < 1e-9);
|
||
let b = m.bounds().unwrap();
|
||
assert!((b.x1 - 30.0).abs() < 1e-9 && b.x0.abs() < 1e-9 && (b.y1 - 10.0).abs() < 1e-9, "{b:?}");
|
||
// Horizontal axis.
|
||
let h = reflect_about(Point::new(0.0, 10.0), 0.0);
|
||
assert!((h * Point::new(4.0, 0.0) - Point::new(4.0, 20.0)).hypot() < 1e-9);
|
||
}
|
||
|
||
#[test]
|
||
fn repeat_transform_moves_arrangement() {
|
||
let mut r = RepeatSpec::radial(vec![sq(-5.0, -105.0, 10.0)], 4, Some(100.0));
|
||
let before = r.bounds().unwrap();
|
||
r.transform(Affine::translate((50.0, 0.0)), false);
|
||
let after = r.bounds().unwrap();
|
||
assert!((after.x0 - before.x0 - 50.0).abs() < 1e-9);
|
||
let mut m = RepeatSpec::mirror(vec![sq(0.0, 0.0, 10.0)], 90.0, 5.0);
|
||
m.transform(Affine::rotate(std::f64::consts::FRAC_PI_2), false);
|
||
let RepeatKind::Mirror { angle, .. } = m.kind else { panic!() };
|
||
assert!((angle.rem_euclid(180.0) - 0.0).abs() < 1e-9 || (angle.rem_euclid(180.0) - 180.0).abs() < 1e-9, "{angle}");
|
||
}
|
||
|
||
#[test]
|
||
fn serde_roundtrip() {
|
||
let mut def = PatternDef::new("Dots", vec![sq(0.0, 0.0, 10.0)]);
|
||
def.tile_type = TileType::HexByRow;
|
||
let s = serde_json::to_string(&def).unwrap();
|
||
assert_eq!(serde_json::from_str::<PatternDef>(&s).unwrap(), def);
|
||
let n = Node::new(NodeId(5), NodeKind::Repeat(RepeatSpec::grid(vec![sq(0.0, 0.0, 10.0)], 1.0, 2.0)));
|
||
let s = serde_json::to_string(&n).unwrap();
|
||
assert_eq!(serde_json::from_str::<Node>(&s).unwrap(), n);
|
||
// Old pattern paints (no xf) still load.
|
||
let p: Paint = serde_json::from_str(r#"{"type":"pattern","pattern":"Dots"}"#).unwrap();
|
||
assert_eq!(p, pattern_paint("Dots"));
|
||
}
|
||
}
|