Files
AniCraft/crates/engine/src/cmds_draw.rs
T

1033 lines
51 KiB
Rust

//! Drawing, selection, element and symbol commands.
use crate::params::*;
use crate::{CommandSpec, EngineError, Result, Selection, Session};
use anicraft_doc::{ColorEffect, ColorStyle, Element, ElementId, ElementKind, Layer, LayerId, LibraryEntry, LibraryItem, LoopMode, Paint, ScaleGrid, Shape, Stroke, Symbol, SymbolId, SymbolKind, Timeline};
use anicraft_geom::{Affine, Decomposed, Path, Vec2};
use serde_json::{Value, json};
use std::sync::Arc;
pub fn specs() -> Vec<CommandSpec> {
let c = |id, label, menu, shortcut, params, mutates, run| CommandSpec { id, label, menu, shortcut, params, mutates, run };
vec![
c("draw.rect", "Rectangle", "", None, "{x, y, w, h, radius?, fill?, stroke?, stroke_width?, profile?, cap?, join?, style?, dash?, object?}", true, draw_rect as crate::RunFn),
c("draw.ellipse", "Oval", "", None, "{x, y, w, h, fill?, stroke?, stroke_width?, profile?, cap?, join?, style?, dash?, object?}", true, draw_ellipse),
c("draw.star", "PolyStar", "", None, "{cx, cy, outer, inner?, points?, fill?, stroke?, profile?, cap?, join?, style?, dash?, object?}", true, draw_star),
c("draw.line", "Line", "", None, "{x0, y0, x1, y1, stroke?, stroke_width?, profile? (a width profile name or [[t, left, right], ..]), cap?, join?, miter?, style?, dash?, dash_offset?, dot_spacing? (the line style, as stroke.set_style; default: the tool's), object? (true: a drawing object; default: Object Drawing, off: it merges with the raw shapes it touches)}", true, draw_line),
c("draw.object_drawing", "Object Drawing", "", Some("J"), "{on?: bool} (default: toggle)", false, object_drawing),
c("draw.snap_to_objects", "Snap to Objects", "View/Snapping", Some("Ctrl+Shift+/"), "{on?: bool} (default: toggle) dragged points and selections, and the points the Line, Rectangle, Oval, PolyStar and Pen tools draw, snap to points, lines and fill edges (the `snap` params of element.translate, raw.move_point, raw.move_handle and draw.snap do nothing while it is off)", false, snap_to_objects),
c("edit.select_all", "Select All", "Edit", Some("Ctrl+A"), "{}", false, select_all),
c("edit.deselect", "Deselect All", "Edit", Some("Ctrl+Shift+A"), "{}", false, |s, _| {
s.selection.clear();
Ok(json!({"selected": 0}))
}),
c("edit.delete", "Clear", "Edit", Some("Delete"), "{} (on every layer with selected items)", true, delete_selection),
c("edit.duplicate", "Duplicate", "Edit", Some("Ctrl+D"), "{dx?, dy?} (each copy on its original's layer)", true, |s, p| s.each_layer(true, |s| duplicate(s, p))),
c("element.select", "Select Elements", "", None, "{ids: [..], add?: bool, toggle?: bool, layer?} selects elements on any visible, unlocked layer at the playhead (ids are unique; `layer` looks only there); `toggle` takes each one that is selected out of the selection and adds the others (Shift+Space on a stage element); the active layer becomes the first one's unless it has some of them", false, select),
c("element.pick", "Select at Point", "", None, "{x, y, add?: bool} the topmost element there on a visible, unlocked layer; `add` (Shift) adds it to the selection, or lets go of it, on any layer", false, pick),
c("element.translate", "Move", "", None, "{dx, dy, snap?, from?: [x, y]} moves the selection, on every layer; with `snap` (a distance) one of its corners or ends (the nearest to `from`) then snaps onto a point, line or fill edge of the rest within that distance", true, translate),
c("element.set_transform", "Transform", "", None, "{x?, y?, sx?, sy?, rotation? (degrees)}", true, |s, p| s.each_layer(true, |s| set_transform(s, p))),
c("element.set_fill", "Fill Colour", "", None, "{color: \"#rrggbb\" | null}", true, |s, p| s.each_layer(false, |s| set_fill(s, p))),
c("element.set_stroke", "Stroke", "", None, "{color?: \"#rrggbb\" | null, width?, profile?: uniform|taper_both|taper_start|taper_end|bulge|pinch | [[t, left, right], ..], cap?, join?, miter?, style?, dash?, dash_offset?, dot_spacing? (as stroke.set_style)}", true, |s, p| s.each_layer(false, |s| set_stroke(s, p))),
c("element.set_alpha", "Alpha", "", None, "{alpha: 0..1} sets the alpha multiplier and keeps the rest of the colour effect (None becomes Alpha; Brightness and Tint become Advanced below 1)", true, |s, p| s.each_layer(true, |s| set_alpha(s, p))),
c("element.set_color_effect", "Colour Effect", "", None, "{style?: none|brightness|tint|advanced|alpha (default: the style the values belong to, else each element's own), alpha? (%, 0..100), brightness? (%, -100..100), tint? (#rrggbb), tint_amount? (%, 0..100), red_multiplier?, green_multiplier?, blue_multiplier?, alpha_multiplier? (%, -100..100), red_offset?, green_offset?, blue_offset?, alpha_offset? (-255..255)} on every selected element (ADR 0056); values not given keep each element's own. A new style starts from the look it can keep: Advanced is exactly the effect before, Alpha keeps the opacity, Brightness and Tint start at 0 %. The camera's effect is a tint", true, |s, p| s.each_layer(true, |s| set_color_effect(s, p))),
c("element.set_blend", "Blending", "", None, "{mode: normal|layer|darken|multiply|lighten|screen|overlay|hardlight|add|subtract|difference|invert|alpha|erase} on the selected movie clip and button instances", true, |s, p| s.each_layer(false, |s| set_blend(s, p))),
c("element.set_filters", "Filters", "", None, "{filters: [{type: blur|drop_shadow|glow|bevel|gradient_glow|gradient_bevel|adjust_color, …values}]} replaces the selected movie clip and button instances' filters (in order; [] removes them). Bevel: shadow_color, highlight_color, side: inner|outer|full, knockout; gradient filters: stops: [{offset 0..1, color \"#rrggbbaa\"}] (Gradient Glow's start and Gradient Bevel's middle stay transparent)", true, |s, p| s.each_layer(false, |s| set_filters(s, p))),
c("element.set_loop", "Looping", "", None, "{loop?: loop|play_once|single_frame, first_frame?}", true, |s, p| s.each_layer(false, |s| set_loop(s, p))),
c("symbol.set_kind", "Symbol Type", "", None, "{kind: graphic|movie_clip|button, symbol?: id (default: the symbols of every selected instance)}", true, set_symbol_kind),
c(
"symbol.set_scale_grid",
"9-Slice Scaling",
"",
None,
"{symbol?: id (default: the symbol open for editing, else the selected instance's), on?: bool, left?, right?, top?, bottom? (guide positions in the symbol's space)} turns a symbol's guides for 9-slice scaling on or off, or moves them (ADR 0055). Turning them on brings back the guides it had when they were turned off (ADR 0057), else puts them a quarter of the way in from each edge of the symbol's artwork; moving one turns them on. Scaled instances then keep the corners outside the guides unscaled, stretch the edges one way and the centre both ways → {symbol, scale_grid: {left, right, top, bottom} | null}",
true,
set_scale_grid,
),
c("element.rename", "Instance Name", "", None, "{name}", true, |s, p| s.each_layer(true, |s| rename(s, p))),
c("arrange.bring_to_front", "Bring to Front", "Modify/Arrange", Some("Ctrl+Shift+Up"), "{} (within each layer)", true, |s, _| s.each_layer(true, |s| arrange(s, true))),
c("arrange.bring_forward", "Bring Forward", "Modify/Arrange", Some("Ctrl+Up"), "{} (within each layer)", true, |s, _| s.each_layer(true, |s| arrange_step(s, true))),
c("arrange.send_backward", "Send Backward", "Modify/Arrange", Some("Ctrl+Down"), "{} (within each layer)", true, |s, _| s.each_layer(true, |s| arrange_step(s, false))),
c("arrange.send_to_back", "Send to Back", "Modify/Arrange", Some("Ctrl+Shift+Down"), "{} (within each layer)", true, |s, _| s.each_layer(true, |s| arrange(s, false))),
c("modify.convert_to_symbol", "Convert to Symbol…", "Modify", Some("F8"), "{name? (default: the next free “Symbol n”; a name the folder holds gets a number), kind?: graphic|movie_clip|button (default: graphic), folder?: Library folder id (default: the top level)} → {symbol, instance, name, layer, folder} (a selection on several layers becomes one symbol with those layers inside; the instance lands on the topmost)", true, convert_to_symbol),
c("modify.break_apart", "Break Apart", "Modify", Some("Ctrl+B"), "{}", true, |s, p| s.each_layer(false, |s| break_apart(s, p))),
c("library.place", "Place on Stage", "", None, "{symbol | bitmap | sound: id, x?, y?} or {items: [{symbol | bitmap | sound: id}, ..], x?, y?} → {element, elements, sound?}: symbols and bitmaps centred on x, y (default: the stage centre; inside an open symbol, in its space) in the active layer's keyframe at the playhead, selected; a sound goes onto that keyframe, its span grown to fit (one sound per keyframe). One undo step", true, place),
]
}
// ----- drawing ----------------------------------------------------------------------------
/// Max path size accepted from params (extent in stage units).
pub(crate) const MAX_EXTENT: f32 = 1_000_000.0;
pub(crate) fn style(s: &Session, p: &Value, closed: bool) -> Result<(Option<Paint>, Option<Stroke>)> {
let fill = if !closed || p.get("fill").is_some_and(Value::is_null) {
None
} else {
match opt_color(p, "fill")? {
Some(c) => Some(Paint::Solid(c)),
// The fill swatch, in stage space (`add_shape` maps it into the shape).
None => s.style.use_fill.then(|| s.style.fill_paint()),
}
};
let width = match opt_f32(p, "stroke_width")? {
Some(w) if (0.0..=1000.0).contains(&w) => w,
Some(_) => return Err(EngineError::Param("param 'stroke_width' must be in 0..=1000".into())),
None => s.style.stroke_width,
};
let profile = opt_profile(p, "profile")?.unwrap_or_else(|| s.style.profile());
let line = opt_stroke_style(p, &s.style.line, width)?.unwrap_or_else(|| s.style.line.clone());
let stroke = if p.get("stroke").is_some_and(Value::is_null) || width <= 0.0 {
None
} else {
match opt_color(p, "stroke")? {
Some(c) => Some(Stroke::new(c, width)),
None => (s.style.use_stroke || !closed).then_some(Stroke::new(s.style.stroke, width)),
}
}
.map(|st| st.with_profile(profile).with_style(line));
if fill.is_none() && stroke.is_none() {
return Err(EngineError::Param("shape would be invisible: give it a fill or a stroke".into()));
}
Ok((fill, stroke))
}
fn rect_params(p: &Value) -> Result<(f32, f32, f32, f32)> {
let (x, y, w, h) = (f32_req(p, "x")?, f32_req(p, "y")?, f32_req(p, "w")?, f32_req(p, "h")?);
if w.abs() < 0.5 || h.abs() < 0.5 {
return Err(EngineError::Param("shape is too small (width and height must be at least 0.5)".into()));
}
if w.abs() > MAX_EXTENT || h.abs() > MAX_EXTENT {
return Err(EngineError::Param("shape is too large".into()));
}
// normalise negative sizes (dragging up/left)
Ok((x.min(x + w), y.min(y + h), w.abs(), h.abs()))
}
/// Adds a shape whose local origin is its centre, placed with a translation. Unless `object`
/// (Object Drawing), it merges with the raw shapes it touches (ADR 0031), and the pieces of it
/// that come out are selected.
pub(crate) fn add_shape(s: &mut Session, name: &str, local: Path, origin: Vec2, fill: Option<Paint>, stroke: Option<Stroke>, object: bool) -> Result<Value> {
// A gradient or bitmap from the fill swatch is in stage space: it stays where it is on the
// stage (Animate's Lock Fill after the Eyedropper).
let fill = fill.map(|f| f.transformed(&Affine::translate(-origin.x, -origin.y)));
let merge = !object && crate::merge::can_merge(stroke.as_ref());
let id = ElementId(s.doc.alloc_id());
let el = Element {
id,
name: String::new(),
transform: Affine::translate(origin.x, origin.y),
color: ColorEffect::default(),
kind: ElementKind::Shape(Shape { path: Arc::new(local), fill, stroke, fill_rule: Default::default(), merge }),
};
if merge {
let merged = crate::merge::merge_in(s, vec![el])?;
s.select_only(merged);
let ids: Vec<u64> = s.selection.id_list();
return Ok(json!({"element": ids.first(), "elements": ids, "kind": name, "merged": true}));
}
let kf = s.editable_keyframe()?;
if kf.elements.len() >= 100_000 {
return Err(EngineError::State("too many elements on this keyframe".into()));
}
kf.elements.push(Arc::new(el));
s.select_only([id]);
Ok(json!({"element": id.0, "kind": name}))
}
/// The `object` param: draw an object instead of merging (default: the Object Drawing setting).
pub(crate) fn object_param(s: &Session, p: &Value) -> Result<bool> {
Ok(opt_bool(p, "object")?.unwrap_or(s.style.object_drawing))
}
fn draw_rect(s: &mut Session, p: &Value) -> Result<Value> {
let (x, y, w, h) = rect_params(p)?;
let r = opt_f32(p, "radius")?.unwrap_or(0.0).max(0.0);
let (fill, stroke) = style(s, p, true)?;
add_shape(s, "rect", Path::rounded_rect(-w / 2.0, -h / 2.0, w, h, r), Vec2::new(x + w / 2.0, y + h / 2.0), fill, stroke, object_param(s, p)?)
}
fn draw_ellipse(s: &mut Session, p: &Value) -> Result<Value> {
let (x, y, w, h) = rect_params(p)?;
let (fill, stroke) = style(s, p, true)?;
add_shape(s, "ellipse", Path::ellipse(0.0, 0.0, w / 2.0, h / 2.0), Vec2::new(x + w / 2.0, y + h / 2.0), fill, stroke, object_param(s, p)?)
}
fn draw_star(s: &mut Session, p: &Value) -> Result<Value> {
let (cx, cy, outer) = (f32_req(p, "cx")?, f32_req(p, "cy")?, f32_req(p, "outer")?);
if !(0.5..=MAX_EXTENT).contains(&outer) {
return Err(EngineError::Param("param 'outer' must be between 0.5 and 1,000,000".into()));
}
let inner = opt_f32(p, "inner")?.unwrap_or(outer * 0.5).clamp(0.0, MAX_EXTENT);
let points = opt_u32(p, "points")?.unwrap_or(5);
if !(3..=64).contains(&points) {
return Err(EngineError::Param("param 'points' must be between 3 and 64".into()));
}
let (fill, stroke) = style(s, p, true)?;
add_shape(s, "star", Path::star(0.0, 0.0, outer, inner, points), Vec2::new(cx, cy), fill, stroke, object_param(s, p)?)
}
fn draw_line(s: &mut Session, p: &Value) -> Result<Value> {
let a = Vec2::new(f32_req(p, "x0")?, f32_req(p, "y0")?);
let b = Vec2::new(f32_req(p, "x1")?, f32_req(p, "y1")?);
if a.distance(b) < 0.5 {
return Err(EngineError::Param("line is too short".into()));
}
let (_, stroke) = style(s, p, false)?;
let c = (a + b) * 0.5;
add_shape(s, "line", Path::line(a - c, b - c), c, None, stroke, object_param(s, p)?)
}
fn snap_to_objects(s: &mut Session, p: &Value) -> Result<Value> {
s.style.snap_objects = opt_bool(p, "on")?.unwrap_or(!s.style.snap_objects);
Ok(json!({"snap_to_objects": s.style.snap_objects}))
}
fn object_drawing(s: &mut Session, p: &Value) -> Result<Value> {
s.style.object_drawing = opt_bool(p, "on")?.unwrap_or(!s.style.object_drawing);
Ok(json!({"object_drawing": s.style.object_drawing}))
}
// ----- selection --------------------------------------------------------------------------
/// Everything on every visible, unlocked layer at the playhead, as Animate's Select All.
fn select_all(s: &mut Session, _: &Value) -> Result<Value> {
let layers: Vec<LayerId> = s.timeline().layers.iter().map(|l| l.id).collect();
let mut sel = Selection::default();
for l in layers.into_iter().filter(|l| s.gathers(*l)) {
sel.extend_on(l, s.elements_on(l).iter().map(|e| e.id));
}
s.selection = sel;
Ok(json!({"selected": s.selection.len()}))
}
/// Most ids `element.select` takes.
const MAX_SELECT: usize = 100_000;
fn select(s: &mut Session, p: &Value) -> Result<Value> {
let ids = opt_u64_list(p, "ids")?.ok_or_else(|| EngineError::Param("param 'ids' is required".into()))?;
if ids.len() > MAX_SELECT {
return Err(EngineError::Param(format!("param 'ids' has more than {MAX_SELECT} ids")));
}
let add = opt_bool(p, "add")?.unwrap_or(false);
let toggle = opt_bool(p, "toggle")?.unwrap_or(false);
// Where each element is at the playhead: on `layer`, else the active layer first, then the
// others top to bottom.
let order: Vec<LayerId> = match opt_u64(p, "layer")?.map(LayerId) {
Some(l) if s.timeline().layer(l).is_none() => return Err(EngineError::State(format!("no layer with id {}", l.0))),
Some(l) => vec![l],
None => std::iter::once(s.layer).chain(s.timeline().layers.iter().map(|l| l.id).filter(|l| *l != s.layer)).collect(),
};
let mut at: std::collections::HashMap<ElementId, LayerId> = std::collections::HashMap::new();
for l in order {
for e in s.elements_on(l) {
at.entry(e.id).or_insert(l);
}
}
let mut picked: Vec<(LayerId, ElementId)> = Vec::with_capacity(ids.len());
for id in ids.into_iter().map(ElementId) {
let Some(&l) = at.get(&id) else {
return Err(EngineError::State(format!("element {} is not on the active layer, or any layer, at this frame", id.0)));
};
if !s.selectable(l) {
let name = s.timeline().layer(l).map(|x| x.name.clone()).unwrap_or_default();
return Err(EngineError::State(format!("element {} is on layer '{name}', which is locked or hidden", id.0)));
}
picked.push((l, id));
}
if toggle {
for &(l, id) in &picked {
s.selection.toggle(l, id);
}
} else {
if !add {
s.selection.clear();
}
for &(l, id) in &picked {
s.selection.insert(l, id);
}
}
// As a click does: the active layer is where the artwork is.
if let Some(&(l, _)) = picked.first()
&& !picked.iter().any(|(x, _)| *x == s.layer)
{
s.layer = l;
}
Ok(json!({"selected": s.selection.id_list()}))
}
fn pick(s: &mut Session, p: &Value) -> Result<Value> {
let pt = Vec2::new(f32_req(p, "x")?, f32_req(p, "y")?);
let add = opt_bool(p, "add")?.unwrap_or(false);
match s.hit_test(pt, 2.0) {
Some((layer, el)) => {
// Shift adds it to (or takes it from) the selection, whichever layers that is on.
if add {
s.selection.toggle(layer, el);
} else if !s.selection.contains(layer, el) {
s.selection = Selection::only(layer, [el]);
}
s.layer = layer;
Ok(json!({"layer": layer.0, "element": el.0}))
}
None => {
if !add {
s.selection.clear();
}
Ok(json!({"element": null}))
}
}
}
// ----- element edits ----------------------------------------------------------------------
fn translate(s: &mut Session, p: &Value) -> Result<Value> {
let (mut dx, mut dy) = (f32_req(p, "dx")?, f32_req(p, "dy")?);
let snap = s.style.snap_radius(opt_f32(p, "snap")?.unwrap_or(0.0).clamp(0.0, 1000.0));
let from = match p.get("from").filter(|v| !v.is_null()) {
None => None,
Some(v) => {
let xy = v.as_array().filter(|a| a.len() == 2).and_then(|a| Some(Vec2::new(a.first()?.as_f64()? as f32, a.get(1)?.as_f64()? as f32)));
Some(xy.filter(|q| q.is_finite()).ok_or_else(|| EngineError::Param("param 'from' must be [x, y]".into()))?)
}
};
let n = move_by(s, Vec2::new(dx, dy))?;
// Snapping while dragging (ADR 0041): a little more, onto what is near.
let mut snapped = Value::Null;
if snap > 0.0
&& let Some((extra, at, kind)) = crate::cmds_raw::snap_selection(s, snap, from)
{
move_by(s, extra)?;
(dx, dy) = (dx + extra.x, dy + extra.y);
snapped = json!({"x": at.x, "y": at.y, "to": kind.key()});
}
Ok(json!({"moved": n, "dx": dx, "dy": dy, "snapped": snapped}))
}
/// Moves the selection by `d` on every layer it is on; how many elements moved.
fn move_by(s: &mut Session, d: Vec2) -> Result<u64> {
let v = s.each_layer(true, |s| {
let els = s.selected_elements_mut()?;
let n = els.len();
for e in els {
e.transform = Affine::translate(d.x, d.y).mul(&e.transform);
}
Ok(json!({"moved": n}))
})?;
Ok(v["moved"].as_u64().unwrap_or(0))
}
fn set_transform(s: &mut Session, p: &Value) -> Result<Value> {
let x = opt_f32(p, "x")?;
let y = opt_f32(p, "y")?;
let sx = opt_f32(p, "sx")?;
let sy = opt_f32(p, "sy")?;
let rot = opt_f32(p, "rotation")?;
for v in [sx, sy].into_iter().flatten() {
if v.abs() < 1e-3 || v.abs() > 1000.0 {
return Err(EngineError::Param("scale must be between 0.001 and 1000 in magnitude".into()));
}
}
let els = s.selected_elements_mut()?;
for e in els {
let mut d: Decomposed = e.transform.decompose();
if let Some(v) = x {
d.tx = v;
}
if let Some(v) = y {
d.ty = v;
}
if let Some(v) = sx {
d.sx = v;
}
if let Some(v) = sy {
d.sy = v;
}
if let Some(v) = rot {
d.rotation = v.to_radians();
}
e.transform = d.compose();
}
Ok(json!({"ok": true}))
}
fn shapes_mut(s: &mut Session) -> Result<Vec<&mut Shape>> {
let shapes: Vec<&mut Shape> = s
.selected_elements_mut()?
.into_iter()
.filter_map(|e| match &mut e.kind {
ElementKind::Shape(sh) => Some(sh),
ElementKind::Symbol { .. } | ElementKind::Text(_) | ElementKind::Camera => None,
})
.collect();
if shapes.is_empty() {
return Err(EngineError::State("the selection has no shapes (symbol instances use alpha/tint; text has its own colour)".into()));
}
Ok(shapes)
}
fn set_fill(s: &mut Session, p: &Value) -> Result<Value> {
let fill = if p.get("color").is_some_and(Value::is_null) {
None
} else {
Some(Paint::Solid(opt_color(p, "color")?.ok_or_else(|| EngineError::Param("param 'color' is required".into()))?))
};
for sh in shapes_mut(s)? {
sh.fill = fill.clone();
}
Ok(json!({"ok": true}))
}
fn set_stroke(s: &mut Session, p: &Value) -> Result<Value> {
let remove = p.get("color").is_some_and(Value::is_null);
let color = opt_color(p, "color")?;
let width = opt_f32(p, "width")?;
if width.is_some_and(|w| !(0.0..=1000.0).contains(&w)) {
return Err(EngineError::Param("param 'width' must be in 0..=1000".into()));
}
let profile = opt_profile(p, "profile")?;
let default = s.style.clone();
// Checked once up front, so a bad style param changes nothing.
opt_stroke_style(p, &default.line, default.stroke_width)?;
for sh in shapes_mut(s)? {
if remove {
sh.stroke = None;
continue;
}
let mut st = sh.stroke.take().unwrap_or_else(|| default.new_stroke(default.stroke, default.stroke_width));
if let Some(c) = color {
st.color = c;
}
if let Some(w) = width {
st.width = w;
}
if let Some(pr) = &profile {
st = st.with_profile(pr.clone());
}
if let Some(line) = opt_stroke_style(p, &st.style, st.width)? {
st = st.with_style(line);
}
sh.stroke = (st.width > 0.0).then_some(st);
}
Ok(json!({"ok": true}))
}
fn set_alpha(s: &mut Session, p: &Value) -> Result<Value> {
let a = f32_req(p, "alpha")?;
if !(0.0..=1.0).contains(&a) {
return Err(EngineError::Param("param 'alpha' must be between 0 and 1".into()));
}
for e in s.selected_elements_mut()? {
e.color = e.color.with_alpha(a);
}
Ok(json!({"alpha": a}))
}
/// Each colour effect value `element.set_color_effect` takes: its key, style, range and scale
/// (the model's value is the param's divided by it).
const EFFECT_VALUES: [(&str, ColorStyle, f32, f32, f32); 11] = [
("alpha", ColorStyle::Alpha, 0.0, 100.0, 100.0),
("brightness", ColorStyle::Brightness, -100.0, 100.0, 100.0),
("tint_amount", ColorStyle::Tint, 0.0, 100.0, 100.0),
("red_multiplier", ColorStyle::Advanced, -100.0, 100.0, 100.0),
("green_multiplier", ColorStyle::Advanced, -100.0, 100.0, 100.0),
("blue_multiplier", ColorStyle::Advanced, -100.0, 100.0, 100.0),
("alpha_multiplier", ColorStyle::Advanced, -100.0, 100.0, 100.0),
("red_offset", ColorStyle::Advanced, -255.0, 255.0, 255.0),
("green_offset", ColorStyle::Advanced, -255.0, 255.0, 255.0),
("blue_offset", ColorStyle::Advanced, -255.0, 255.0, 255.0),
("alpha_offset", ColorStyle::Advanced, -255.0, 255.0, 255.0),
];
fn set_color_effect(s: &mut Session, p: &Value) -> Result<Value> {
let style = match opt_str(p, "style")? {
Some(k) => Some(ColorStyle::from_key(k).ok_or_else(|| EngineError::Param(format!("unknown style '{k}' (none, brightness, tint, advanced or alpha)")))?),
None => None,
};
let tint = opt_color(p, "tint")?;
let mut values: Vec<(usize, f32)> = Vec::new();
let mut families: Vec<ColorStyle> = tint.map(|_| ColorStyle::Tint).into_iter().collect();
for (i, (key, fam, lo, hi, scale)) in EFFECT_VALUES.iter().enumerate() {
if let Some(v) = opt_f32(p, key)? {
if !(*lo..=*hi).contains(&v) {
return Err(EngineError::Param(format!("param '{key}' must be between {lo} and {hi}")));
}
values.push((i, v / scale));
if !families.contains(fam) {
families.push(*fam);
}
}
}
let style = match (style, families.as_slice()) {
(Some(st), f) if f.iter().any(|x| *x != st) => return Err(EngineError::Param(format!("the {} style has none of these values: give only its own", st.key()))),
(Some(st), _) => Some(st),
(None, []) => return Err(EngineError::Param("give a style, or a value to set".into())),
(None, [one]) => Some(*one),
(None, _) => return Err(EngineError::Param("these values belong to different styles: give one style's values".into())),
};
let mut first = None;
for e in s.selected_elements_mut()? {
let target = style.unwrap_or(e.color.style());
if matches!(e.kind, ElementKind::Camera) && !matches!(target, ColorStyle::Tint | ColorStyle::None) {
return Err(EngineError::State("the camera's colour effect is a tint".into()));
}
let mut fx = e.color.to_style(target);
if let ColorEffect::Tint { color, .. } = &mut fx
&& let Some(t) = tint
{
*color = t.with_alpha(1.0);
}
for &(i, v) in &values {
match &mut fx {
ColorEffect::Alpha(a) if i == 0 => *a = v,
ColorEffect::Brightness(b) if i == 1 => *b = v,
ColorEffect::Tint { amount, .. } if i == 2 => *amount = v,
ColorEffect::Advanced(t) => {
if let Some(m) = i.checked_sub(3).and_then(|j| t.mul.get_mut(j)) {
*m = v;
} else if let Some(o) = i.checked_sub(7).and_then(|j| t.add.get_mut(j)) {
*o = v;
}
}
_ => {}
}
}
e.color = fx.sanitized();
first.get_or_insert(e.color);
}
Ok(first.map_or(Value::Null, |fx| crate::color_effect_json(&fx)))
}
/// Most filters on one instance.
const MAX_FILTERS: usize = 16;
/// Filters for the selected movie clip and button instances (Animate offers them on those only).
fn set_filters(s: &mut Session, p: &Value) -> Result<Value> {
let mut list = p.get("filters").cloned().ok_or_else(|| EngineError::Param("param 'filters' is required (a list; [] removes them)".into()))?;
// Colours may be written "#rrggbb" (or "#rrggbbaa"), as everywhere in commands: the filter's
// own and its ramp stops'.
fn hex_colors(v: &mut Value, keys: &[&str]) -> Result<()> {
for k in keys {
if v.get(*k).is_some_and(Value::is_string) {
let c = opt_color(v, k)?.unwrap_or(anicraft_doc::Rgba::BLACK);
v[*k] = json!({"r": c.r, "g": c.g, "b": c.b, "a": c.a});
}
}
Ok(())
}
for f in list.as_array_mut().into_iter().flatten() {
hex_colors(f, &["color", "shadow_color", "highlight_color"])?;
if let Some(stops) = f.get_mut("stops").and_then(Value::as_array_mut) {
if stops.len() > anicraft_doc::MAX_RAMP_STOPS {
return Err(EngineError::Param(format!("a ramp has at most {} stops", anicraft_doc::MAX_RAMP_STOPS)));
}
for st in stops.iter_mut() {
hex_colors(st, &["color"])?;
}
}
}
let filters: Vec<anicraft_doc::Filter> = serde_json::from_value(list).map_err(|e| EngineError::Param(format!("'filters' must be a list of {{type: blur|drop_shadow|glow|bevel|gradient_glow|gradient_bevel|adjust_color, …}}: {e}")))?;
if filters.len() > MAX_FILTERS {
return Err(EngineError::Param(format!("at most {MAX_FILTERS} filters per instance")));
}
let filters: Vec<anicraft_doc::Filter> = filters.iter().map(anicraft_doc::Filter::sanitized).collect();
let kinds: std::collections::HashMap<SymbolId, SymbolKind> = s.doc.library.iter().map(|x| (x.id, x.kind)).collect();
let (mut set, mut graphics) = (0, 0);
for e in s.selected_elements_mut()? {
if let ElementKind::Symbol { symbol, filters: f, .. } = &mut e.kind {
if kinds.get(symbol) == Some(&SymbolKind::Graphic) {
graphics += 1;
continue;
}
f.clone_from(&filters);
set += 1;
}
}
if set == 0 {
return Err(EngineError::State(if graphics > 0 {
"filters apply to movie clip and button instances, as in Animate; set the symbol's Type to Movie Clip first".into()
} else {
"select a movie clip or button instance".into()
}));
}
Ok(json!({"filters": filters.len(), "set": set}))
}
/// Blending for the selected movie clip and button instances (Animate offers it on those only).
fn set_blend(s: &mut Session, p: &Value) -> Result<Value> {
let key = str_req(p, "mode")?;
let mode = anicraft_doc::BlendMode::from_key(key).ok_or_else(|| {
let all: Vec<&str> = anicraft_doc::BlendMode::ALL.iter().map(|m| m.key()).collect();
EngineError::Param(format!("unknown blend mode '{key}' ({})", all.join(", ")))
})?;
let kinds: std::collections::HashMap<SymbolId, SymbolKind> = s.doc.library.iter().map(|x| (x.id, x.kind)).collect();
let mut set = 0;
let mut graphics = 0;
for e in s.selected_elements_mut()? {
if let ElementKind::Symbol { symbol, blend, .. } = &mut e.kind {
if kinds.get(symbol) == Some(&SymbolKind::Graphic) {
graphics += 1;
continue;
}
*blend = mode;
set += 1;
}
}
if set == 0 {
return Err(EngineError::State(if graphics > 0 {
"blending applies to movie clip and button instances, as in Animate; set the symbol's Type to Movie Clip first".into()
} else {
"select a movie clip or button instance".into()
}));
}
Ok(json!({"mode": mode.key(), "set": set}))
}
/// Looping for the selected graphic instances: loop, play once or a single frame, from
/// `first_frame` (1-based in the UI, 0-based here).
fn set_loop(s: &mut Session, p: &Value) -> Result<Value> {
let mode = match opt_str(p, "loop")? {
None => None,
Some("loop") => Some(LoopMode::Loop),
Some("play_once" | "play once") => Some(LoopMode::PlayOnce),
Some("single_frame" | "single frame") => Some(LoopMode::SingleFrame),
Some(other) => return Err(EngineError::Param(format!("unknown loop '{other}' (loop, play_once or single_frame)"))),
};
let first = opt_u32(p, "first_frame")?;
if mode.is_none() && first.is_none() {
return Err(EngineError::Param("pass 'loop' and/or 'first_frame'".into()));
}
let mut n = 0;
for e in s.selected_elements_mut()? {
if let ElementKind::Symbol { loop_mode, first_frame, .. } = &mut e.kind {
if let Some(m) = mode {
*loop_mode = m;
}
if let Some(f) = first {
*first_frame = f.min(crate::MAX_FRAME);
}
n += 1;
}
}
if n == 0 {
return Err(EngineError::State("select a symbol instance first".into()));
}
Ok(json!({"instances": n}))
}
/// A symbol's kind, for every instance of it: a graphic keeps step with the timeline it is
/// placed on, a movie clip plays its own timeline on a loop, a button shows its Up frame.
fn set_symbol_kind(s: &mut Session, p: &Value) -> Result<Value> {
let kind = crate::cmds_library::kind_of(str_req(p, "kind")?)?;
let ids: Vec<SymbolId> = match opt_u64(p, "symbol")? {
Some(id) => vec![SymbolId(id)],
None => {
// The symbols of the selected instances, on every layer (ADR 0053: a "mixed" Type
// row sets them all), in selection order.
let mut ids = Vec::new();
for (layer, sel) in s.selection.iter() {
if let Some(ElementKind::Symbol { symbol, .. }) = s.elements_on(layer).iter().find(|e| e.id == sel).map(|e| &e.kind)
&& !ids.contains(symbol)
{
ids.push(*symbol);
}
}
if ids.is_empty() {
return Err(EngineError::State(if s.selection.is_empty() { "select a symbol instance, or pass 'symbol'".into() } else { "the selection is not a symbol instance".into() }));
}
ids
}
};
for id in &ids {
let sym = s.doc.library.iter_mut().find(|x| x.id == *id).ok_or_else(|| EngineError::State(format!("no symbol with id {}", id.0)))?;
if sym.kind != kind {
std::sync::Arc::make_mut(sym).kind = kind;
}
}
Ok(json!({"symbol": ids.first().map(|i| i.0), "symbols": ids.iter().map(|i| i.0).collect::<Vec<_>>(), "kind": format!("{kind:?}")}))
}
/// The symbol a command means: `symbol`, else the selected instance's.
fn selected_symbol(s: &Session, p: &Value) -> Result<SymbolId> {
Ok(match opt_u64(p, "symbol")? {
Some(id) => SymbolId(id),
None => {
// The symbol of the selected instance.
let (layer, sel) = s.selection.first().ok_or_else(|| EngineError::State("select a symbol instance, or pass 'symbol'".into()))?;
s.elements_on(layer)
.iter()
.find(|e| e.id == sel)
.and_then(|e| match e.kind {
ElementKind::Symbol { symbol, .. } => Some(symbol),
ElementKind::Shape(_) | ElementKind::Text(_) | ElementKind::Camera => None,
})
.ok_or_else(|| EngineError::State("the selection is not a symbol instance".into()))?
}
})
}
/// 9-slice guides (ADR 0055): on, off or moved, on one symbol.
fn set_scale_grid(s: &mut Session, p: &Value) -> Result<Value> {
let on = opt_bool(p, "on")?;
let edges = [opt_f32(p, "left")?, opt_f32(p, "right")?, opt_f32(p, "top")?, opt_f32(p, "bottom")?];
if on.is_none() && edges.iter().all(Option::is_none) {
return Err(EngineError::Param("pass 'on', or a guide to move: 'left', 'right', 'top' or 'bottom'".into()));
}
// The open symbol is the one being edited; otherwise the selected instance's.
let id = match (opt_u64(p, "symbol")?, s.editing_symbol()) {
(None, Some(open)) => open,
_ => selected_symbol(s, p)?,
};
let sym = s.doc.symbol(id).ok_or_else(|| EngineError::State(format!("no symbol with id {}", id.0)))?;
let grid = if on == Some(false) {
if edges.iter().any(Option::is_some) {
return Err(EngineError::Param("guides can't be moved while turning them off".into()));
}
None
} else {
// Switched on again, the guides come back where they were (ADR 0057).
let start = sym.scale_grid.or(sym.scale_grid_kept).unwrap_or_else(|| {
let b = anicraft_doc::symbol_box(&s.doc, sym);
ScaleGrid::inset(&if b.is_empty() { anicraft_geom::Rect::new(0.0, 0.0, 100.0, 100.0) } else { b })
});
let [l, r, t, b] = edges;
let g = ScaleGrid { left: l.unwrap_or(start.left), right: r.unwrap_or(start.right), top: t.unwrap_or(start.top), bottom: b.unwrap_or(start.bottom) };
g.check().map_err(EngineError::Param)?;
Some(g)
};
// Off, the guides are kept (only hidden), so switching back on finds them.
let kept = if grid.is_none() { sym.scale_grid.or(sym.scale_grid_kept) } else { None };
if let Some(sym) = s.doc.library.iter_mut().find(|x| x.id == id)
&& (sym.scale_grid != grid || sym.scale_grid_kept != kept)
{
let sym = Arc::make_mut(sym);
sym.scale_grid = grid;
sym.scale_grid_kept = kept;
}
Ok(json!({"symbol": id.0, "scale_grid": grid.map(|g| json!({"left": g.left, "right": g.right, "top": g.top, "bottom": g.bottom}))}))
}
fn rename(s: &mut Session, p: &Value) -> Result<Value> {
let name: String = str_req(p, "name")?.chars().take(128).collect();
for e in s.selected_elements_mut()? {
e.name = name.clone();
}
Ok(json!({"name": name}))
}
/// Clear: the selection goes, on every layer it is on.
pub(crate) fn delete_selection(s: &mut Session, p: &Value) -> Result<Value> {
s.each_layer(true, |s| delete(s, p))
}
fn delete(s: &mut Session, _: &Value) -> Result<Value> {
let sel = s.selection.on(s.layer);
if sel.is_empty() {
return Err(EngineError::State("nothing is selected".into()));
}
let kf = s.editable_keyframe()?;
let before = kf.elements.len();
kf.elements.retain(|e| !sel.contains(&e.id));
let n = before - kf.elements.len();
s.selection.clear();
Ok(json!({"deleted": n}))
}
fn duplicate(s: &mut Session, p: &Value) -> Result<Value> {
let dx = opt_f32(p, "dx")?.unwrap_or(10.0);
let dy = opt_f32(p, "dy")?.unwrap_or(10.0);
let sel = s.selection.on(s.layer);
if sel.is_empty() {
return Err(EngineError::State("nothing is selected".into()));
}
let copies: Vec<Element> = s.editable_keyframe()?.elements.iter().filter(|e| sel.contains(&e.id)).map(|e| (**e).clone()).collect();
let mut new_ids = Vec::new();
let mut out = Vec::new();
for mut e in copies {
e.id = ElementId(s.doc.alloc_id());
e.transform = Affine::translate(dx, dy).mul(&e.transform);
new_ids.push(e.id);
out.push(Arc::new(e));
}
s.editable_keyframe()?.elements.extend(out);
s.select_only(new_ids.iter().copied());
Ok(json!({"created": new_ids.iter().map(|e| e.0).collect::<Vec<_>>()}))
}
fn arrange(s: &mut Session, front: bool) -> Result<Value> {
let sel = s.selection.on(s.layer);
if sel.is_empty() {
return Err(EngineError::State("nothing is selected".into()));
}
let kf = s.editable_keyframe()?;
let (picked, rest): (Vec<Arc<Element>>, Vec<Arc<Element>>) = kf.elements.drain(..).partition(|e| sel.contains(&e.id));
kf.elements = if front { rest.into_iter().chain(picked).collect() } else { picked.into_iter().chain(rest).collect() };
Ok(json!({"ok": true}))
}
/// Bring Forward / Send Backward: each selected element swaps with the unselected neighbour
/// above (or below) it; a selected block moves as one, keeping its order.
fn arrange_step(s: &mut Session, forward: bool) -> Result<Value> {
let sel = s.selection.on(s.layer);
if sel.is_empty() {
return Err(EngineError::State("nothing is selected".into()));
}
let kf = s.editable_keyframe()?;
let n = kf.elements.len();
let picked = |els: &Vec<Arc<Element>>, i: usize| els.get(i).is_some_and(|e| sel.contains(&e.id));
if forward {
// From the top down, so a selected element never jumps over another selected one.
for i in (0..n.saturating_sub(1)).rev() {
if picked(&kf.elements, i) && !picked(&kf.elements, i + 1) {
kf.elements.swap(i, i + 1);
}
}
} else {
for i in 1..n {
if picked(&kf.elements, i) && !picked(&kf.elements, i - 1) {
kf.elements.swap(i, i - 1);
}
}
}
Ok(json!({"ok": true}))
}
// ----- symbols ----------------------------------------------------------------------------
/// Convert to Symbol. The registration point is the centre of the selection's bounds. A
/// selection on several layers becomes one symbol with those layers inside it (named and
/// stacked as they are), and its instance lands on the topmost of them, where its first
/// selected element was; the other layers lose what was selected (ADR 0044).
pub(crate) fn convert_to_symbol(s: &mut Session, p: &Value) -> Result<Value> {
let layers = s.selected_layers();
let Some(&top) = layers.first() else {
return Err(EngineError::State("select something to convert".into()));
};
// Into the folder asked for (ADR 0053), else the top level; the name is free there: the
// next free “Symbol n”, or the name asked for with a number when the folder has it already.
let folder = crate::cmds_library::opt_folder(s, p, "folder")?;
let kind = opt_str(p, "kind")?.map(crate::cmds_library::kind_of).transpose()?.unwrap_or(SymbolKind::Graphic);
let name: String = match opt_str(p, "name")? {
Some(n) => s.doc.unique_name(folder, n),
None => s.doc.numbered_name(folder, "Symbol", s.doc.library.len() + 1),
};
let bounds = s.selection_bounds();
let center = if bounds.is_empty() { Vec2::ZERO } else { bounds.center() };
let sym_id = SymbolId(s.doc.alloc_id());
let first_layer = LayerId(s.doc.alloc_id());
let inst_id = ElementId(s.doc.alloc_id());
let instance = Element {
id: inst_id,
name: String::new(),
transform: Affine::translate(center.x, center.y),
color: ColorEffect::default(),
kind: ElementKind::Symbol { symbol: sym_id, loop_mode: LoopMode::Loop, first_frame: 0, blend: anicraft_doc::BlendMode::Normal, filters: Vec::new(), events: Vec::new() },
};
// Children are stored relative to the registration point (the selection centre).
let to_local = Affine::translate(-center.x, -center.y);
let single = layers.len() == 1;
let mut inner: Vec<Arc<Layer>> = Vec::with_capacity(layers.len());
for l in layers {
let sel = s.selection.on(l);
let source = s.timeline().layer(l).map(|x| x.name.clone()).unwrap_or_default();
let picked = s.with_layer(l, |s| -> Result<Vec<Arc<Element>>> {
let kf = s.editable_keyframe()?;
let first_pos = kf.elements.iter().position(|e| sel.contains(&e.id)).unwrap_or(kf.elements.len());
let (picked, mut rest): (Vec<Arc<Element>>, Vec<Arc<Element>>) = kf.elements.drain(..).partition(|e| sel.contains(&e.id));
if l == top {
rest.insert(first_pos.min(rest.len()), Arc::new(instance.clone()));
}
kf.elements = rest;
Ok(picked)
})?;
let children: Vec<Arc<Element>> = picked
.into_iter()
.map(|e| {
let mut e = Arc::unwrap_or_clone(e);
e.transform = to_local.mul(&e.transform);
Arc::new(e)
})
.collect();
let id = if inner.is_empty() { first_layer } else { LayerId(s.doc.alloc_id()) };
let mut layer = Layer::new(id, if single { "Layer 1".to_string() } else { source });
if let Some(k) = layer.keyframe_mut(0) {
k.elements = children;
}
inner.push(Arc::new(layer));
}
s.doc.library.push(Arc::new(Symbol { id: sym_id, name: name.clone(), kind, linkage: None, scale_grid_kept: None, scale_grid: None, timeline: Timeline { layers: inner } }));
if folder.is_some() {
s.doc.place_entry(LibraryEntry::Item(LibraryItem::Symbol(sym_id)), folder);
}
s.layer = top;
s.select_only([inst_id]);
Ok(json!({"symbol": sym_id.0, "instance": inst_id.0, "name": name, "layer": top.0, "folder": folder.map(|f| f.0)}))
}
fn break_apart(s: &mut Session, _: &Value) -> Result<Value> {
let sel = s.selection.on(s.layer);
if sel.is_empty() {
return Err(EngineError::State("nothing is selected".into()));
}
let library = s.doc.library.clone();
let mut fresh_ids = Vec::new();
let kf_elements: Vec<Arc<Element>> = s.editable_keyframe()?.elements.clone();
let mut out = Vec::new();
for e in kf_elements {
// Text breaks apart into a shape with the same outlines.
if let ElementKind::Text(t) = &e.kind
&& sel.contains(&e.id)
{
let mut c = (*e).clone();
c.id = ElementId(s.doc.alloc_id());
c.kind = ElementKind::Shape(crate::cmds_text::to_shape(t));
fresh_ids.push(c.id);
out.push(Arc::new(c));
continue;
}
let ElementKind::Symbol { symbol, .. } = &e.kind else {
out.push(e);
continue;
};
if !sel.contains(&e.id) {
out.push(e);
continue;
}
let Some(sym) = library.iter().find(|x| x.id == *symbol) else {
out.push(e);
continue;
};
for layer in sym.timeline.layers.iter().rev() {
for child in layer.keyframes.first().map(|k| k.elements.as_slice()).unwrap_or(&[]) {
let mut c = (**child).clone();
c.id = ElementId(s.doc.alloc_id());
c.transform = e.transform.mul(&child.transform);
c.color = e.color.nested(&child.color);
fresh_ids.push(c.id);
out.push(Arc::new(c));
}
}
}
if fresh_ids.is_empty() {
return Err(EngineError::State("the selection has no symbol instances or text to break apart".into()));
}
s.editable_keyframe()?.elements = out;
s.select_only(fresh_ids.iter().copied());
Ok(json!({"created": fresh_ids.len()}))
}
/// Most items one `library.place` takes.
const MAX_PLACE: usize = 1_000;
/// Places Library items at `x`/`y` (default: the stage centre), as a drop from the Library
/// does (ADR 0053): an instance of each symbol, a rectangle of each bitmap's size showing it,
/// in the active layer's keyframe at the playhead, all selected; a sound goes onto that
/// keyframe. One command, so one undo step however many items.
pub(crate) fn place(s: &mut Session, p: &Value) -> Result<Value> {
let items: Vec<LibraryItem> = match p.get("items") {
Some(list) => {
let list = list.as_array().ok_or_else(|| EngineError::Param("param 'items' must be a list of {\"symbol\" | \"bitmap\" | \"sound\": id}".into()))?;
if list.len() > MAX_PLACE {
return Err(EngineError::Param(format!("at most {MAX_PLACE} items at once")));
}
let mut out = Vec::with_capacity(list.len());
for v in list {
match crate::cmds_library::entry_of(v)? {
LibraryEntry::Item(i) => out.push(i),
LibraryEntry::Folder(_) => return Err(EngineError::Param("a folder can't be placed; name the items in it".into())),
}
}
out
}
None => match (opt_u64(p, "symbol")?, opt_u64(p, "bitmap")?, opt_u64(p, "sound")?) {
(Some(i), None, None) => vec![LibraryItem::Symbol(SymbolId(i))],
(None, Some(i), None) => vec![LibraryItem::Bitmap(anicraft_doc::BitmapId(i))],
(None, None, Some(i)) => vec![LibraryItem::Sound(anicraft_doc::SoundId(i))],
_ => return Err(EngineError::Param("name one item ('symbol', 'bitmap' or 'sound'), or a list in 'items'".into())),
},
};
if items.is_empty() {
return Err(EngineError::Param("nothing to place".into()));
}
let mut sound = None;
for &i in &items {
if !s.doc.has_item(i) {
return Err(EngineError::State(match i {
LibraryItem::Symbol(id) => format!("no symbol with id {}", id.0),
LibraryItem::Bitmap(id) => format!("no bitmap with id {}", id.0),
LibraryItem::Sound(id) => format!("no sound with id {} in the library", id.0),
}));
}
match i {
LibraryItem::Symbol(id) if crate::editing::would_nest(s, id) => return Err(EngineError::State("a symbol can't be placed inside itself".into())),
LibraryItem::Sound(id) => {
if sound.is_some_and(|x| x != id) {
return Err(EngineError::State("a keyframe holds one sound; place sounds one at a time, on different keyframes or layers".into()));
}
sound = Some(id);
}
_ => {}
}
}
let x = opt_f32(p, "x")?.unwrap_or(s.doc.stage.width as f32 / 2.0);
let y = opt_f32(p, "y")?.unwrap_or(s.doc.stage.height as f32 / 2.0);
if !(x.is_finite() && y.is_finite()) || x.abs() > 1.0e6 || y.abs() > 1.0e6 {
return Err(EngineError::Param("'x' and 'y' must be within a million pixels of the origin".into()));
}
let mut placed = Vec::new();
for &i in &items {
match i {
LibraryItem::Symbol(id) => placed.push(place_symbol(s, id, x, y)?),
LibraryItem::Bitmap(id) => placed.push(place_bitmap(s, id, x, y)?),
LibraryItem::Sound(_) => {}
}
}
let mut out = json!({"element": placed.first().map(|e| e.0), "elements": placed.iter().map(|e| e.0).collect::<Vec<_>>()});
if let Some(id) = sound {
if s.active_layer().is_some_and(|l| l.locked) || s.timeline().locked_by_folder(s.layer) {
return Err(EngineError::State("the active layer is locked; unlock it to put a sound on it".into()));
}
out["sound"] = crate::cmds_sound::place(s, &json!({"sound": id.0, "extend": true}))?;
}
if !placed.is_empty() {
s.select_only(placed.iter().copied());
}
Ok(out)
}
fn place_symbol(s: &mut Session, sym: SymbolId, x: f32, y: f32) -> Result<ElementId> {
let id = ElementId(s.doc.alloc_id());
let el = Element {
id,
name: String::new(),
transform: Affine::translate(x, y),
color: ColorEffect::default(),
kind: ElementKind::Symbol { symbol: sym, loop_mode: LoopMode::Loop, first_frame: 0, blend: anicraft_doc::BlendMode::Normal, filters: Vec::new(), events: Vec::new() },
};
s.editable_keyframe()?.elements.push(Arc::new(el));
Ok(id)
}
fn place_bitmap(s: &mut Session, bitmap: anicraft_doc::BitmapId, x: f32, y: f32) -> Result<ElementId> {
let (name, w, h) = match s.doc.bitmap(bitmap) {
Some(b) => (b.name.clone(), b.width as f32, b.height as f32),
None => return Err(EngineError::State(format!("no bitmap with id {}", bitmap.0))),
};
let id = ElementId(s.doc.alloc_id());
let el = Element {
id,
name,
transform: Affine::translate(x - w / 2.0, y - h / 2.0),
color: ColorEffect::default(),
kind: ElementKind::Shape(Shape {
path: Arc::new(Path::rect(0.0, 0.0, w, h)),
fill: Some(Paint::Bitmap { bitmap, repeat: false, matrix: Affine::IDENTITY }),
stroke: None,
fill_rule: anicraft_geom::FillRule::NonZero,
merge: false,
}),
};
s.editable_keyframe()?.elements.push(Arc::new(el));
Ok(id)
}