use std::collections::BTreeSet; use vectorcraft_doc::live::BlendSpineMode; use super::common::{ DEFAULT_DISTANCE, DEFAULT_STEPS, ease_param, fix_ids, ids_json, is_blend, orientation_param, percent_param, roots_param, selected_of, spacing_param, starts_param, wrap, }; use super::mesh::index_param; use super::{ Affine, Anchor, Appearance, Arc, Beside, BlendDefaults, BlendOrientation, BlendSpacing, BlendSpec, Document, EngineError, Node, NodeId, NodeKind, Paint, PathData, Point, Result, Session, Spine, Value, Vec2, bad, f64_req, json, live, number_or, ok, str_param, switch_or, }; /// The first blend among `roots`. fn first_blend(d: &Document, roots: &[NodeId]) -> Option { roots.iter().filter_map(|r| d.node(*r)).find(|n| is_blend(n)).cloned() } /// Key objects of a blend made of `nodes` (paint order) and their start points: a blend among /// them gives its keys (with theirs), the other objects are keys themselves. fn merge_keys(nodes: Vec>, starts: &[(NodeId, u32)]) -> (Vec>, Vec>) { let (mut keys, mut st) = (vec![], vec![]); for n in nodes { match &n.kind { NodeKind::Blend { children, spec } => { st.extend((0..children.len()).map(|i| spec.starts.get(i).copied().flatten())); keys.extend(children.iter().cloned()); } _ => { st.push(starts.iter().find(|(id, _)| *id == n.id).map(|(_, a)| *a)); keys.push(n); } } } if st.iter().all(Option::is_none) { st.clear(); } (keys, st) } /// The spine of a blend of `keys` made by giving blend `old` (spec `old_spec`) more keys: its /// spine pinned, with a straight segment to each new key before or after its own (a closed spine /// gives way to the straight lines between the keys). fn extend_spine(spec: &mut BlendSpec, old: &[Arc], old_spec: &BlendSpec, keys: &[Arc]) { if old_spec.spine.is_none() { return; } let Some((mut path, anchors)) = live::pin_spine(old, old_spec) else { return }; let Some(first) = old.first().and_then(|f| keys.iter().position(|k| k.id == f.id)) else { return }; let Some(sp) = path.subpaths.first_mut().filter(|sp| !sp.closed) else { return }; let center = |k: &Arc| vectorcraft_geom::Anchor::corner(k.geometric_bounds().map(|b| b.center()).unwrap_or_default()); let before: Vec<_> = keys.iter().take(first).map(center).collect(); let after: Vec<_> = keys.iter().skip(first + old.len()).map(center).collect(); let shift = before.len(); sp.anchors.splice(0..0, before); let n = sp.anchors.len(); sp.anchors.extend(after); let mut ka: Vec = (0..shift).collect(); ka.extend(anchors.iter().map(|a| a + shift)); ka.extend(n..sp.anchors.len()); spec.key_anchors = ka.iter().map(|a| u32::try_from(*a).unwrap_or(u32::MAX)).collect(); spec.spine = Some(path); } /// Does `p` set easing (`easingType` or `ramp`)? Easing needs a spine. fn gives_easing(p: &Value) -> bool { ["easingType", "ramp"].iter().any(|key| p.get(*key).is_some_and(|v| !v.is_null())) } /// The Create Spine mode `p` gives as `key`, or `current` when it is omitted or null. fn spine_mode_param(p: &Value, cmd: &str, key: &str, current: BlendSpineMode) -> Result { match p.get(key).filter(|v| !v.is_null()) { None => Ok(current), Some(v) => v.as_str().and_then(BlendSpineMode::from_id).ok_or_else(|| bad(cmd, format!("`{key}` must be one of auto, always, never"))), } } pub(super) fn blend_make(s: &mut Session, p: &Value) -> Result { const C: &str = "object.blend.make"; let roots = roots_param(s, p)?; if roots.len() < 2 { return Err(bad(C, "select at least two objects")); } let starts = starts_param(p, &roots)?; let base = first_blend(&s.doc()?.doc, &roots); let defaults = s.prefs.blend_options.unwrap_or_default(); // Create Spine applies to a new blend; one taking more keys keeps whether it has a spine. let create_spine = spine_mode_param(p, C, "createSpine", defaults.create_spine)?; let cur = match base.as_ref().map(|n| &n.kind) { Some(NodeKind::Blend { spec, .. }) => BlendDefaults { spacing: spec.spacing, orientation: spec.orientation, ..defaults }, _ => defaults, }; let spacing = spacing_param(p, C, cur.spacing)?; let orientation = orientation_param(p, C, cur.orientation)?; let (ease0, color0, no_spine) = match base.as_ref().map(|n| &n.kind) { Some(NodeKind::Blend { spec, .. }) => (spec.ease, spec.color_shift, spec.no_spine), _ => (Default::default(), 0.0, !create_spine.creates_spine()), }; if no_spine && gives_easing(p) { return Err(bad(C, "the blend has no spine")); } let ease = ease_param(p, C, ease0)?; let color_shift = percent_param(p, C, "colorShift", color0, -100.0)?; let id = s.edit("Make Blend", |d, sel| { wrap(d, sel, &roots, |id, nodes| { let (children, starts) = merge_keys(nodes, &starts); // A blend taking more keys keeps its name, transparency and spine; a new one is a // knockout group, so translucent steps don't show through each other. let mut n = base.unwrap_or_else(|| { let mut n = Node::new(id, NodeKind::Group { children: vec![], clip: false }); n.knockout = vectorcraft_doc::Knockout::On; n }); let mut spec = BlendSpec { spacing, orientation, ease, color_shift, starts, no_spine, ..Default::default() }; if let NodeKind::Blend { children: old, spec: old_spec } = &n.kind { extend_spine(&mut spec, old, old_spec, &children); } n.id = id; n.kind = NodeKind::Blend { children, spec: Box::new(spec) }; n }) })?; Ok(json!({ "id": id.0 })) } pub(super) fn blend_release(s: &mut Session, _: &Value) -> Result { let blends = selected_of(s, is_blend); let (ids, spines, groups) = s.edit("Release Blend", |d, sel| { let (mut keys, mut spines, mut groups) = (vec![], vec![], vec![]); let mut released = Beside::replacing(d, &blends); for b in &blends { let Some(n) = d.node(*b).cloned() else { continue }; let NodeKind::Blend { children, spec } = &n.kind else { continue }; // The spine stays behind as a path that paints nothing, below the keys. let mut nodes = vec![]; if let Some((path, _)) = live::blend_spine(children, spec) { let id = d.alloc_id(); spines.push(id); nodes.push(Node::path(id, path, Appearance::basic(Paint::None, Paint::None, 0.0))); } keys.extend(children.iter().map(|c| c.id)); nodes.extend(children.iter().map(|c| (**c).clone())); // What the blend itself carries stays on a group around what it gave back. if n.name.is_some() || n.opacity < 1.0 || n.blend != vectorcraft_color::BlendMode::Normal || n.isolate || n.extras().mask.is_some() || !n.appearance.items.is_empty() || !n.appearance.effects.is_empty() { let mut g = n.clone(); g.kind = NodeKind::Group { children: nodes.into_iter().map(Arc::new).collect(), clip: false }; groups.push(g.id); nodes = vec![g]; } released.put(d, *b, nodes)?; } released.finish(d)?; if groups.is_empty() { sel.set(spines.iter().chain(&keys).copied()); } else { sel.set(groups.iter().copied()); } Ok((keys, spines, groups)) })?; let mut r = ids_json(&ids); r["spines"] = json!(spines.iter().map(|i| i.0).collect::>()); r["groups"] = json!(groups.iter().map(|i| i.0).collect::>()); Ok(r) } /// The blend `id` (default: the first selected), its spine pinned to its keys (see /// [`live::pin_spine`]) and given to `f` with the key anchors and the keys; the result is stored /// as the blend's spine, one undo step. fn edit_spine( s: &mut Session, p: &Value, cmd: &str, label: &str, f: impl FnOnce(&mut vectorcraft_geom::SubPath, &mut Vec, &mut [Arc]) -> Result, ) -> Result { let id = match crate::cmd::object_param(p, "id", cmd)? { Some(id) => id, None => *selected_of(s, is_blend).first().ok_or_else(|| bad(cmd, "select a blend or give `id`"))?, }; let c = cmd.to_string(); s.edit(label, move |d, _| { let Some(NodeKind::Blend { children, spec }) = d.node_mut(id).map(|n| &mut n.kind) else { return Err(bad(&c, "not a blend")) }; let (mut path, mut anchors) = live::pin_spine(children, spec).ok_or_else(|| bad(&c, "the blend has no spine"))?; let sp = path.subpaths.first_mut().ok_or_else(|| bad(&c, "the blend has no spine"))?; let out = f(sp, &mut anchors, children)?; spec.key_anchors = anchors.iter().map(|a| u32::try_from(*a).unwrap_or(u32::MAX)).collect(); spec.spine = Some(path); Ok(out) }) } /// A point parameter that must be finite. fn finite_point(p: &Value, cmd: &str) -> Result { let q = Point::new(f64_req(p, "x", cmd)?, f64_req(p, "y", cmd)?); if q.x.is_finite() && q.y.is_finite() && q.x.abs() < 1e9 && q.y.abs() < 1e9 { Ok(q) } else { Err(bad(cmd, "x and y must be finite")) } } /// Most spine points `with` names. const MAX_SPINE_POINTS: usize = 10_000; /// The optional `with` list of spine point indexes (empty when absent). fn spine_points_param(p: &Value, cmd: &str) -> Result> { let Some(v) = p.get("with").filter(|v| !v.is_null()) else { return Ok(vec![]) }; let wrong = || bad(cmd, "`with` must be a list of at most 10000 spine point indexes"); let list = v.as_array().filter(|l| l.len() <= MAX_SPINE_POINTS).ok_or_else(wrong)?; list.iter().map(|i| i.as_u64().and_then(|i| usize::try_from(i).ok()).ok_or_else(wrong)).collect() } pub(super) fn spine_move_anchor(s: &mut Session, p: &Value) -> Result { const C: &str = "object.blend.spine.moveAnchor"; let index = index_param(p, "anchor", C)?; let q = finite_point(p, C)?; let handle = match str_param(p, "handle") { None => None, Some("out") => Some(true), Some("in") => Some(false), Some(_) => return Err(bad(C, "handle must be in or out")), }; let independent = switch_or(p, "independent", false, C)?; let with = spine_points_param(p, C)?; // Any `with`, even an empty list, asks to move points, which a handle drag doesn't. if handle.is_some() && p.get("with").is_some_and(|v| !v.is_null()) { return Err(bad(C, "`with` moves points, not a handle")); } edit_spine(s, p, C, "Reshape Spine", |sp, anchors, keys| { let a = sp.anchors.get_mut(index).ok_or_else(|| bad(C, "no such spine point"))?; if let Some(out) = handle { a.set_handle(out, q, independent); return Ok(()); } let delta = q - a.p; // The other points selected with it (#5285) move as far. let moved: BTreeSet = with.iter().copied().chain([index]).collect(); for &i in &moved { sp.anchors.get_mut(i).ok_or_else(|| bad(C, "no such spine point"))?.translate(delta); } // The key objects on the points move with them. for (k, _) in anchors.iter().enumerate().filter(|(_, a)| moved.contains(*a)) { if let Some(key) = keys.get_mut(k) { Arc::make_mut(key).transform(Affine::translate(delta), false); } } Ok(()) })?; ok() } pub(super) fn spine_convert_anchor(s: &mut Session, p: &Value) -> Result { const C: &str = "object.blend.spine.convertAnchor"; let index = index_param(p, "anchor", C)?; let smooth = match str_param(p, "to") { Some("smooth") => true, Some("corner") => false, _ => return Err(bad(C, "to must be smooth or corner")), }; let target = match (p.get("x"), p.get("y")) { (None, None) => None, (Some(_), Some(_)) => Some(finite_point(p, C)?), _ => return Err(bad(C, "x and y must be given together")), }; edit_spine(s, p, C, "Convert Anchor Point", |sp, _, _| { if smooth && target.is_none() { if index >= sp.anchors.len() { return Err(bad(C, "no such spine point")); } vectorcraft_tools::draw2::curvature_smooth(sp, index); return Ok(()); } let a = sp.anchors.get_mut(index).ok_or_else(|| bad(C, "no such spine point"))?; match target { Some(q) if smooth && q.distance(a.p) > 1e-9 => *a = Anchor::smooth(a.p, q), _ => a.retract(), } Ok(()) })?; ok() } pub(super) fn spine_reshape_segment(s: &mut Session, p: &Value) -> Result { const C: &str = "object.blend.spine.reshapeSegment"; let seg = index_param(p, "segment", C)?; let t = number_or(p, "t", 0.5, C)?.clamp(0.05, 0.95); let dv = Vec2::new(number_or(p, "dx", 0.0, C)?, number_or(p, "dy", 0.0, C)?); if !(t.is_finite() && dv.x.is_finite() && dv.y.is_finite() && dv.hypot() < 1e9) { return Err(bad(C, "t, dx and dy must be finite")); } let perpendicular = switch_or(p, "perpendicular", false, C)?; edit_spine(s, p, C, "Reshape Spine", |sp, _, _| { let bent = if perpendicular { sp.bend_segment_perpendicular(seg, t, dv) } else { sp.bend_segment(seg, t, dv) }; if bent { Ok(()) } else { Err(bad(C, "no such spine segment")) } })?; ok() } pub(super) fn spine_add_anchor(s: &mut Session, p: &Value) -> Result { const C: &str = "object.blend.spine.addAnchor"; let q = finite_point(p, C)?; let index = edit_spine(s, p, C, "Add Spine Point", |sp, anchors, _| { let (_, seg, t, _, _) = PathData::single(sp.clone()).nearest(q).ok_or_else(|| bad(C, "the spine has no segments"))?; let i = sp.insert_anchor(seg, t.clamp(1e-3, 1.0 - 1e-3)); for a in anchors.iter_mut().filter(|a| **a >= i) { *a += 1; } Ok(i) })?; Ok(json!({ "anchor": index })) } pub(super) fn spine_remove_anchor(s: &mut Session, p: &Value) -> Result { const C: &str = "object.blend.spine.removeAnchor"; let index = index_param(p, "anchor", C)?; edit_spine(s, p, C, "Delete Spine Point", |sp, anchors, _| { if index >= sp.anchors.len() { return Err(bad(C, "no such spine point")); } if anchors.contains(&index) { return Err(bad(C, "a key object sits on that point")); } // A closed spine pinned open keeps a copy of its first point at its end (#6809), so the // points left must be two apart, not only two in number. let mut rest = sp.anchors.iter().enumerate().filter(|(i, _)| *i != index).map(|(_, a)| a.p); let first = rest.next(); if sp.anchors.len() <= 2 || first.is_none_or(|f| rest.all(|q| q.distance(f) < 0.01)) { return Err(bad(C, "a spine keeps at least two points")); } sp.anchors.remove(index); for a in anchors.iter_mut().filter(|a| **a > index) { *a -= 1; } Ok(()) })?; ok() } fn edit_blends(s: &mut Session, label: &str, f: impl Fn(&mut Vec>, &mut BlendSpec)) -> Result { let blends = selected_of(s, is_blend); s.edit(label, |d, _| { for b in &blends { if let Some(NodeKind::Blend { children, spec }) = d.node_mut(*b).map(|n| &mut n.kind) { f(children, spec); } } Ok(()) })?; ok() } /// The first selected blend: its id, spec and key ids. fn selected_spec(s: &Session) -> Option<(NodeId, BlendSpec, Vec)> { let b = *selected_of(s, is_blend).first()?; match &s.doc().ok()?.doc.node(b)?.kind { NodeKind::Blend { spec, children } => Some((b, (**spec).clone(), children.iter().map(|c| c.id).collect())), _ => None, } } pub(super) fn blend_options(s: &mut Session, p: &Value) -> Result { const C: &str = "object.blend.options"; let id = crate::cmd::object_param(p, "id", C)?; let target = match id { Some(id) => { let doc = &s.doc()?.doc; match doc.node(id).map(|n| &n.kind) { Some(NodeKind::Blend { .. }) if !doc.is_editable(id) => return Err(bad(C, "the object is hidden or locked")), Some(NodeKind::Blend { spec, children }) => Some((id, (**spec).clone(), children.iter().map(|c| c.id).collect())), _ => return Err(bad(C, "not a blend")), } } None => selected_spec(s), }; let Some((_, cur, _)) = target else { if ["easingType", "ramp", "colorShift"].iter().any(|key| p.get(*key).is_some_and(|v| !v.is_null())) { return Err(bad(C, "select a blend to set easing or color shift")); } // Nothing to set them on: the options new blends start with (easing is per blend). let d = s.prefs.blend_options.unwrap_or_default(); let spacing = spacing_param(p, C, d.spacing)?; let orientation = orientation_param(p, C, d.orientation)?; s.prefs.blend_options = Some(BlendDefaults { spacing, orientation, ..d }); return Ok(json!({ "defaults": true })); }; let no_spine = if id.is_some() { cur.no_spine } else { any_without_spine(s) }; if gives_easing(p) && no_spine { return Err(bad(C, "the blend has no spine")); } // Every value is checked before anything changes. Each blend then takes only the values that // were given and keeps its own for the rest, so editing several blends does not copy the first // one's options onto the others. let given = |key: &str| p.get(key).is_some_and(|v| !v.is_null()); let has_count = given("value") || given("steps") || given("distance"); let has_spacing = given("spacing") || has_count || p.get("smooth").and_then(Value::as_bool) == Some(true); let spacing = spacing_param(p, C, cur.spacing)?; let orientation = orientation_param(p, C, cur.orientation)?; let ease = ease_param(p, C, cur.ease)?; let color_shift = percent_param(p, C, "colorShift", cur.color_shift, -100.0)?; let (has_orientation, has_kind, has_ramp, has_shift) = (given("orientation"), given("easingType"), given("ramp"), given("colorShift")); let set = |spec: &mut BlendSpec| { // A spacing mode without a count keeps the count of a blend already in that mode. let same_mode = std::mem::discriminant(&spacing) == std::mem::discriminant(&spec.spacing); if has_spacing && (has_count || !same_mode) { spec.spacing = spacing; } if has_orientation { spec.orientation = orientation; } if has_kind { spec.ease.kind = ease.kind; } if has_ramp { spec.ease.ramp = ease.ramp; } if has_shift { spec.color_shift = color_shift; } }; let targets = match id { Some(id) => vec![id], None => selected_of(s, is_blend), }; let doc = &s.doc()?.doc; let changes = |b: &NodeId| match doc.node(*b).map(|n| &n.kind) { Some(NodeKind::Blend { spec, .. }) => { let mut next = (**spec).clone(); set(&mut next); next != **spec } _ => false, }; if !targets.iter().any(changes) { return ok(); } match id { Some(id) => { s.edit("Blend Options", |d, _| { if let Some(NodeKind::Blend { spec, .. }) = d.node_mut(id).map(|n| &mut n.kind) { set(spec); } Ok(()) })?; ok() } None => edit_blends(s, "Blend Options", |_, spec| set(spec)), } } pub(super) fn blend_set_easing(s: &mut Session, p: &Value) -> Result { const C: &str = "object.blend.setEasing"; let id = match crate::cmd::object_param(p, "id", C)? { Some(id) => id, None => *selected_of(s, is_blend).first().ok_or_else(|| bad(C, "select a blend or give `id`"))?, }; let doc = &s.doc()?.doc; let Some(NodeKind::Blend { children, spec }) = doc.node(id).map(|n| &n.kind) else { return Err(bad(C, "not a blend")) }; if !doc.is_editable(id) { return Err(bad(C, "the object is hidden or locked")); } let ease = ease_param(p, C, spec.ease)?; let color_shift = percent_param(p, C, "colorShift", spec.color_shift, -100.0)?; // Easing moves the steps along a spine, so it needs one with a length to run along. let easing = ["easingType", "ramp"].iter().any(|key| p.get(*key).is_some_and(|v| !v.is_null())); let spined = spec.eases_along_spine() && live::blend_spine(children, spec).and_then(|(path, _)| Spine::new(&path)).is_some_and(|sp| sp.length().is_finite() && sp.length() > 0.0); if easing && !spined { return Err(bad(C, "the blend has no spine")); } let changed = ease != spec.ease || color_shift != spec.color_shift; if changed { s.edit("Blend Options", |d, _| { if let Some(NodeKind::Blend { spec, .. }) = d.node_mut(id).map(|n| &mut n.kind) { spec.ease = ease; spec.color_shift = color_shift; } Ok(()) })?; } Ok(json!({ "id": id.0, "easingType": ease.kind.id(), "ramp": ease.ramp * 100.0, "colorShift": color_shift, "changed": changed })) } /// Spacing and orientation as `object.blend.options` takes them; the step count and distance /// not in use show their defaults. fn blend_options_json(spacing: BlendSpacing, orientation: BlendOrientation) -> Value { let (mode, steps, distance) = match spacing { BlendSpacing::SmoothColor => ("smooth", DEFAULT_STEPS, DEFAULT_DISTANCE), BlendSpacing::Steps(n) => ("steps", n, DEFAULT_DISTANCE), BlendSpacing::Distance(d) => ("distance", DEFAULT_STEPS, d), }; let orientation = if orientation == BlendOrientation::AlignToPath { "path" } else { "page" }; json!({ "spacing": mode, "steps": steps, "distance": distance, "orientation": orientation }) } pub(super) fn blend_info(s: &mut Session, _: &Value) -> Result { Ok(match selected_spec(s) { Some((id, spec, keys)) => { let mut v = blend_options_json(spec.spacing, spec.orientation); v["target"] = json!("blend"); v["id"] = json!(id.0); v["easingType"] = json!(spec.ease.kind.id()); v["ramp"] = json!(spec.ease.ramp * 100.0); v["colorShift"] = json!(spec.color_shift); v["starts"] = json!((0..keys.len()).map(|i| spec.start(i)).collect::>()); v["keys"] = json!(keys.iter().map(|k| k.0).collect::>()); v["hasSpine"] = json!(!spec.no_spine); if let Some(NodeKind::Blend { children, .. }) = s.doc()?.doc.node(id).map(|n| &n.kind) && let Some((path, anchors)) = live::blend_spine(children, &spec) && let Some(sp) = path.subpaths.first() { let pt = |p: Point| json!([p.x, p.y]); let points: Vec = sp.anchors.iter().map(|a| json!({"x": a.p.x, "y": a.p.y, "in": pt(a.h_in), "out": pt(a.h_out)})).collect(); v["spine"] = json!({"anchors": points, "closed": sp.closed, "keyAnchors": anchors, "explicit": spec.spine.is_some()}); } v } None => { let d = s.prefs.blend_options.unwrap_or_default(); let mut v = blend_options_json(d.spacing, d.orientation); v["target"] = json!("defaults"); v } }) } /// The Blend panel's Create Spine: with `mode`, sets whether new blends get a spine; without, reads /// it. A tool setting kept with the preferences, not an undo step; blends already made keep theirs. pub(super) fn blend_create_spine(s: &mut Session, p: &Value) -> Result { const C: &str = "object.blend.createSpine"; let mut d = s.prefs.blend_options.unwrap_or_default(); let mode = spine_mode_param(p, C, "mode", d.create_spine)?; if mode != d.create_spine { d.create_spine = mode; s.prefs.blend_options = Some(d); } Ok(json!({ "mode": mode.id() })) } pub(super) fn blend_expand(s: &mut Session, _: &Value) -> Result { let blends = selected_of(s, is_blend); let ids = s.edit("Expand Blend", |d, sel| { for b in &blends { expand_blend(d, *b)?; } sel.set(blends.iter().copied()); Ok(blends.clone()) })?; Ok(ids_json(&ids)) } /// Replace blend `id` by a group of its keys and steps in place, keeping everything about the /// blend itself: id, name, visibility, lock, transparency (knockout and isolation included), /// opacity mask and appearance. fn expand_blend(d: &mut Document, id: NodeId) -> Result<()> { let Some(n) = d.node(id).filter(|n| is_blend(n)).cloned() else { return Ok(()) }; let mut g = n.clone(); g.kind = NodeKind::Group { children: vectorcraft_render::expand_live(&n).into_iter().map(Arc::new).collect(), clip: false }; fix_ids(d, &mut g); *d.node_mut(id).ok_or(EngineError::NoNode(id))? = g; Ok(()) } /// Object › Expand: every blend in the subtrees of `roots` (outer ones first) becomes a group of /// its steps ([`expand_blend`]). Returns how many. pub(crate) fn expand_blends(d: &mut Document, roots: &[NodeId]) -> Result { let mut blends = vec![]; for r in roots { if let Some(n) = d.node(*r) { n.walk(&mut |c| { if is_blend(c) { blends.push(c.id); } }); } } for b in &blends { expand_blend(d, *b)?; } Ok(blends.len()) } /// Move the keys onto their spine positions (so what's stored matches what's drawn): onto their /// anchors, or spread evenly by arc length along a spine from Replace Spine. fn keys_to_spine(children: &mut [Arc], spec: &BlendSpec) { let Some(path) = &spec.spine else { return }; let k = children.len(); let pinned = spec.key_anchors.len() == k; let sp = Spine::new(path); for (i, c) in children.iter_mut().enumerate() { let pt = if pinned { spec.key_anchors.get(i).and_then(|a| path.subpaths.first()?.anchors.get(*a as usize)).map(|a| a.p) } else { sp.as_ref().map(|sp| sp.at(if k > 1 { i as f64 / (k - 1) as f64 } else { 0.0 }).0) }; if let (Some(pt), Some(b)) = (pt, c.geometric_bounds()) { Arc::make_mut(c).transform(Affine::translate(pt - b.center()), false); } } } /// Store the blend's spine pinned to its keys (see [`live::pin_spine`]); false when it has none. fn pin(children: &[Arc], spec: &mut BlendSpec) -> bool { match live::pin_spine(children, spec) { Some((path, anchors)) => { spec.spine = Some(path); spec.key_anchors = anchors.iter().map(|a| u32::try_from(*a).unwrap_or(u32::MAX)).collect(); true } None => false, } } /// `spec`'s spine reversed: the key anchors count from the other end. fn reverse_spine(spec: &mut BlendSpec) { if let Some(sp) = &mut spec.spine { sp.reverse(); let n = sp.subpaths.first().map_or(0, |s| s.anchors.len() as u32); for a in &mut spec.key_anchors { *a = n.saturating_sub(1).saturating_sub(*a); } } } pub(super) fn blend_replace_spine(s: &mut Session, _: &Value) -> Result { let blends = selected_of(s, is_blend); let st = s.doc()?; let path = st .selection .objects .iter() .copied() .find(|id| { !blends.contains(id) && st.doc.node(*id).is_some_and(|n| n.path_data().is_some()) && !blends.iter().any(|b| st.doc.ancestry(*id).unwrap_or_default().contains(b)) }) .ok_or_else(|| EngineError::Other("Replace Spine: select a blend and a path".into()))?; let Some(&b) = blends.first() else { return Err(EngineError::Other("Replace Spine: select a blend and a path".into())) }; s.edit("Replace Spine", |d, sel| { let spine = d.node(path).and_then(|n| n.path_data().cloned()).ok_or(EngineError::NoNode(path))?; d.remove(path)?; if let Some(NodeKind::Blend { children, spec }) = d.node_mut(b).map(|n| &mut n.kind) { // A blend made without a spine gets this one. spec.no_spine = false; spec.spine = Some(spine); spec.key_anchors.clear(); keys_to_spine(children, spec); } sel.set([b]); Ok(()) })?; ok() } /// Is any selected blend one made without a spine? pub(super) fn any_without_spine(s: &Session) -> bool { super::common::any_selected_of(s, is_blend, |n| matches!(&n.kind, NodeKind::Blend { spec, .. } if spec.no_spine)) } pub(super) fn blend_reverse_spine(s: &mut Session, _: &Value) -> Result { if any_without_spine(s) { return Err(bad("object.blend.reverseSpine", "the blend has no spine")); } edit_blends(s, "Reverse Spine", |children, spec| { if spec.spine.is_some() && pin(children, spec) { // The keys keep their anchors, which now count from the other end. if let Some(sp) = &mut spec.spine { sp.reverse(); } keys_to_spine(children, spec); } else { let centers: Vec = children.iter().map(|k| k.geometric_bounds().map(|b| b.center()).unwrap_or_default()).collect(); let n = children.len(); for (i, k) in children.iter_mut().enumerate() { Arc::make_mut(k).transform(Affine::translate(centers[n - 1 - i] - centers[i]), false); } } }) } pub(super) fn blend_reverse_stack(s: &mut Session, _: &Value) -> Result { edit_blends(s, "Reverse Front to Back", |children, spec| { children.reverse(); // Each key keeps its start point. if !spec.starts.is_empty() { spec.starts.resize(children.len(), None); spec.starts.reverse(); } // Each key keeps its place: on its anchor, or (spread evenly) with the spine reversed. spec.key_anchors.reverse(); reverse_spine(spec); }) }