Files
vectorcraft/crates/render/src/fx/bounds.rs
T
dotCooCoo 27553366ab Effects: a Transform effect after Rasterize moves the image with its pixel grid
On a path or compound path, a Transform effect listed after the
object's own Rasterize effect now moves the image that Rasterize makes.
The image is made of the art before the Transform effect, at the
Rasterize effect's resolution and with its room around the art, and the
Transform effect scales, turns, reflects and moves it. Before, the
Transform effect moved the art and Rasterize made a new image of the
moved art on a grid square to the page.

- effects: rasterize_stage finds the Transform effects that move the
  last Rasterize image; stage_map composes their maps about the
  reference point of the art each one takes.
- render: the canvas draws the node without those Transform effects
  through the map, and its drawn and painted bounds follow the map. A
  map that scales the image to nothing draws nothing.
- engine: Expand Appearance places Object > Rasterize's image of the
  art through the map, and PDF export makes those images before it
  bakes the geometry effects.

A Transform effect that makes copies or moves at random, one followed
by another kind of effect, a fill's or stroke's own Rasterize effect,
and Rasterize on type, images, symbol instances and groups keep the
earlier behavior.
2026-11-14 20:45:07 -08:00

888 lines
45 KiB
Rust

use super::predicates::{has_fx, has_object_fx, is_container};
use super::raster::doc_raster_ppi;
use super::{
Affine, AppearanceItem, Arc, BezPath, Document, Effect, FillRule, GeomContext, Node, NodeKind, PathEl, Rect, Renderer, Shape, SymbolBoxes,
effects,
};
use vectorcraft_doc::symbol_overrides::dynamic_art;
pub(super) fn node_bezpath(n: &Node) -> Option<BezPath> {
match &n.kind {
NodeKind::Path { path, .. } => Some(path.to_bezpath()),
NodeKind::Compound { children, .. } => {
let mut bp = BezPath::new();
for c in children {
if let Some(p) = c.path_data() {
bp.extend(p.to_bezpath());
}
}
Some(bp)
}
_ => None,
}
}
pub(super) fn apply(effects: &[Effect], bp: &BezPath, ctx: &GeomContext) -> BezPath {
if !effects::has_geometry(effects) || bp.elements().is_empty() {
return bp.clone();
}
effects::apply_geometry_bez(effects, bp, bp.bounding_box(), ctx)
}
/// The object-level effected geometry of `n` (base path `bp`), with the swatches and patterns that
/// live-effect plug-ins painting their pieces name looked up in `doc`.
pub(crate) fn effected_path(doc: &Document, n: &Node, bp: &BezPath) -> BezPath {
apply(&n.appearance.effects, bp, &GeomContext { doc: Some(doc), ..GeomContext::of(n) })
}
/// [`apply`], and how gradients follow the effects ([`effects::Carry`]).
pub(super) fn apply_carrying(effects: &[Effect], bp: &BezPath, ctx: &GeomContext) -> (BezPath, effects::Carry) {
if !effects::has_geometry(effects) || bp.elements().is_empty() {
return (bp.clone(), effects::Carry::default());
}
effects::apply_geometry_bez_carrying(effects, bp, bp.bounding_box(), ctx)
}
/// [`effected_path`], and how `n`'s gradients follow its effects.
pub(crate) fn effected_path_carrying(doc: &Document, n: &Node, bp: &BezPath) -> (BezPath, effects::Carry) {
apply_carrying(&n.appearance.effects, bp, &GeomContext { doc: Some(doc), ..GeomContext::of(n) })
}
/// `n`, a path or compound path whose own Rasterize effect is followed by Transform effects that
/// move its image ([`effects::rasterize_stage`]), with those Transform effects hidden, and the map
/// they move the image by ([`effects::stage_map`]): the image is made of that node's art on its
/// own pixel grid, then drawn through the map. `None` for any other object, when the node without
/// those Transform effects is drawn through its art ([`has_object_fx`]: a Transform effect that
/// copies it, Crop Marks, a 3D effect…), and when the art before the Transform effects is empty.
pub(crate) fn rasterize_stage(doc: &Document, n: &Node) -> Option<(Node, Affine)> {
if !has_fx(n) {
return None;
}
let at = effects::rasterize_stage(&n.appearance.effects)?;
let mut stage = n.clone();
stage.appearance.effects = effects::staged_effects(&n.appearance.effects, &at);
if has_object_fx(&stage) {
return None;
}
let g = effected_path(doc, &stage, &node_bezpath(n)?);
let map = effects::stage_map(&n.appearance.effects, &at, &vectorcraft_geom::PathData::from_bezpath(&g))?;
Some((stage, map))
}
/// The box `map` ([`rasterize_stage`]) takes `b` to; `None` when it flattens it to a line or a
/// point, which leaves nothing to draw.
pub(crate) fn staged_reach(map: Affine, b: Rect) -> Option<Rect> {
let det = map.determinant();
(det.is_finite() && det.abs() > 1e-12).then(|| map.transform_rect_bbox(b))
}
pub(super) fn item_effects(item: &AppearanceItem) -> &[Effect] {
match item {
AppearanceItem::Fill(f) => &f.effects,
AppearanceItem::Stroke(s) => &s.effects,
}
}
/// The effects of `item`, a fill or stroke of `n`, that its raster effects are drawn from: each
/// one following `n`'s Transform effects as well ([`effects::item_effects_in`]).
pub(super) fn item_raster<'a>(n: &Node, item: &'a AppearanceItem) -> std::borrow::Cow<'a, [Effect]> {
effects::item_effects_in(&n.appearance.effects, item_effects(item))
}
/// Visual bounds including geometry effects, stroke outsets and shadows/glows (symbol instances
/// measured by their art from `symbols`).
pub(crate) fn visual_bounds(symbols: &SymbolBoxes, n: &Node) -> Option<Rect> {
if let Some(art) = painted_art(symbols, n) {
return art.visual_bounds_with(symbols).map(|r| with_raster_reach(symbols, n, r));
}
// Copies that each carry the raster effects listed before their Transform effect reach as far
// as each copy's raster effects paint, and the raster effects after it spread them all.
if effects::outer_effects(n).len() < n.appearance.effects.len()
&& let Some(art) = effects::reshape(Some(symbols.document()), n, None)
{
return cull_bounds(symbols, &art);
}
// A Rasterize image moved by the Transform effects after it reaches as far as the map takes
// what the art before them reaches, the image included.
if let Some((stage, map)) = rasterize_stage(symbols.document(), n) {
return staged_reach(map, visual_bounds(symbols, &stage)?);
}
let bp = node_bezpath(n)?;
let ctx = GeomContext { doc: Some(symbols.document()), ..GeomContext::of(n) };
let (g, carry) = effected_path_carrying(symbols.document(), n, &bp);
// The raster effects reach as far as they are drawn: following only the Transform effects
// that moved the art ([`effects::Carry::hide_skipped`]).
let mut ran = std::borrow::Cow::Borrowed(n);
if carry.skipped() {
carry.hide_skipped(&mut ran.to_mut().appearance.effects);
}
let mut r: Option<Rect> = (!g.elements().is_empty()).then(|| g.bounding_box());
for (j, item) in n.appearance.items.iter().enumerate() {
let fx = item_effects(item);
if effects::has_geometry(fx) {
let (ig, c) = apply_carrying(fx, &g, &ctx.item(item));
if c.skipped()
&& let Some(it) = ran.to_mut().appearance.items.get_mut(j)
{
c.hide_skipped(it.effects_mut());
}
if !ig.elements().is_empty() {
let b = ig.bounding_box();
r = Some(r.map_or(b, |r| r.union(b)));
}
}
}
let s = n.appearance.outset();
r.map(|r| with_raster_reach(symbols, &ran, r.inflate(s, s)))
}
/// `n` with the Transform effects its geometry passes leave out (past the budget) hidden, in its
/// own list and in its fills' and strokes' ([`effects::Carry::hide_skipped`]): the effects its
/// raster effects are drawn from. Borrowed when it has no Transform effect or no raster effect, is
/// not a path or compound path, or its art is made by [`effects::reshape`] or a 3D effect.
fn ran<'a>(doc: &Document, n: &'a Node) -> std::borrow::Cow<'a, Node> {
let transforms = |fx: &[Effect]| fx.iter().any(|e| e.visible && e.id == "distort.transform");
let mut out = std::borrow::Cow::Borrowed(n);
if (!transforms(&n.appearance.effects) && !n.appearance.items.iter().any(|i| transforms(item_effects(i))))
|| (effects::raster_effects(&n.appearance.effects).is_empty()
&& n.appearance.items.iter().all(|i| effects::raster_effects(item_effects(i)).is_empty()))
|| effects::has_painted_effects(n)
|| effects::has_revolve(n)
|| effects::has_solid(n)
{
return out;
}
let Some(bp) = node_bezpath(n) else { return out };
let ctx = GeomContext { doc: Some(doc), ..GeomContext::of(n) };
let (g, carry) = apply_carrying(&n.appearance.effects, &bp, &ctx);
if carry.skipped() {
carry.hide_skipped(&mut out.to_mut().appearance.effects);
}
for (j, item) in n.appearance.items.iter().enumerate() {
let fx = item_effects(item);
if !transforms(fx) || g.elements().is_empty() {
continue;
}
let (_, c) = apply_carrying(fx, &g, &ctx.item(item));
if c.skipped()
&& let Some(it) = out.to_mut().appearance.items.get_mut(j)
{
c.hide_skipped(it.effects_mut());
}
}
out
}
/// `r`, the art of `n` with its strokes, grown by how far the raster effects of `n`'s fills and
/// strokes and then `n`'s own paint past it.
fn with_raster_reach(symbols: &SymbolBoxes, n: &Node, r: Rect) -> Rect {
let r = n.appearance.items.iter().filter(|i| paints(i)).map(|i| spread(symbols, &item_raster(n, i), r)).fold(r, |acc, b| acc.union(b));
let o = outset(symbols, &n.appearance.effects, r);
r.inflate(o, o)
}
/// The art of `n` with each piece a live-effect plug-in returns and the paints of that piece
/// ([`effects::has_painted_effects`]); `None` for any other object.
fn painted_art(symbols: &SymbolBoxes, n: &Node) -> Option<Node> {
effects::has_painted_effects(n).then(|| effects::reshape(Some(symbols.document()), n, None)).flatten()
}
/// Calls `f` on each object in `art`, the art [`painted_art`] makes, that has a visible brushed
/// stroke, looking into the visible members of its groups. Hidden objects are left out.
fn each_brushed_piece(art: &Node, f: &mut impl FnMut(&Node)) {
if !art.visible {
return;
}
match &art.kind {
NodeKind::Group { children, .. } => children.iter().for_each(|c| each_brushed_piece(c, f)),
_ if vectorcraft_brush::has_brush(art) => f(art),
_ => {}
}
}
/// [`cull_bounds`] of path or compound path `n` whose live-effect plug-ins paint their pieces
/// ([`painted_art`]), with room for brush art past each piece's brushed strokes
/// ([`crate::brush_fx::pad`] of that piece, from the piece's own stroke widths) and the reach of
/// `n`'s raster effects past them. `None` when the renderer measures `n` otherwise: it has no such
/// pieces, or has Crop Marks, Vector Halftone or a 3D effect.
pub(crate) fn painted_cull_bounds(symbols: &SymbolBoxes, n: &Node) -> Option<Option<Rect>> {
if !effects::has_painted_effects(n)
|| effects::has_crop_marks(n)
|| effects::addons::halftone::has_halftone(n)
|| effects::has_revolve(n)
|| effects::has_solid(n)
{
return None;
}
let art = painted_art(symbols, n)?;
let mut b = art.visual_bounds_with(symbols);
each_brushed_piece(&art, &mut |p| {
let pad = crate::brush_fx::pad(symbols, p);
b = vectorcraft_geom::union_opt(b, p.visual_bounds_with(symbols).map(|r| r.inflate(pad, pad)));
});
Some(b.map(|b| with_raster_reach(symbols, n, b)))
}
/// The widest stroke of the pieces with a visible brushed stroke that live-effect plug-ins paint
/// ([`painted_art`]) for the paths in the art of the symbol named `symbol`, and in the art of the
/// symbols the instances in it show, each symbol measured once for `symbols`
/// ([`SymbolBoxes::measured_width`]). `None` when no such piece has one; symbols whose art has no
/// visible effect ([`SymbolBoxes::has_effects`]) are not looked at.
pub(crate) fn painted_brush_width(symbols: &SymbolBoxes, symbol: &str) -> Option<f64> {
symbols.measured_width("painted brush", symbol, || {
if !symbols.has_effects(symbol) {
return None;
}
let mut width: Option<f64> = None;
symbols.measure_art(symbol, |art| {
art.walk(&mut |n| {
let nested = match &n.kind {
NodeKind::SymbolInstance { symbol, .. } => painted_brush_width(symbols, symbol),
_ => None,
};
width = width.into_iter().chain(nested).reduce(f64::max);
if let Some(pieces) = painted_art(symbols, n) {
each_brushed_piece(&pieces, &mut |p| {
let widths = p.appearance.items.iter().filter_map(|i| if let AppearanceItem::Stroke(s) = i { Some(s.width) } else { None });
width = Some(widths.fold(width.unwrap_or(0.0), f64::max));
});
}
})
});
width
})
}
/// Does `item` paint (as [`Renderer::paint_items`] draws it)?
fn paints(item: &AppearanceItem) -> bool {
item.visible() && !item.paint().is_none()
}
/// The bounds of what `n` draws, its own and its members' geometry effects applied and the raster
/// effects of its members and of its fills and strokes included (each fill's and stroke's
/// spreading what it paints, [`item_bounds`]), with strokes measured as
/// [`Node::visual_bounds_with`] measures them, without the reach of `n`'s own raster effects
/// (symbol instances measured by their art from `symbols`): what Rasterize makes its image over.
pub(crate) fn drawn_bounds(symbols: &SymbolBoxes, n: &Node) -> Option<Rect> {
drawn_bounds_ran(symbols, n, None)
}
/// [`drawn_bounds`], with `ran`, [`ran`] of `n`, when the caller has it.
fn drawn_bounds_ran(symbols: &SymbolBoxes, n: &Node, ran: Option<&Node>) -> Option<Rect> {
// A 3D effect's art holds its fills' and strokes' raster effects, measured with it.
if let Some(b) = three_d_bounds(symbols, n) {
return b;
}
let b = art_bounds(symbols, n)?;
let mut items =
n.appearance.items.iter().enumerate().filter(|(_, i)| paints(i) && !effects::raster_effects(item_effects(i)).is_empty()).peekable();
if items.peek().is_none() {
return Some(b);
}
let own;
let ran = match ran {
Some(r) => r,
None => {
own = self::ran(symbols.document(), n);
&*own
}
};
Some(
items
.map(|(j, i)| {
let r = ran.appearance.items.get(j).unwrap_or(i);
spread(symbols, &item_raster(ran, r), item_bounds(symbols.document(), n, i).unwrap_or(b))
})
.fold(b, |acc, r| acc.union(r)),
)
}
/// The bounds of what `item`, a fill or stroke of the path or compound path `n`, paints: the path
/// with `n`'s and `item`'s geometry effects, and for a stroke its width. `None` for other objects,
/// 3D art, a path whose live-effect plug-ins paint their pieces, a brushed stroke and an item that
/// draws no path.
fn item_bounds(doc: &Document, n: &Node, item: &AppearanceItem) -> Option<Rect> {
let stroke = matches!(item, AppearanceItem::Stroke(_));
if !has_fx(n)
|| effects::has_revolve(n)
|| effects::has_solid(n)
|| effects::has_painted_effects(n)
|| (stroke && vectorcraft_brush::has_brush(n))
{
return None;
}
let g = effected_path(doc, n, &node_bezpath(n)?);
let fx = item_effects(item);
if effects::has_geometry(fx) {
let ig = apply(fx, &g, &GeomContext { doc: Some(doc), ..GeomContext::of(n) }.item(item));
let o = if let AppearanceItem::Stroke(s) = item { s.reach() } else { 0.0 };
return (!ig.elements().is_empty()).then(|| ig.bounding_box().inflate(o, o));
}
let one = vectorcraft_doc::Appearance { items: vec![item.clone()], ..Default::default() };
(!g.elements().is_empty()).then(|| one.stroked_bounds(g.bounding_box(), || g.clone()))
}
/// `b` grown by how far raster effects `fx` paint past it, each spreading what the ones before it
/// paint (Rasterize at the document's raster effects resolution where it takes it).
fn spread(symbols: &SymbolBoxes, fx: &[Effect], b: Rect) -> Rect {
let ppi = doc_raster_ppi(symbols.document());
effects::raster_effects(fx).iter().fold(b, |r, e| e.at_document_ppi(ppi).spread(r, 72.0 / ppi))
}
/// [`drawn_bounds`] before the raster effects of `n`'s fills and strokes: its art, and the art of
/// its brushed strokes (a symbol's brushed art as far as [`crate::brush_fx::pad`] reaches). A path
/// whose live-effect plug-ins paint their pieces is measured by those pieces, each with the art
/// its brushed strokes draw along it.
fn art_bounds(symbols: &SymbolBoxes, n: &Node) -> Option<Rect> {
if let Some(art) = painted_art(symbols, n) {
let mut b = art.visual_bounds_with(symbols);
each_brushed_piece(&art, &mut |p| {
let brushed = vectorcraft_brush::expand(symbols.document(), p).and_then(|a| a.visual_bounds_with(symbols));
b = vectorcraft_geom::union_opt(b, brushed);
});
return b;
}
let b = shape_bounds(symbols, n);
let brushed = vectorcraft_brush::has_brush(n)
.then(|| vectorcraft_brush::expand(symbols.document(), n))
.flatten()
.and_then(|art| art.visual_bounds_with(symbols));
let b = vectorcraft_geom::union_opt(b, brushed)?;
let pad = if matches!(n.kind, NodeKind::SymbolInstance { .. }) { crate::brush_fx::pad(symbols, n) } else { 0.0 };
Some(b.inflate(pad, pad))
}
/// [`art_bounds`] without brush art.
fn shape_bounds(symbols: &SymbolBoxes, n: &Node) -> Option<Rect> {
// The visible members of `g` (a Shaper group's first member is its source art, which paints
// nothing).
let union = |g: &Node| {
let members = g.children()?.get(usize::from(g.extras().shaper.is_some())..).unwrap_or_default();
members.iter().filter(|c| c.visible).fold(None, |acc, c| vectorcraft_geom::union_opt(acc, painted_reach(symbols, c)))
};
match &n.kind {
_ if effects::has_container_appearance(n) => {
let art = effects::evaluate_container(Some(symbols.document()), n);
let art = art.as_ref().unwrap_or(n);
if art.clips() { art.visual_bounds_with(symbols) } else { union(art) }
}
NodeKind::Layer { clip: false, .. } | NodeKind::Group { clip: false, .. } => union(n),
_ if has_fx(n) => {
let g = effected_path(symbols.document(), n, &node_bezpath(n)?);
// The path as the fills and strokes without geometry effects of their own paint it
// (as every fill and stroke would when none paints).
let mut plain = n.appearance.clone();
plain.items.retain(|i| !(paints(i) && effects::has_geometry(item_effects(i))));
let on_path = !n.appearance.items.iter().any(paints) || plain.items.iter().any(paints);
let mut r = (on_path && !g.elements().is_empty()).then(|| plain.stroked_bounds(g.bounding_box(), || g.clone()));
let ctx = GeomContext { doc: Some(symbols.document()), ..GeomContext::of(n) };
for item in n.appearance.items.iter().filter(|i| paints(i) && effects::has_geometry(item_effects(i))) {
let ig = apply(item_effects(item), &g, &ctx.item(item));
let o = if let AppearanceItem::Stroke(s) = item { s.reach() } else { 0.0 };
r = vectorcraft_geom::union_opt(r, (!ig.elements().is_empty()).then(|| ig.bounding_box().inflate(o, o)));
}
r
}
// As [`cull_bounds_in`] measures them, without the object's own raster effects: the
// reshaped art (type's outlines, and an image and the paths of its own fills and strokes,
// measured one by one with the effects of those fills and strokes), grown by how far the
// effects in a symbol's art and a live object's content paint past it.
_ if has_object_fx(n) => {
let symbol = match &n.kind {
NodeKind::SymbolInstance { symbol, .. } => {
symbols.document().symbols.iter().find(|s| s.name == *symbol).map(|s| dynamic_art(&s.art, n))
}
_ => None,
};
let reshaped = effects::reshape(Some(symbols.document()), n, symbol.as_ref());
let b = match &reshaped {
Some(r) if has_instance_row_effects(n) => instance_piece_bounds(symbols, r),
Some(r) if matches!(n.kind, NodeKind::Text(_)) || (matches!(n.kind, NodeKind::Image(_)) && !r.clips()) => {
r.children().into_iter().flatten().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, painted_reach(symbols, c)))
}
Some(r) => r.visual_bounds_with(symbols),
None => None,
}
.or_else(|| own_box(symbols, n))?;
let a = match &reshaped {
Some(r) => reshaped_art_effects_reach(symbols, n, r),
None => art_effects_reach(symbols, n),
};
let a = a.max(live_content_reach(symbols, n));
Some(b.inflate(a, a))
}
_ => {
let b = n.visual_bounds_with(symbols)?;
let a = art_effects_reach(symbols, n).max(live_content_reach(symbols, n));
Some(b.inflate(a, a))
}
}
}
/// Is `n` a symbol instance whose active fill or stroke has geometry or raster effects that the
/// fills and strokes of its art take ([`effects::has_item_geometry`],
/// [`effects::has_instance_row_raster`])?
fn has_instance_row_effects(n: &Node) -> bool {
matches!(n.kind, NodeKind::SymbolInstance { .. }) && (effects::has_item_geometry(n) || effects::has_instance_row_raster(n))
}
/// The bounds of `art`, the art [`effects::reshape`] made of a symbol instance whose active fill or
/// stroke has geometry or raster effects ([`has_instance_row_effects`]): its paths measured with the
/// effects of their fills and strokes, shadows and glows included ([`visual_bounds`]), the symbol instances in it that
/// took those effects by their own reshaped art in turn, its groups and layers with their own fills
/// and strokes by the art those paint ([`effects::evaluate_container`]), its clip groups by their
/// clipping paths and other objects as [`Node::visual_bounds_with`] measures them. Hidden objects are left out.
/// An instance more than [`vectorcraft_doc::depth::MAX_DEPTH`] instances deep, or whose art would
/// take the objects measured so far past [`effects::SYMBOL_ART_MAX_NODES`], is measured as
/// [`Node::visual_bounds_with`] measures it.
fn instance_piece_bounds(symbols: &SymbolBoxes, art: &Node) -> Option<Rect> {
let mut budget = effects::SYMBOL_ART_MAX_NODES;
pieces_within(symbols, art, 1, &mut budget)
}
/// [`instance_piece_bounds`] of `art`, `depth` instances deep, with `budget` objects left to measure.
fn pieces_within(symbols: &SymbolBoxes, art: &Node, depth: usize, budget: &mut u64) -> Option<Rect> {
if !art.visible {
return None;
}
match &art.kind {
NodeKind::Group { clip: false, .. } | NodeKind::Layer { clip: false, .. } => {
// A group's or layer's own fills and strokes as the art among its members that they paint.
let evaluated = effects::has_container_appearance(art).then(|| effects::evaluate_container(Some(symbols.document()), art)).flatten();
let g = evaluated.as_ref().unwrap_or(art);
if g.clips() {
return g.visual_bounds_with(symbols);
}
g.children().into_iter().flatten().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, pieces_within(symbols, c, depth, budget)))
}
NodeKind::Path { .. } | NodeKind::Compound { .. } if has_fx(art) => visual_bounds(symbols, art),
NodeKind::SymbolInstance { symbol, .. } if depth < vectorcraft_doc::depth::MAX_DEPTH && has_instance_row_effects(art) => {
let doc = symbols.document();
let reshaped = doc.symbols.iter().find(|s| s.name == *symbol).and_then(|s| {
let count = s.art.count() as u64;
if count > *budget {
return None;
}
*budget -= count;
effects::reshape(Some(doc), art, Some(&dynamic_art(&s.art, art)))
});
match reshaped {
Some(r) => pieces_within(symbols, &r, depth + 1, budget),
None => art.visual_bounds_with(symbols),
}
}
_ => art.visual_bounds_with(symbols),
}
}
/// [`drawn_bounds`] of `n` grown by how far its own raster effects paint past them. With Crop
/// Marks, the [`drawn_bounds`] of its art: the marks and the object, which paints its own raster
/// effects inside the art.
pub(crate) fn painted_reach(symbols: &SymbolBoxes, n: &Node) -> Option<Rect> {
if let Some(art) = effects::crop_marks_art(n) {
return drawn_bounds(symbols, &art);
}
if let Some((stage, map)) = rasterize_stage(symbols.document(), n) {
return staged_reach(map, painted_reach(symbols, &stage)?);
}
let ran = ran(symbols.document(), n);
let b = drawn_bounds_ran(symbols, n, Some(&ran))?;
Some(spread(symbols, &ran.appearance.effects, b))
}
/// The outline the renderer clips `n`'s Feather, Inner Glow and Rasterize with Create Clipping
/// Mask to: a path's or compound path's geometry with its object-level geometry effects applied,
/// the outline of the art [`Renderer::fx_art`] makes for an object with object effects, and with
/// Crop Marks the object's own. For other objects it is [`effects::clip_outline`].
pub(crate) fn drawn_outline(doc: &Document, n: &Node) -> Option<(BezPath, FillRule)> {
if let Some(art) = effects::crop_marks_art(n) {
return drawn_outline(doc, art.children()?.first()?);
}
if has_object_fx(n) {
let art = Renderer::new().fx_art(doc, &Arc::new(n.clone()), false);
return effects::clip_outline(&art);
}
match &n.kind {
NodeKind::Path { rule, .. } | NodeKind::Compound { rule, .. } if effects::has_geometry(&n.appearance.effects) => {
Some((effected_path(doc, n, &node_bezpath(n)?), *rule))
}
_ => effects::clip_outline(n),
}
}
/// Adds the outlines of `n` to `out`, one per object and without uniting them: the visible members of
/// a group, layer or intertwine (a Shaper group's without its source art) and the evaluated art of a
/// blend, envelope, repeat, Pathfinder result or object with object effects. A gradient mesh adds its
/// mesh lines and a symbol instance its bounds, as the selection highlight shows them; any other
/// object, a clip group included, adds [`drawn_outline`]. Each outline's points and each evaluated
/// object are taken from `left`; `None` when they do not fit in it.
pub(crate) fn drawn_outlines(doc: &Document, symbols: &SymbolBoxes, n: &Node, left: &mut usize, out: &mut Vec<BezPath>) -> Option<()> {
if let Some(art) = effects::crop_marks_art(n) {
return match art.children().and_then(|c| c.first()) {
Some(object) => drawn_outlines(doc, symbols, object, left, out),
None => Some(()),
};
}
if has_object_fx(n) {
let makes_art = effects::has_revolve(n) || effects::has_solid(n) || effects::addons::halftone::has_halftone(n);
// Effects that leave a mesh's shape alone evaluate it to its many colored pieces.
if let NodeKind::Mesh(m) = &n.kind
&& !makes_art
&& !effects::has_geometry(&n.appearance.effects)
{
return push_outline(Some(m.lines().to_bezpath()), left, out);
}
let mut object = n.clone();
// A group's own fills and strokes repeat its members' geometry as more art.
if is_container(n) && !makes_art && !effects::has_item_geometry(n) {
object.appearance.items.clear();
}
let art = Renderer::new().fx_art(doc, &Arc::new(object), false);
if art.children().is_some() && !has_object_fx(&art) {
return evaluated_outlines(doc, symbols, &art, left, out);
}
return push_outline(effects::clip_outline(&art).map(|(path, _)| path), left, out);
}
if effects::has_pathfinder(n)
&& let Some(art) = effects::evaluate_container(Some(doc), n).filter(|art| !effects::has_pathfinder(art))
{
return evaluated_outlines(doc, symbols, &art, left, out);
}
match &n.kind {
NodeKind::Group { children, clip: false } | NodeKind::Layer { children, clip: false, .. } | NodeKind::Intertwine { children } => {
for c in children.iter().skip(usize::from(n.extras().shaper.is_some())).filter(|c| c.visible) {
drawn_outlines(doc, symbols, c, left, out)?;
}
Some(())
}
NodeKind::Blend { .. } | NodeKind::Envelope { .. } | NodeKind::Repeat(_) => {
evaluated_outlines(doc, symbols, &effects::expanded_live_group(Some(doc), n), left, out)
}
NodeKind::Mesh(m) => push_outline(Some(m.lines().to_bezpath()), left, out),
NodeKind::SymbolInstance { .. } => {
push_outline(n.geometric_bounds_with(symbols).map(|b| vectorcraft_geom::shapes::rectangle(b).to_bezpath()), left, out)
}
_ => push_outline(drawn_outline(doc, n).map(|(path, _)| path), left, out),
}
}
/// [`drawn_outlines`] of `art`, the evaluated form of a live object or an object with effects, with
/// each of its objects taken from `left`.
fn evaluated_outlines(doc: &Document, symbols: &SymbolBoxes, art: &Node, left: &mut usize, out: &mut Vec<BezPath>) -> Option<()> {
*left = left.checked_sub(art.children().map_or(0, Vec::len))?;
drawn_outlines(doc, symbols, art, left, out)
}
/// Adds `path` to `out` with its points taken from `left`; `None` when they do not fit in it.
fn push_outline(path: Option<BezPath>, left: &mut usize, out: &mut Vec<BezPath>) -> Option<()> {
if let Some(path) = path {
*left = left.checked_sub(path.elements().iter().filter(|el| !matches!(el, PathEl::ClosePath)).count())?;
out.push(path);
}
Some(())
}
/// How far raster effects `fx` paint beyond `b`, each spreading what the ones before it paint
/// ([`spread`]).
fn outset(symbols: &SymbolBoxes, fx: &[Effect], b: Rect) -> f64 {
let s = spread(symbols, fx, b);
[b.x0 - s.x0, b.y0 - s.y0, s.x1 - b.x1, s.y1 - b.y1].into_iter().fold(0.0, f64::max)
}
/// Bounds used for culling: like `Node::visual_bounds_with`, but aware of live effects anywhere in
/// the subtree (a shadow can reach the view while its object is outside it). Symbol instances are
/// measured by their art from `symbols`.
pub(crate) fn cull_bounds(symbols: &SymbolBoxes, n: &Node) -> Option<Rect> {
cull_bounds_in(symbols, n, true, false)
}
/// [`cull_bounds`] with room for the brush art of the members of the groups and layers in `n`, each
/// member measured as [`crate::brush_fx::cull_bounds`] measures it. The room for `n`'s own brushed
/// strokes is left to the caller.
pub(crate) fn brushed_cull_bounds(symbols: &SymbolBoxes, n: &Node) -> Option<Rect> {
cull_bounds_in(symbols, n, true, true)
}
/// [`cull_bounds_in`] of `c`, a member of a group or layer; with `brush`, grown by the room its
/// brushed strokes leave for brush art, as [`crate::brush_fx::cull_bounds`] measures it.
fn member_cull_bounds(symbols: &SymbolBoxes, c: &Node, after_reshape: bool, brush: bool) -> Option<Rect> {
if !brush {
return cull_bounds_in(symbols, c, after_reshape, false);
}
if let Some(b) = painted_cull_bounds(symbols, c) {
return b;
}
let b = cull_bounds_in(symbols, c, after_reshape, true)?;
let pad = crate::brush_fx::pad(symbols, c);
Some(b.inflate(pad, pad))
}
/// [`cull_bounds`] of path or compound path `n` made from `visual`, its visual bounds as
/// [`Node::visual_bounds_with`] measures them, when [`cull_bounds`] measures `n` by those (it has
/// no crop marks, Vector Halftone, container appearance or effects); else `None`.
pub(crate) fn path_cull_bounds(symbols: &SymbolBoxes, n: &Node, visual: impl FnOnce() -> Option<Rect>) -> Option<Option<Rect>> {
let plain = matches!(n.kind, NodeKind::Path { .. } | NodeKind::Compound { .. })
&& !effects::has_crop_marks(n)
&& !effects::addons::halftone::has_halftone(n)
&& !effects::has_container_appearance(n)
&& !has_fx(n)
&& !has_object_fx(n);
plain.then(|| {
let b = visual()?;
let a = live_content_reach(symbols, n);
Some(b.inflate(a, a))
})
}
/// [`cull_bounds`] of `n`. With `after_reshape` true, the effects in the art of a symbol instance
/// with geometry effects of its own are measured on the art as those effects reshape it
/// ([`reshaped_art_effects_reach`]). With `after_reshape` false, they are measured on the art
/// before those effects run ([`art_effects_reach`]), which `symbols` keeps for each symbol and
/// linear part. With `brush` true, the members of a group or layer are measured with the room
/// their brushed strokes leave for brush art ([`member_cull_bounds`]).
fn cull_bounds_in(symbols: &SymbolBoxes, n: &Node, after_reshape: bool, brush: bool) -> Option<Rect> {
let inner = |c: &Node| cull_bounds_in(symbols, c, after_reshape, false);
let member = |c: &Node| member_cull_bounds(symbols, c, after_reshape, brush);
// The art that a group's or layer's crop marks or Vector Halftone draw holds its members. The
// caller leaves the room for an object's own brushed strokes.
let held = |art: &Node| cull_bounds_in(symbols, art, after_reshape, brush && is_container(n));
match &n.kind {
// The object and its crop marks.
_ if effects::has_crop_marks(n) => effects::crop_marks_art(n).and_then(|art| held(&art)),
// The object Vector Halftone samples, and as far as its dots reach past it.
_ if effects::addons::halftone::has_halftone(n) => {
let reach = effects::addons::halftone::reach(n);
held(&effects::addons::halftone::split(n).0).map(|b| b.inflate(reach, reach))
}
// A 3D effect's art, as the renderer draws it, and the raster effects' reach: the solid of
// type or of a group's members reaches past the letters or members the arms below measure.
_ if (effects::has_revolve(n) || effects::has_solid(n))
&& let Some(b) = three_d_bounds(symbols, n) =>
{
b.map(|b| with_own_raster_reach(symbols, n, b))
}
// The evaluated art (its fills, strokes and geometry effects) and the raster effects' reach.
_ if effects::has_container_appearance(n) => {
let art = effects::evaluate_container(Some(symbols.document()), n);
let art = art.as_ref().unwrap_or(n);
let b = if art.clips() {
art.visual_bounds_with(symbols).map(|b| with_clip_region(symbols, art, b))
} else {
art.children()?.iter().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, member(c)))
}?;
Some(with_own_raster_reach(symbols, n, b))
}
NodeKind::Layer { children, clip: false, .. } | NodeKind::Group { children, clip: false } => {
children.iter().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, member(c)))
}
_ if has_fx(n) => visual_bounds(symbols, n),
// The reshaped art (a symbol instance's reshaped art is made from its symbol's art; type's
// outlines, and an image and the paths of its own fills and strokes, measured one by one
// with the geometry effects of those fills and strokes), grown by how far the effects in a
// symbol instance's art paint past that art.
_ if has_object_fx(n) => {
let symbol = match &n.kind {
NodeKind::SymbolInstance { symbol, .. } => {
symbols.document().symbols.iter().find(|s| s.name == *symbol).map(|s| dynamic_art(&s.art, n))
}
_ => None,
};
let reshaped = effects::reshape(Some(symbols.document()), n, symbol.as_ref());
let b = match &reshaped {
Some(r) if has_instance_row_effects(n) => instance_piece_bounds(symbols, r),
Some(r) if matches!(n.kind, NodeKind::Text(_)) || (matches!(n.kind, NodeKind::Image(_)) && !r.clips()) => {
r.children().into_iter().flatten().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, inner(c)))
}
Some(r) => r.visual_bounds_with(symbols),
None => None,
}
.or_else(|| own_box(symbols, n))?;
let a = match &reshaped {
Some(r) if after_reshape => reshaped_art_effects_reach(symbols, n, r),
_ => art_effects_reach(symbols, n),
};
let a = a.max(live_content_reach(symbols, n));
let b = b.inflate(a, a);
Some(with_own_raster_reach(symbols, n, b))
}
NodeKind::SymbolInstance { .. } => {
let b = n.visual_bounds_with(symbols)?;
let a = art_effects_reach(symbols, n);
Some(b.inflate(a, a))
}
_ => {
let b = n.visual_bounds_with(symbols)?;
let b = match &n.kind {
NodeKind::Text(t) => vectorcraft_geom::union_opt(Some(b), glyphs_box(t, n.appearance.outset())).unwrap_or(b),
_ => with_clip_region(symbols, n, b),
};
let a = live_content_reach(symbols, n);
Some(b.inflate(a, a))
}
}
}
/// `b`, the visual bounds of `n`, grown to the region a clip group's or clipping layer's clipping
/// path clips to when geometry effects in it move or grow that region ([`effects::clip_outline`])
/// past its plain shape, and to where its stroke paints along it. Other objects keep `b`.
fn with_clip_region(symbols: &SymbolBoxes, n: &Node, b: Rect) -> Rect {
match &n.kind {
NodeKind::Group { children, clip: true } | NodeKind::Layer { children, clip: true, .. } => match children.first() {
Some(c) if effects::needs_bake(c) => {
let s = c.appearance.outset();
let region = effects::clip_outline(c).map(|(bp, _)| bp.bounding_box().inflate(s, s));
let painted = if has_fx(c) { visual_bounds(symbols, c) } else { None };
vectorcraft_geom::union_opt(vectorcraft_geom::union_opt(Some(b), region), painted).unwrap_or(b)
}
_ => b,
},
_ => b,
}
}
/// The bounds of the art a 3D effect of `n` draws (Revolve, Extrude & Bevel, Inflate, Rotate),
/// built now, without `n`'s own raster effects ([`three_d_art_bounds`]): `None` when it draws no
/// such art, `Some(None)` when that art paints nothing. The renderer measures the art it keeps
/// instead ([`crate::Renderer::bounds_of`]).
fn three_d_bounds(symbols: &SymbolBoxes, n: &Node) -> Option<Option<Rect>> {
if !effects::has_revolve(n) && !effects::has_solid(n) {
return None;
}
let doc = Some(symbols.document());
let art = effects::revolve_art_in(doc, n).or_else(|| effects::solid_art_in(doc, n))?;
Some(three_d_art_bounds(symbols, &art))
}
/// The bounds of `art`, the art a 3D effect draws for an object, as the renderer draws it: with
/// its geometry effects, without the raster effects the object paints over it (which
/// [`with_own_raster_reach`] adds), and each object in it with the raster effects of its own fills
/// and strokes and the art of its brushed strokes (a stroke without a 3D effect of its own keeps
/// its brush): the art itself, which Rasterize and exports take, not the room culling leaves.
pub(crate) fn three_d_art_bounds(symbols: &SymbolBoxes, art: &Node) -> Option<Rect> {
fn pieces(symbols: &SymbolBoxes, n: &Node) -> Option<Rect> {
match &n.kind {
NodeKind::Group { children, clip: false } if !has_object_fx(n) => {
children.iter().filter(|c| c.visible).fold(None, |acc, c| vectorcraft_geom::union_opt(acc, pieces(symbols, c)))
}
// The art its brushed strokes draw, not the room culling leaves for it.
_ => {
let brushed = vectorcraft_brush::has_brush(n)
.then(|| vectorcraft_brush::expand(symbols.document(), n))
.flatten()
.and_then(|art| art.visual_bounds_with(symbols));
vectorcraft_geom::union_opt(cull_bounds(symbols, n), brushed)
}
}
}
let mut art = art.clone();
art.appearance.effects.retain(|e| effects::is_geometry(&e.id));
let art = effects::evaluate_container(Some(symbols.document()), &art).unwrap_or(art);
pieces(symbols, &art)
}
/// `b`, the bounds of what `n` draws, grown by how far `n`'s own raster effects paint past it.
pub(crate) fn with_own_raster_reach(symbols: &SymbolBoxes, n: &Node, b: Rect) -> Rect {
let o = outset(symbols, &n.appearance.effects, b);
b.inflate(o, o)
}
/// `n`'s own visual box, type's grown to hold its glyphs ([`glyphs_box`]): what it draws when its
/// object effects leave it as it is (Revolve builds no art from type).
fn own_box(symbols: &SymbolBoxes, n: &Node) -> Option<Rect> {
let b = n.visual_bounds_with(symbols)?;
Some(match &n.kind {
NodeKind::Text(t) => vectorcraft_geom::union_opt(Some(b), glyphs_box(t, n.appearance.outset())).unwrap_or(b),
_ => b,
})
}
/// The box of type `t`'s glyphs as laid out (its layout bounds, else laid out now), grown by its
/// characters' strokes, miter spikes included, and by `outset`: on a path they stand above it and
/// run past its ends, in an area they can hang past its frame, where its own box
/// ([`Node::visual_bounds_with`]) doesn't.
fn glyphs_box(t: &vectorcraft_doc::TextObject, outset: f64) -> Option<Rect> {
let b = t.cached_bounds.unwrap_or_else(|| vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).bounds);
let o = outset.max(t.char_stroke_reach());
(b.width() > 0.0 || b.height() > 0.0).then(|| t.xf.transform_rect_bbox(b).inflate(o, o))
}
/// How far the content of live object `n` (a blend, envelope or repeat) can paint past its visual
/// bounds: for each object in it, how far the effects in a symbol instance's art paint past that
/// art ([`art_effects_reach`]), how far brush art can paint ([`crate::brush_fx::pad`]) and how far
/// a path's own effects paint past it ([`path_effects_reach`]), on the farthest side; for a path
/// whose live-effect plug-ins paint their pieces, how far its pieces and their brush art reach past
/// it ([`painted_cull_bounds`]). 0 for any other kind of object.
fn live_content_reach(symbols: &SymbolBoxes, n: &Node) -> f64 {
if !vectorcraft_doc::live::is_live(n) {
return 0.0;
}
let mut reach = 0.0f64;
n.walk(&mut |c| {
let own = match painted_cull_bounds(symbols, c) {
Some(b) => match (b, c.visual_bounds_with(symbols)) {
(Some(b), Some(v)) => [v.x0 - b.x0, v.y0 - b.y0, b.x1 - v.x1, b.y1 - v.y1].into_iter().fold(0.0, f64::max),
_ => 0.0,
},
None => art_effects_reach(symbols, c).max(path_effects_reach(symbols, c)) + crate::brush_fx::pad(symbols, c),
};
reach = reach.max(own);
});
reach
}
/// How far the effects of path or compound path `n` (a drop shadow, a glow, a geometry effect)
/// paint past its visual bounds, on its farthest side ([`visual_bounds`]): 0 when it has no
/// visible effects, and for any other kind of object.
fn path_effects_reach(symbols: &SymbolBoxes, n: &Node) -> f64 {
if !has_fx(n) {
return 0.0;
}
match (visual_bounds(symbols, n), n.visual_bounds_with(symbols)) {
(Some(c), Some(v)) => [v.x0 - c.x0, v.y0 - c.y0, c.x1 - v.x1, c.y1 - v.y1].into_iter().fold(0.0, f64::max),
_ => 0.0,
}
}
/// How far the effects in the art of symbol instance `n` (and in the art of the symbols the
/// instances in it show) paint past that art's visual bounds, on its farthest side, measured on the
/// art as the instance places it before its effects run: 0 when the art has no visible effects, and
/// for any other kind of object. The reach is the same wherever the art is moved to, so the art is
/// placed by the linear part of the instance's transform alone, and `symbols` keeps the reach for
/// each symbol and linear part, up to a limit ([`SymbolBoxes::effects_reach`]).
fn art_effects_reach(symbols: &SymbolBoxes, n: &Node) -> f64 {
let NodeKind::SymbolInstance { symbol, xf } = &n.kind else { return 0.0 };
if !symbols.has_effects(symbol) {
return 0.0;
}
let measure = |[m0, m1, m2, m3]: [f64; 4]| {
let past = |art: &Arc<Node>| {
let mut placed = (**art).clone();
placed.transform(Affine::new([m0, m1, m2, m3, 0.0, 0.0]), false);
match (cull_bounds(symbols, &placed), placed.visual_bounds_with(symbols)) {
(Some(c), Some(v)) => [v.x0 - c.x0, v.y0 - c.y0, c.x1 - v.x1, c.y1 - v.y1].into_iter().fold(0.0, f64::max),
_ => 0.0,
}
};
symbols.measure_art(symbol, past).unwrap_or(0.0)
};
let [m0, m1, m2, m3, _, _] = xf.as_coeffs();
symbols.effects_reach(symbol, [m0, m1, m2, m3], &measure)
}
/// How far the effects in the art of symbol instance `n` paint past `r`, that art as `n`'s own
/// geometry effects reshape it ([`effects::reshape`]), on its farthest side: 0 when the art has no
/// visible effects, and for any other kind of object. The art in `r` is measured without the raster
/// effects of `n` that `r` carries, by [`cull_bounds_in`] with `after_reshape` false: the effects in
/// the art of an instance in it are measured before that instance's own geometry effects run.
fn reshaped_art_effects_reach(symbols: &SymbolBoxes, n: &Node, r: &Node) -> f64 {
let NodeKind::SymbolInstance { symbol, .. } = &n.kind else { return 0.0 };
if !symbols.has_effects(symbol) {
return 0.0;
}
let art = r.children().into_iter().flatten().fold(None, |acc, c| vectorcraft_geom::union_opt(acc, cull_bounds_in(symbols, c, false, false)));
match (art, r.visual_bounds_with(symbols)) {
(Some(c), Some(v)) => [v.x0 - c.x0, v.y0 - c.y0, c.x1 - v.x1, c.y1 - v.y1].into_iter().fold(0.0, f64::max),
_ => 0.0,
}
}