diff --git a/ATTRIBUTION.md b/ATTRIBUTION.md
index 8e6e35339..97598349b 100644
--- a/ATTRIBUTION.md
+++ b/ATTRIBUTION.md
@@ -17,6 +17,18 @@ iconography, images or other Adobe assets; open licences only; every asset attri
| `assets/fonts/NotoSerif-Regular.ttf` | The Noto Project Authors | https://github.com/notofonts/latin-greek-cyrillic | OFL-1.1 (`assets/fonts/OFL-NotoSerif.txt`) |
| `assets/fonts/JetBrainsMono-Regular.ttf` | The JetBrains Mono Project Authors | https://github.com/JetBrains/JetBrainsMono | OFL-1.1 (`assets/fonts/OFL-JetBrainsMono.txt`) |
+## Screenshots
+
+Screenshots of EffectCraft itself, rendered headlessly, showing only procedurally generated demo content.
+
+| Asset | Author | Source | Licence |
+|---|---|---|---|
+| `docs/images/effectcraft-hero.png` | EffectCraft contributors | Original work: screenshot of EffectCraft (EffectCraft main window) | MIT OR Apache-2.0 |
+| `docs/images/effectcraft-3d.png` | EffectCraft contributors | Original work: screenshot of EffectCraft (EffectCraft Classic 3D) | MIT OR Apache-2.0 |
+| `docs/images/effectcraft-graph-editor.png` | EffectCraft contributors | Original work: screenshot of EffectCraft (EffectCraft Graph Editor) | MIT OR Apache-2.0 |
+| `docs/images/effectcraft-effects.png` | EffectCraft contributors | Original work: screenshot of EffectCraft (EffectCraft effects) | MIT OR Apache-2.0 |
+| `docs/images/effectcraft-render-queue.png` | EffectCraft contributors | Original work: screenshot of EffectCraft (EffectCraft Render Queue panel with the demo compositions queued for H.264 and ProRes export) | MIT OR Apache-2.0 |
+
## Code-drawn assets (original work, MIT OR Apache-2.0)
- UI icons drawn in code: `crates/ui-egui/src/icons.rs`.
diff --git a/Cargo.lock b/Cargo.lock
index 32b3a1543..4091f707c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1197,6 +1197,7 @@ dependencies = [
"effectcraft-render",
"effectcraft-text",
"effectcraft-time",
+ "image",
"log",
"serde",
"serde_json",
diff --git a/README.md b/README.md
index 8f0ac5887..f1f9d7119 100644
--- a/README.md
+++ b/README.md
@@ -15,12 +15,12 @@
A free, open-source compositor in the spirit of After Effects: compositions, layers,
- keyframes, effects and expressions, native on macOS, Windows and Linux, and in the browser later on.
- It is in early development. The engine crates are being written now and there is no app to run yet.
+ keyframes, 241 effects, expressions, 3D cameras and lights, and a render queue, native on macOS,
+ Windows and Linux, and in the browser later on. Young, moving fast, and already usable.
-
+
@@ -35,6 +35,12 @@
All Crafting Apps
+
+
+
+
+
+
> [!NOTE]
> **ArtCraft is a community of artists from all walks of life.** Painters, photographers,
> filmmakers, illustrators, designers, animators, hobbyists, and people who picked up a pencil
@@ -42,9 +48,13 @@
What it is ·
- Where it stands ·
- The plan ·
- Building ·
+ Animate ·
+ Effects ·
+ 3D ·
+ Export ·
+ Agents ·
+ Get started ·
+ Status ·
How it's made ·
The Crafting Apps ·
License
@@ -71,84 +81,104 @@ then to go further in a few places where it matters to us:
- **No FFmpeg.** Video and audio decoding and encoding come from FilmCraft's own pure-Rust
codecs.
-## Where it stands
+## Animate
-> [!IMPORTANT]
-> **There is no app to run yet.** EffectCraft is in its first milestone. The planning is done and
-> the low-level engine crates are being written. The windowed app, the renderer and the effects
-> come next. If you want to follow along or help shape it, the
-> [Discord](https://discord.gg/artcraft) is the place.
+The panels, menus and shortcuts follow After Effects, so your muscle memory carries over:
+Project, Composition, Timeline, Effect Controls, Properties, Effects & Presets, Character,
+Paragraph, Align, Info, Preview, Audio and the Render Queue, docked the way you expect.
-| | What | State |
-|---|---|---|
-| **Built** | The plan: an After Effects UI and feature reference, a full effects list, the architecture and a milestone plan (see [`plan/`](plan/)) | Done |
-| **In progress** | Engine foundation crates: time, geometry, color and blend modes, keyframes, the project model, raster images, Bezier paths, text | Early code and first tests |
-| **Next** | The compositor, a first set of effects, the editing engine and the After Effects style interface rendering an animated demo composition | Not started |
-| **Later** | Precomps and preview, shapes and masks, 3D, expressions, text animators, export, GPU rendering, the web build | Planned |
+- **Layers of every kind:** solids, shapes, text, footage, nested compositions, nulls,
+ adjustment layers, cameras and lights; parenting, track mattes, all 38 blend modes, motion blur.
+- **Keyframes that behave the same:** linear, Bezier, hold, auto and continuous Bezier, roving
+ keys, Easy Ease (F9), Keyframe Velocity and Interpolation dialogs, copy and paste at the current
+ time, and a **Graph Editor** with value and speed graphs and draggable handles.
+- **Time:** time remapping, time stretch, time-reverse, freeze frame, work area, markers, exact
+ frame-accurate timing at every frame rate including 29.97 drop-frame.
+- **Shapes and masks:** shape layers with trim paths, repeaters, round corners, offset, zig zag,
+ twist, wiggle, merge paths and gradient strokes; masks drawn with the pen tool, with modes,
+ feather, expansion and vertex editing in the viewer.
+- **Text:** point and paragraph text with real shaping, the Character and Paragraph panels, and
+ text animators with range selectors.
+- **Expressions:** JavaScript with the After Effects object model (`wiggle`, `loopOut`,
+ `thisComp.layer("…")`, vector maths on arrays), an inline editor and the pick-whip.
-The live checklist is [`plan/STATUS.md`](plan/STATUS.md).
+
+
+
-### The crates so far
+## Effects
-| Crate | What it does |
-|---|---|
-| `effectcraft-time` | Exact media time in integer ticks, so 23.976 and 29.97 fps, drop-frame timecode and audio sample rates never drift |
-| `effectcraft-geom` | 2D and 3D vectors, matrices and the layer transform (anchor, position, scale, rotation, orientation) |
-| `effectcraft-color` | RGBA color, sRGB transfer, HSL and HSV, and the 38 After Effects blend modes |
-| `effectcraft-keyframe` | Animated values: linear, hold and Bezier keyframes with speed and influence, and spatial motion paths |
-| `effectcraft-project` | The document: project items, compositions, layers and the property tree |
-| `effectcraft-raster` | Floating-point premultiplied images with warps, blurs and compositing, parallel across cores |
-| `effectcraft-path` | Bezier shapes, path operations (trim, round corners, zig zag, offset and more), stroking and anti-aliased fills |
-| `effectcraft-text` | Fonts, shaping, bidirectional text, line breaking and glyph outlines for text layers |
+241 effects across After Effects' categories, each with its parameter names, order and
+defaults: blur and sharpen, channel, color correction (Curves, Levels, Hue/Saturation, Lumetri
+Color…), distort (Warp, Bulge, Turbulent Displace, CC Power Pin…), generate (Fractal Noise,
+Gradient Ramp, Stroke, Write-on, Audio Spectrum…), keying, matte, noise and grain, perspective,
+**simulation** (CC Particle World, CC Rainfall, Shatter, Card Dance, Caustics, Wave World…),
+stylize (Glow, CC Glass…), text, transitions, utility and expression controls.
-These are moving fast. Expect names and APIs to change.
+
+
+
-## The plan
+## 3D
-EffectCraft is built in milestones. The first one is about getting something you can see on
-screen as early as possible, then filling in depth underneath.
+Classic 3D the way After Effects does it: 3D layers with orientation and material options,
+one- and two-node **cameras** with depth of field, **lights** (parallel, spot, point, ambient)
+with soft ray-traced shadows, layers that intersect correctly, orbit, pan and dolly camera
+tools, and Front, Top, Left and Custom views.
-| | Milestone | What you'll get |
-|---|---|---|
-| **M0** | Skeleton and visual shell | The full panel layout over a real CPU compositor playing an animated demo composition, about 8 effects, and the control channel and MCP server |
-| M1 | Keyframes | Complete temporal and spatial interpolation, Easy Ease, roving keys, velocity |
-| M2 | Compositing | All 38 blend modes, track mattes, parenting, 8/16/32 bit per channel behaviour |
-| M3 | Project operations | Composition and layer settings, layer commands, save and open `.ecproj`, undo, clipboard |
-| M4 | Preview and precomps | Nested compositions, adjustment layers, motion blur, cached RAM preview with audio |
-| M5 | Timeline depth | Keyframe editing, the graph editor, markers, trims, time remapping |
-| M6 | Shapes, masks and footage | Shape layers and path operations, masks, the pen tool, video and image import |
-| M7 | 3D | 3D layers, cameras and lights |
-| M8 | Expressions | JavaScript expressions with the After Effects object model (`wiggle`, `loopOut`, `thisComp` and friends) |
-| M9 | Text and effects | Text animators, text on a path, layer styles, the first 60 effects |
-| M10 | Export | Render queue, image sequences, H.264 and ProRes, GIF, command-line rendering |
-| M11 | Animation tools | Motion Sketch, Wiggler, presets, Lottie import and export, audio |
-| M12 | Performance | GPU compositing and effects, disk cache, motion tracking |
-| M13 to M16 | Beyond | More effects, puppet and paint tools, polish, the web app, a plugin API |
+
+
+
-The details, with an acceptance test for every task, are in
-[`plan/execution-plan.md`](plan/execution-plan.md) and [`plan/architecture.md`](plan/architecture.md).
+## Export
-## Building from source
+A Render Queue like After Effects', with Render Settings and Output Modules: **H.264** MP4 and
+**ProRes** MOV (Proxy to 4444 XQ with alpha) with audio, PNG, JPEG, TIFF and 32-bit EXR
+sequences, and animated GIF. The same queue runs from the command line. Every encoder is
+FilmCraft's pure-Rust code; there is no FFmpeg inside.
-You need [Rust](https://rustup.rs/) 1.95 or newer. There is nothing to launch yet, but you can
-build and test the engine crates:
+
+
+
+
+## Built for agents
+
+Everything you can do from a menu is a command with an id, and agents can reach every one of
+them:
+
+- **MCP server:** `effectcraft-cli mcp` speaks the Model Context Protocol over stdio, headless
+ or bridged to the running app (`--bridge 9877`). Tools cover commands, the project and property
+ tree, keyframes and rendered frames. This repository ships a ready [`.mcp.json`](.mcp.json).
+- **Command line:** one-shot calls with JSON output, for example
+ `effectcraft-cli set Main '#1' transform/position '[100,360]' --time 0 main.ecproj --save`
+ or `effectcraft-cli render --comp Main --out main.mp4`.
+- **Control channel:** `effectcraft --control 9877` accepts JSON lines to run commands, inspect
+ and click any widget by its automation id, and take screenshots.
+
+See [docs/agents.md](docs/agents.md) and [docs/control-protocol.md](docs/control-protocol.md).
+
+## Get started
+
+You need [Rust](https://rustup.rs/) 1.95 or newer.
```sh
git clone https://github.com/storytold/effectcraft
cd effectcraft
-cargo build
-cargo test
+cargo run --release -p effectcraft # the app, with the demo project open
+cargo run --release -p effectcraft-cli -- render --out intro.mp4 # render the demo headless
```
-To work on one crate:
+To work on it: `cargo test --workspace`, and `cargo xtask ci` before every commit (format, lints,
+tests, layering, asset attribution and the WebAssembly build). See [CONTRIBUTING.md](CONTRIBUTING.md),
+[docs/architecture.md](docs/architecture.md) and [docs/testing.md](docs/testing.md).
-```sh
-cargo test -p effectcraft-keyframe
-```
+## Where it stands
-The workspace picks up every crate under `crates/`, so while a new crate is half-written the
-whole build can break for a while. The `cargo xtask` helpers named in the plan (layer checks,
-asset checks, CI) are not written yet.
+EffectCraft is young. The core of After Effects is in place and gets deeper every week: what is
+done and what comes next is in the [ROADMAP](ROADMAP.md). Not there yet: layer styles, time and
+audio effects, audio playback, motion tracking, puppet and paint tools, the web build and GPU
+compositing. Projects are saved as `.ecproj`, readable versioned JSON; After Effects `.aep`
+files cannot be opened.
## How it's made
@@ -156,10 +186,10 @@ asset checks, CI) are not written yet.
top and nothing underneath depends on it.
- **Clean room.** We work from After Effects' public documentation and how it behaves, never
from Adobe's files, icons, presets or code. No code is copied from GPL projects. The full rules
- are in [`plan/README.md`](plan/README.md).
+ are in [AGENTS.md](AGENTS.md).
- **Private by default.** No telemetry, and no network access unless you ask for it.
- **One family.** EffectCraft shares its time model and text engine design with FilmCraft, and
- gets its video and audio codecs from it (see [`plan/adr/`](plan/adr/)).
+ gets its video and audio codecs from it.
## The Crafting Apps
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
index ecc392430..331503793 100644
--- a/crates/engine/Cargo.toml
+++ b/crates/engine/Cargo.toml
@@ -24,3 +24,4 @@ serde = { workspace = true }
serde_json = { workspace = true }
thiserror = { workspace = true }
log = { workspace = true }
+image = { workspace = true }
diff --git a/crates/engine/src/commands/anim.rs b/crates/engine/src/commands/anim.rs
index f3560ccdd..0fbef4bb0 100644
--- a/crates/engine/src/commands/anim.rs
+++ b/crates/engine/src/commands/anim.rs
@@ -386,7 +386,7 @@ pub fn specs() -> Vec {
vec![
cmd!("keys.copy", "Copy Keyframes", [], None, "{}", has_keys, copy),
cmd!("keys.paste", "Paste Keyframes", [], None, "{layers?, prop?|path?, time?}", has_key_clip, paste),
- cmd!("keys.selectAll", "Select All Keyframes", ["Edit"], Some("Cmd+Alt+A"), "{layers?}", keys_or_layers, select_all),
+ cmd!("keys.selectAll", "Select All Keyframes", [], Some("Cmd+Alt+A"), "{layers?}", keys_or_layers, select_all),
cmd!("keys.nudge", "Nudge Keyframes", [], None, "{frames, merge?}", has_keys, nudge),
cmd!("keys.nudgeForward", "Move Keyframes 1 Frame Later", [], Some("Alt+ArrowRight"), "{}", has_keys, |s, _| nudge(s, &json!({"frames": 1}))),
cmd!("keys.nudgeBackward", "Move Keyframes 1 Frame Earlier", [], Some("Alt+ArrowLeft"), "{}", has_keys, |s, _| nudge(s, &json!({"frames": -1}))),
diff --git a/crates/engine/src/commands/animation.rs b/crates/engine/src/commands/animation.rs
new file mode 100644
index 000000000..69a9ec31e
--- /dev/null
+++ b/crates/engine/src/commands/animation.rs
@@ -0,0 +1,399 @@
+//! Animation menu: animation presets (EffectCraft's own JSON format), Add Keyframe, Keyframe
+//! Assistant (Exponential Scale), text animators/selectors, and the
+//! Reveal Properties commands.
+
+use std::collections::BTreeMap;
+
+use effectcraft_keyframe::{Interp, Keyframe, Value as KV};
+use effectcraft_project::build::{self, Ids};
+use effectcraft_project::{GroupKind, LayerId, Node, PropGroup, Property, Uid};
+use effectcraft_time::Tick;
+use serde_json::{Value, json};
+
+use super::{CommandSpec, bad, frontend, has_comp, has_keys, has_layers, layer_mut, layer_p, layers_p, match_path_of, selected_leaf_props, str_p};
+use crate::{EngineError, KeyRef, Result, Session, cmd};
+
+/// Preset file format version tag (`*.ecpreset`, JSON).
+pub const PRESET_TAG: &str = "effectcraftAnimationPreset";
+
+fn has_selected_props(s: &Session) -> std::result::Result<(), String> {
+ has_comp(s)?;
+ if selected_leaf_props(s).is_empty() && selected_effects(s).is_empty() { Err("select properties or effects first".into()) } else { Ok(()) }
+}
+
+fn has_text_layer(s: &Session) -> std::result::Result<(), String> {
+ has_layers(s)?;
+ let c = s.active_comp().ok_or("no composition")?;
+ if s.state.selected_layers.iter().filter_map(|l| c.layer(*l)).any(|l| l.props.group("text/animators").is_some()) {
+ Ok(())
+ } else {
+ Err("select a text layer".into())
+ }
+}
+
+/// Selected effect groups (layer, effect group).
+fn selected_effects(s: &Session) -> Vec<(LayerId, PropGroup)> {
+ let Some(c) = s.active_comp() else { return vec![] };
+ s.state
+ .selected_props
+ .iter()
+ .filter_map(|(l, u)| {
+ let layer = c.layer(*l)?;
+ let fx = layer.effects()?;
+ fx.groups().find(|g| g.uid == *u).map(|g| (*l, g.clone()))
+ })
+ .collect()
+}
+
+// ---------------------------------------------------------------- presets
+
+fn save_preset(s: &mut Session, p: &Value) -> Result {
+ let path = str_p(p, "path").ok_or_else(|| bad("anim.savePreset", "missing `path`"))?.to_string();
+ let comp = s.active_comp().ok_or(EngineError::NoComp)?;
+ let t = s.time();
+ let effects: Vec<(LayerId, PropGroup)> = selected_effects(s);
+ let effect_uids: Vec = effects.iter().map(|(_, g)| g.uid).collect();
+ let mut props = vec![];
+ for (lid, uid) in selected_leaf_props(s) {
+ let Some(l) = comp.layer(lid) else { continue };
+ // Properties inside a saved effect travel with the effect.
+ if l.effects().is_some_and(|fx| fx.groups().any(|g| effect_uids.contains(&g.uid) && g.find(uid).is_some())) {
+ continue;
+ }
+ let (Some(pr), Some(mp)) = (l.props.find(uid), match_path_of(&l.props, uid)) else { continue };
+ props.push((l.layer_time(t), mp, pr.clone()));
+ }
+ if props.is_empty() && effects.is_empty() {
+ return Err(bad("anim.savePreset", "select properties or effects to save"));
+ }
+ // Key times are stored relative to the earliest key so the preset applies at the CTI.
+ let first = props.iter().flat_map(|(_, _, pr)| pr.keys.iter().map(|k| k.time)).min().unwrap_or(Tick::ZERO);
+ let props_json: Vec = props
+ .iter()
+ .map(|(_, mp, pr)| {
+ let mut pr = pr.clone();
+ for k in &mut pr.keys {
+ k.time -= first;
+ }
+ json!({"path": mp, "value": pr.value, "keys": pr.keys, "expression": pr.expr})
+ })
+ .collect();
+ let fx_json: Vec = effects.iter().map(|(_, g)| serde_json::to_value(g).unwrap_or_default()).collect();
+ let name = str_p(p, "name")
+ .map(str::to_string)
+ .unwrap_or_else(|| std::path::Path::new(&path).file_stem().map(|s| s.to_string_lossy().to_string()).unwrap_or_default());
+ let doc = json!({PRESET_TAG: 1, "name": name, "properties": props_json, "effects": fx_json});
+ let text = serde_json::to_string_pretty(&doc).unwrap_or_default();
+ s.services.write_file(&path, text.as_bytes()).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+ Ok(json!({"path": path, "properties": props.len(), "effects": effects.len()}))
+}
+
+fn apply_preset(s: &mut Session, p: &Value) -> Result {
+ let doc: Value = match (p.get("preset"), str_p(p, "path")) {
+ (Some(v), _) => v.clone(),
+ (None, Some(path)) => {
+ let bytes = s.services.read_file(path).map_err(|e| EngineError::Other(format!("cannot read {path}: {e}")))?;
+ serde_json::from_slice(&bytes).map_err(|e| bad("anim.applyPreset", format!("not a preset: {e}")))?
+ }
+ _ => return Err(bad("anim.applyPreset", "missing `path` (or inline `preset`)")),
+ };
+ if doc.get(PRESET_TAG).is_none() {
+ return Err(bad("anim.applyPreset", "not an EffectCraft animation preset"));
+ }
+ let (cid, ids) = layers_p(s, p)?;
+ if ids.is_empty() {
+ return Err(bad("anim.applyPreset", "select a layer"));
+ }
+ let effects: Vec =
+ doc["effects"].as_array().map(|a| a.iter().filter_map(|v| serde_json::from_value(v.clone()).ok()).collect()).unwrap_or_default();
+ let props: Vec<(String, Property)> = doc["properties"]
+ .as_array()
+ .map(|a| {
+ a.iter()
+ .filter_map(|v| {
+ let path = v["path"].as_str()?.to_string();
+ let value: KV = serde_json::from_value(v["value"].clone()).ok()?;
+ let keys: Vec = serde_json::from_value(v["keys"].clone()).unwrap_or_default();
+ let expr = serde_json::from_value(v["expression"].clone()).ok().flatten();
+ let mut pr = Property::new(0, "", "", value);
+ pr.keys = keys;
+ pr.expr = expr;
+ Some((path, pr))
+ })
+ .collect()
+ })
+ .unwrap_or_default();
+ let t = s.time();
+ let mut applied = 0;
+ let mut skipped = vec![];
+ s.edit("Apply Animation Preset", None, |proj, _| {
+ let mut next = proj.next_id;
+ for lid in &ids {
+ let l = layer_mut(proj, cid, *lid)?;
+ let lt = l.layer_time(t);
+ if let Some(fx) = l.props.sub_mut("effects") {
+ for g in &effects {
+ let mut g = g.clone();
+ g.reassign_uids(&mut next);
+ next += 1;
+ fx.children.push(Node::Group(g));
+ applied += 1;
+ }
+ }
+ for (path, src) in &props {
+ match l.props.prop_mut(path) {
+ Some(pr) if std::mem::discriminant(&pr.value) == std::mem::discriminant(&src.value) => {
+ pr.value = src.value.clone();
+ pr.keys = src
+ .keys
+ .iter()
+ .cloned()
+ .map(|mut k| {
+ k.time += lt;
+ k
+ })
+ .collect();
+ if src.expr.is_some() {
+ pr.expr = src.expr.clone();
+ }
+ applied += 1;
+ }
+ _ => skipped.push(path.clone()),
+ }
+ }
+ }
+ proj.next_id = next;
+ Ok(())
+ })?;
+ Ok(json!({"applied": applied, "skipped": skipped}))
+}
+
+// ---------------------------------------------------------------- keyframes
+
+fn add_keyframe(s: &mut Session, _: &Value) -> Result {
+ let targets = selected_leaf_props(s);
+ if targets.is_empty() {
+ return Err(bad("anim.addKeyframe", "select properties first"));
+ }
+ let cid = s.active_comp_id().ok_or(EngineError::NoComp)?;
+ let t = s.time();
+ let n = s.edit("Add Keyframe", None, |proj, _| {
+ let mut n = 0;
+ for (lid, uid) in &targets {
+ let l = layer_mut(proj, cid, *lid)?;
+ let lt = l.layer_time(t);
+ let Some(pr) = l.props.find_mut(*uid) else { continue };
+ if pr.static_only {
+ continue;
+ }
+ if pr.keys.is_empty() {
+ pr.set_animated(true, lt);
+ } else {
+ let v = pr.value_at(lt);
+ pr.set_value_at(lt, v);
+ }
+ n += 1;
+ }
+ Ok(n)
+ })?;
+ Ok(json!({"keys": n}))
+}
+
+/// Selected keys grouped by (layer, property).
+fn keys_by_prop(s: &Session) -> BTreeMap<(LayerId, Uid), Vec> {
+ let mut m: BTreeMap<(LayerId, Uid), Vec> = BTreeMap::new();
+ for k in &s.state.selected_keys {
+ m.entry((k.layer, k.prop)).or_default().push(k.time);
+ }
+ m
+}
+
+fn exponential_scale(s: &mut Session, _: &Value) -> Result {
+ let cid = s.active_comp_id().ok_or(EngineError::NoComp)?;
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ let fd = comp.frame_duration();
+ let groups = keys_by_prop(s);
+ let mut done = 0;
+ let mut work = vec![];
+ for ((lid, uid), mut times) in groups {
+ let Some(l) = comp.layer(lid) else { continue };
+ if l.transform().and_then(|tr| tr.get("scale")).map(|p| p.uid) != Some(uid) {
+ continue;
+ }
+ times.sort();
+ if times.len() >= 2 {
+ work.push((lid, uid, times[0], *times.last().unwrap_or(×[0])));
+ }
+ }
+ if work.is_empty() {
+ return Err(bad("keys.exponentialScale", "select two Scale keyframes"));
+ }
+ s.edit("Exponential Scale", None, |proj, st| {
+ for (lid, uid, a, b) in &work {
+ let l = layer_mut(proj, cid, *lid)?;
+ let Some(pr) = l.props.find_mut(*uid) else { continue };
+ let (va, vb) = (pr.value_at(*a).as_vec3(), pr.value_at(*b).as_vec3());
+ pr.keys.retain(|k| k.time <= *a || k.time >= *b);
+ let n = ((*b - *a).0 / fd.0.max(1)).max(1);
+ for i in 0..=n {
+ let u = i as f64 / n as f64;
+ let t = if i == n { *b } else { *a + Tick(fd.0 * i) };
+ let f = |x: f64, y: f64| if x.abs() < 1e-9 || y.abs() < 1e-9 || x.signum() != y.signum() { x + (y - x) * u } else { x * (y / x).powf(u) };
+ let v = [f(va[0], vb[0]), f(va[1], vb[1]), f(va[2], vb[2])];
+ let mut k = Keyframe::new(t, KV::Vec3(v));
+ k.in_interp = Interp::Linear;
+ k.out_interp = Interp::Linear;
+ effectcraft_keyframe::set_key(&mut pr.keys, k);
+ st.selected_keys.push(KeyRef { layer: *lid, prop: *uid, time: t });
+ }
+ done += 1;
+ }
+ st.selected_keys.sort_by_key(|k| (k.layer.0, k.prop, k.time));
+ st.selected_keys.dedup();
+ Ok(())
+ })?;
+ Ok(json!({"properties": done}))
+}
+
+// ---------------------------------------------------------------- text animators
+
+fn add_selector(s: &mut Session, p: &Value) -> Result {
+ let kind = str_p(p, "kind").unwrap_or("range");
+ if kind != "range" {
+ return Err(bad("text.addSelector", "only Range selectors are available"));
+ }
+ let (cid, lid) = layer_p(s, p, "text.addSelector")?;
+ // Target: a selected animator (or anything inside one), else the last animator.
+ let sel: Vec = s.state.selected_props.iter().filter(|(l, _)| *l == lid).map(|(_, u)| *u).collect();
+ let uid = s.edit("Add Text Selector", None, |proj, _| {
+ let mut next = proj.next_id;
+ let l = layer_mut(proj, cid, lid)?;
+ let anims = l.props.group_mut("text/animators").ok_or_else(|| bad("text.addSelector", "not a text layer"))?;
+ if anims.children.is_empty() {
+ return Err(bad("text.addSelector", "the layer has no text animators (use Animate Text first)"));
+ }
+ let idx = anims
+ .children
+ .iter()
+ .position(|c| c.as_group().is_some_and(|g| sel.contains(&g.uid) || sel.iter().any(|u| g.find(*u).is_some() || g.find_group(*u).is_some())))
+ .unwrap_or(anims.children.len() - 1);
+ let Some(Node::Group(anim)) = anims.children.get_mut(idx) else { return Err(bad("text.addSelector", "no animator")) };
+ let sels = anim.sub_mut("selectors").ok_or_else(|| bad("text.addSelector", "animator has no selectors group"))?;
+ let mut ids = Ids(&mut next);
+ let g = build::range_selector(&mut ids, &format!("Range Selector {}", sels.children.len() + 1));
+ let uid = g.uid;
+ sels.children.push(g.into());
+ proj.next_id = next;
+ Ok(uid)
+ })?;
+ Ok(json!({"selector": uid}))
+}
+
+fn remove_all_animators(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ s.edit("Remove All Text Animators", None, |proj, _| {
+ for lid in &ids {
+ if let Some(a) = layer_mut(proj, cid, *lid)?.props.group_mut("text/animators") {
+ a.children.clear();
+ }
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+// ---------------------------------------------------------------- reveal
+
+/// Whether a static property differs from the value a fresh layer would have. Transform
+/// defaults depend on the source size and comp size.
+fn modified(pr: &Property, group: &str, default_anchor: [f64; 2], comp_center: [f64; 2]) -> bool {
+ if pr.is_animated() || pr.expr.is_some() {
+ return true;
+ }
+ let v = &pr.value;
+ let near = |a: &[f64], b: &[f64]| a.iter().zip(b).all(|(x, y)| (x - y).abs() < 1e-6);
+ match (group, pr.match_id.as_str()) {
+ ("transform", "anchor") => !near(&v.as_vec2(), &default_anchor),
+ ("transform", "position") => !near(&v.as_vec2(), &comp_center) || v.as_vec3()[2].abs() > 1e-6,
+ ("transform", "scale") => !near(&v.as_vec3(), &[100.0; 3]),
+ ("transform", "opacity") => (v.as_f64() - 100.0).abs() > 1e-6,
+ ("transform", "orientation") => !near(&v.as_vec3(), &[0.0; 3]),
+ ("transform", _) => v.as_f64().abs() > 1e-6,
+ _ => false,
+ }
+}
+
+fn reveal(s: &mut Session, p: &Value) -> Result {
+ let kind = str_p(p, "kind").unwrap_or("keyframes").to_string();
+ let cid = super::comp_id(s, p)?;
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ let layers: Vec = if s.state.selected_layers.is_empty() { comp.layers.iter().map(|l| l.id).collect() } else { s.state.selected_layers.clone() };
+ let mut out = vec![];
+ for lid in &layers {
+ let Some(l) = comp.layer(*lid) else { continue };
+ let (w, h) = effectcraft_render::source_size(&s.project, l);
+ let anchor = [w as f64 / 2.0, h as f64 / 2.0];
+ let center = [comp.width as f64 / 2.0, comp.height as f64 / 2.0];
+ for top in l.props.groups() {
+ let hit = |pr: &Property| match kind.as_str() {
+ "keyframes" => pr.is_animated(),
+ "animation" => pr.is_animated() || pr.has_expression(),
+ _ => modified(pr, &top.match_id, anchor, center),
+ };
+ let mut found = vec![];
+ top.walk("", &mut |_, pr| {
+ if hit(pr) {
+ found.push(pr.uid);
+ }
+ });
+ // Modified: effects and masks count as modifications in full (AE reveals them).
+ if kind == "modified" && matches!(top.match_id.as_str(), "effects" | "masks") {
+ for g in top.groups() {
+ found.push(g.uid);
+ }
+ }
+ if kind == "modified" && top.match_id == "text" {
+ for g in top.group("animators").into_iter().flat_map(|a| a.groups()) {
+ found.push(g.uid);
+ }
+ }
+ out.extend(found.into_iter().map(|u| json!({"layer": lid.0, "prop": u})));
+ }
+ }
+ frontend(s, "timeline.revealProps", &json!({"props": out, "kind": kind}))?;
+ Ok(json!({"props": out}))
+}
+
+/// Is `g` an effect/mask group kind (used by tests).
+#[allow(dead_code)]
+pub(crate) fn is_indexed(g: &PropGroup) -> bool {
+ matches!(g.kind, GroupKind::Indexed | GroupKind::Mask { .. } | GroupKind::Effect { .. })
+}
+
+pub fn specs() -> Vec {
+ vec![
+ cmd!(
+ "anim.savePreset",
+ "Save Animation Preset...",
+ ["Animation"],
+ None,
+ "{path (.ecpreset), name?} — saves the selected properties/effects",
+ has_selected_props,
+ save_preset
+ ),
+ cmd!("anim.applyPreset", "Apply Animation Preset...", ["Animation"], None, "{path | preset, layers?}", has_layers, apply_preset),
+ cmd!("anim.addKeyframe", "Add Keyframe", ["Animation"], None, "{} — keys the selected properties at the CTI", has_selected_props, add_keyframe),
+ cmd!(
+ "keys.exponentialScale",
+ "Exponential Scale",
+ ["Animation", "Keyframe Assistant"],
+ None,
+ "{} — two selected Scale keys",
+ has_keys,
+ exponential_scale
+ ),
+ cmd!("text.addSelector", "Add Text Selector", [], None, "{layer?, kind: range}", has_text_layer, add_selector),
+ cmd!("text.removeAllAnimators", "Remove All Text Animators", ["Animation"], None, "{layers?}", has_text_layer, remove_all_animators),
+ cmd!("anim.reveal", "Reveal Properties", [], None, "{kind: keyframes|animation|modified}", has_comp, reveal),
+ ]
+}
diff --git a/crates/engine/src/commands/comp.rs b/crates/engine/src/commands/comp.rs
index f00b9b519..996df5df7 100644
--- a/crates/engine/src/commands/comp.rs
+++ b/crates/engine/src/commands/comp.rs
@@ -241,7 +241,7 @@ pub fn specs() -> Vec {
vec![
cmd!(
"comp.new",
- "New Composition…",
+ "New Composition...",
["Composition"],
Some("Cmd+N"),
"{name?, width?, height?, frameRate?, duration? (s), startTime? (s) | startTimecode?, background? [r,g,b]|#hex, pixelAspect?, shutterAngle?, shutterPhase?, motionBlurSamples?, renderer? classic3D|advanced3D, anchor?, open?}",
@@ -250,7 +250,7 @@ pub fn specs() -> Vec {
),
cmd!(
"comp.settings",
- "Composition Settings…",
+ "Composition Settings...",
["Composition"],
Some("Cmd+K"),
"{comp?, name?, width?, height?, anchor? 0-8 (resize anchor, 4 = center), frameRate?, duration?, startTime? (s) | startTimecode?, background?, shutterAngle?, shutterPhase?, motionBlurSamples?, pixelAspect?, renderer? classic3D|advanced3D}",
@@ -260,7 +260,7 @@ pub fn specs() -> Vec {
cmd!("comp.setPosterTime", "Set Poster Time", ["Composition"], None, "{}", has_comp, poster),
cmd!("comp.trimToWorkArea", "Trim Comp to Work Area", ["Composition"], Some("Cmd+Shift+X"), "{comp?}", has_comp, trim_to_wa),
cmd!("comp.open", "Open Composition", [], None, "{comp: id|name}", always, open),
- cmd!("comp.close", "Close Composition", [], Some("Cmd+W"), "{comp?}", has_comp, close),
+ cmd!("comp.close", "Close Composition", [], None, "{comp?}", has_comp, close),
cmd!("comp.workArea", "Set Work Area", [], None, "{start?, end?, set?: begin|end (at CTI)}", has_comp, work_area),
cmd!("comp.setSwitch", "Composition Switch", [], None, "{switch: hideShy|motionBlur|frameBlending|draft3d, value?}", has_comp, comp_switch),
cmd!("comp.addMarker", "Add Marker", [], Some("Num*"), "{time?, comment?}", has_comp, add_marker),
diff --git a/crates/engine/src/commands/comp_more.rs b/crates/engine/src/commands/comp_more.rs
new file mode 100644
index 000000000..6a066b5ac
--- /dev/null
+++ b/crates/engine/src/commands/comp_more.rs
@@ -0,0 +1,130 @@
+//! Composition menu, part two: crop to region of interest / layer bounds, Save Frame As ▸ File,
+//! Responsive Design — Time.
+
+use effectcraft_keyframe::Value as KV;
+use effectcraft_project::Marker;
+use effectcraft_time::Tick;
+use serde_json::{Value, json};
+
+use super::{CommandSpec, bad, comp_id, f_p, has_comp, has_layers, layers_p, str_p};
+use crate::{EngineError, Result, Session, cmd};
+
+fn has_roi(s: &Session) -> std::result::Result<(), String> {
+ has_comp(s)?;
+ if s.state.region_of_interest.is_some() { Ok(()) } else { Err("draw a region of interest in the viewer first".into()) }
+}
+
+/// Crop the comp to `[x, y, w, h]`: the comp shrinks and every unparented layer moves by -x, -y
+/// (all position keys too) so nothing moves on screen.
+fn crop(s: &mut Session, cid: effectcraft_project::ItemId, r: [f64; 4], label: &str) -> Result {
+ let (x, y) = (r[0].round(), r[1].round());
+ let (w, h) = (r[2].round().max(1.0) as u32, r[3].round().max(1.0) as u32);
+ s.edit(label, None, |proj, st| {
+ let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+ c.width = w;
+ c.height = h;
+ for l in c.layers.iter_mut().filter(|l| l.parent.is_none()) {
+ let Some(pos) = l.transform_mut().and_then(|tr| tr.get_mut("position")) else { continue };
+ let mv = |v: &KV| {
+ let a = v.as_vec3();
+ KV::Vec3([a[0] - x, a[1] - y, a[2]])
+ };
+ pos.value = mv(&pos.value);
+ for k in &mut pos.keys {
+ k.value = mv(&k.value);
+ }
+ }
+ for g in &mut c.guides {
+ g.position -= if g.vertical { x } else { y };
+ }
+ st.region_of_interest = None;
+ Ok(())
+ })?;
+ Ok(json!({"width": w, "height": h, "offset": [x, y]}))
+}
+
+fn crop_to_roi(s: &mut Session, p: &Value) -> Result {
+ let cid = comp_id(s, p)?;
+ let r = s.state.region_of_interest.ok_or_else(|| bad("comp.cropToRegionOfInterest", "no region of interest"))?;
+ crop(s, cid, r, "Crop Comp to Region of Interest")
+}
+
+fn crop_to_layers(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ let t = s.time();
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ let ctx = effectcraft_render::EvalCtx::new(&s.project, cid, comp, t);
+ let mut b = [f64::MAX, f64::MAX, f64::MIN, f64::MIN];
+ for l in comp.layers.iter().filter(|l| ids.contains(&l.id)) {
+ let Some([x0, y0, x1, y1]) = effectcraft_render::content_bounds(&ctx, l) else { continue };
+ let (m, _) = ctx.layer_to_comp(l);
+ for (px, py) in [(x0, y0), (x1, y0), (x1, y1), (x0, y1)] {
+ let v = m.0;
+ let wz = v[2][0] * px + v[2][1] * py + v[2][2];
+ let wz = if wz.abs() < 1e-9 { 1.0 } else { wz };
+ let cx = (v[0][0] * px + v[0][1] * py + v[0][2]) / wz;
+ let cy = (v[1][0] * px + v[1][1] * py + v[1][2]) / wz;
+ b = [b[0].min(cx), b[1].min(cy), b[2].max(cx), b[3].max(cy)];
+ }
+ }
+ if b[0] > b[2] {
+ return Err(bad("comp.cropToLayerBounds", "the selected layers have no visible bounds"));
+ }
+ let (x0, y0) = (b[0].floor(), b[1].floor());
+ crop(s, cid, [x0, y0, b[2].ceil() - x0, b[3].ceil() - y0], "Crop Comp to Selected Layer(s) Bounds")
+}
+
+/// Encode straight 8-bit RGBA as PNG.
+pub(crate) fn encode_png(rgba: &[u8], w: u32, h: u32) -> std::result::Result, String> {
+ use image::ImageEncoder;
+ let mut out = vec![];
+ image::codecs::png::PngEncoder::new(&mut out).write_image(rgba, w, h, image::ExtendedColorType::Rgba8).map_err(|e| e.to_string())?;
+ Ok(out)
+}
+
+fn save_frame(s: &mut Session, p: &Value) -> Result {
+ let path = str_p(p, "path").ok_or_else(|| bad("comp.saveFrameAs", "missing `path` (.png)"))?.to_string();
+ let cid = comp_id(s, p)?;
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ let t = f_p(p, "time").map(Tick::from_seconds_f64).unwrap_or(s.time());
+ let scale = f_p(p, "scale").unwrap_or(1.0).clamp(0.01, 4.0);
+ let bg = comp.background;
+ let img = s.render(cid, t, effectcraft_render::RenderOpts { scale, ..Default::default() });
+ let rgba = img.to_rgba8_over(bg);
+ let png = encode_png(&rgba, img.width, img.height).map_err(|e| EngineError::Other(format!("PNG encoding failed: {e}")))?;
+ s.services.write_file(&path, &png).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+ s.toast(format!("Saved frame to {path}"));
+ Ok(json!({"path": path, "width": img.width, "height": img.height, "time": t.seconds()}))
+}
+
+/// Responsive Design — Time: protected comp markers for an intro, an outro or the work area.
+fn responsive_time(s: &mut Session, p: &Value) -> Result {
+ let cid = comp_id(s, p)?;
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ let t = s.time();
+ let (start, end, comment) = match str_p(p, "op").unwrap_or("workArea") {
+ "intro" => (Tick::ZERO, t, "Intro"),
+ "outro" => (t, comp.duration, "Outro"),
+ "workArea" => (comp.work_area.0, comp.work_area.1, "Protected Region"),
+ o => return Err(bad("comp.responsiveTime", format!("op: intro|outro|workArea, not `{o}`"))),
+ };
+ if end <= start {
+ return Err(bad("comp.responsiveTime", "move the current time first (the region would be empty)"));
+ }
+ s.edit("Create Protected Region", None, |proj, _| {
+ let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+ c.markers.push(Marker { time: start, duration: end - start, comment: comment.into(), protected: true, ..Default::default() });
+ c.markers.sort_by_key(|m| m.time);
+ Ok(())
+ })?;
+ Ok(json!({"start": start.seconds(), "end": end.seconds()}))
+}
+
+pub fn specs() -> Vec {
+ vec![
+ cmd!("comp.cropToRegionOfInterest", "Crop Comp to Region of Interest", ["Composition"], None, "{comp?}", has_roi, crop_to_roi),
+ cmd!("comp.cropToLayerBounds", "Crop Comp to Selected Layer(s) Bounds", ["Composition"], None, "{layers?}", has_layers, crop_to_layers),
+ cmd!("comp.saveFrameAs", "File...", ["Composition", "Save Frame As"], Some("Cmd+Alt+S"), "{path (.png), time?, scale?}", has_comp, save_frame),
+ cmd!("comp.responsiveTime", "Responsive Design — Time", [], None, "{op: intro|outro|workArea}", has_comp, responsive_time),
+ ]
+}
diff --git a/crates/engine/src/commands/edit.rs b/crates/engine/src/commands/edit.rs
index 027c23b65..df7a9e426 100644
--- a/crates/engine/src/commands/edit.rs
+++ b/crates/engine/src/commands/edit.rs
@@ -1,11 +1,12 @@
//! Edit menu.
use effectcraft_color::Label;
-use effectcraft_project::{Layer, LayerId};
+use effectcraft_project::{Expression, ItemKind, Layer, LayerId, LayerSource};
+use effectcraft_time::Tick;
use serde_json::{Value, json};
-use super::{CommandSpec, has_comp, has_layers, layers_p, str_p};
-use crate::{Result, Session, cmd};
+use super::{CommandSpec, has_comp, has_layers, layers_p, match_path_of, selected_leaf_props, str_p};
+use crate::{EngineError, LinkClip, Result, Session, cmd};
fn can_undo(s: &Session) -> std::result::Result<(), String> {
if s.history.undo.is_empty() { Err("nothing to undo".into()) } else { Ok(()) }
@@ -15,7 +16,25 @@ fn can_redo(s: &Session) -> std::result::Result<(), String> {
}
fn has_clip(s: &Session) -> std::result::Result<(), String> {
has_comp(s)?;
- if s.state.clipboard.is_empty() && s.state.key_clipboard.is_empty() { Err("the clipboard is empty".into()) } else { Ok(()) }
+ if s.state.clipboard.is_empty() && s.state.key_clipboard.is_empty() && s.state.link_clipboard.is_none() {
+ Err("the clipboard is empty".into())
+ } else {
+ Ok(())
+ }
+}
+fn has_key_clip(s: &Session) -> std::result::Result<(), String> {
+ has_layers(s)?;
+ if s.state.key_clipboard.is_empty() { Err("no keyframes on the clipboard".into()) } else { Ok(()) }
+}
+fn has_props_or_layers(s: &Session) -> std::result::Result<(), String> {
+ has_comp(s)?;
+ if s.state.selected_layers.is_empty() && s.state.selected_props.is_empty() { Err("select layers or properties first".into()) } else { Ok(()) }
+}
+fn has_props_or_layers_or_items(s: &Session) -> std::result::Result<(), String> {
+ if has_props_or_layers(s).is_ok() || !s.state.project_selection.is_empty() { Ok(()) } else { Err("select layers or project items first".into()) }
+}
+fn has_selected_footage(s: &Session) -> std::result::Result<(), String> {
+ if original_path(s).is_some() { Ok(()) } else { Err("select a footage item or layer".into()) }
}
fn undo(s: &mut Session, _: &Value) -> Result {
@@ -100,18 +119,187 @@ fn delete(s: &mut Session, p: &Value) -> Result {
Ok(json!(ids.len()))
}
+fn clear_clipboards(s: &mut Session) {
+ s.state.clipboard.clear();
+ s.state.key_clipboard.clear();
+ s.state.link_clipboard = None;
+ s.state.clip_is_keys = false;
+}
+
+/// Edit ▸ Copy: selected keyframes (when any) go to the keyframe clipboard, else layers.
fn copy(s: &mut Session, p: &Value) -> Result {
// Keyframes selected → copy keys (pasted at the CTI).
if !s.state.selected_keys.is_empty() && p.get("layers").is_none() {
+ s.state.link_clipboard = None;
return s.execute("keys.copy", json!({}));
}
let (cid, ids) = layers_p(s, p)?;
s.state.clip_is_keys = false;
let comp = s.project.comp(cid).ok_or(crate::EngineError::NoComp)?;
- s.state.clipboard = comp.layers.iter().filter(|l| ids.contains(&l.id)).cloned().collect();
+ let layers: Vec = comp.layers.iter().filter(|l| ids.contains(&l.id)).cloned().collect();
+ clear_clipboards(s);
+ s.state.clipboard = layers;
Ok(json!(s.state.clipboard.len()))
}
+/// The expression accessor for a property, e.g. `comp("Main").layer("Solid").transform("Position")`.
+pub(crate) fn link_expression(s: &Session, lid: LayerId, uid: effectcraft_project::Uid, relative: bool) -> Option {
+ let cid = s.active_comp_id()?;
+ let comp = s.project.comp(cid)?;
+ let l = comp.layer(lid)?;
+ let names = l.props.name_path_of(uid)?;
+ let matches = match_path_of(&l.props, uid)?;
+ let names: Vec<&str> = names.split('/').collect();
+ let first = matches.split('/').next()?.to_string();
+ let q = |x: &str| serde_json::to_string(x).unwrap_or_default();
+ let base = if relative { format!("thisComp.layer({})", q(&l.name)) } else { format!("comp({}).layer({})", q(&s.project.item(cid)?.name), q(&l.name)) };
+ let mut out = match first.as_str() {
+ "transform" => format!("{base}.transform"),
+ "effects" => format!("{base}.effect({})", q(names.get(1)?)),
+ "masks" => format!("{base}.mask({})", q(names.get(1)?)),
+ "text" => format!("{base}.text"),
+ "contents" => format!("{base}.content({})", q(names.get(1)?)),
+ _ => return None,
+ };
+ let skip = if matches!(first.as_str(), "effects" | "masks" | "contents") { 2 } else { 1 };
+ for n in names.iter().skip(skip) {
+ out.push_str(&format!("({})", q(n)));
+ }
+ Some(out)
+}
+
+fn copy_links(s: &mut Session, p: &Value, relative: bool) -> Result {
+ let props = selected_leaf_props(s);
+ if props.is_empty() {
+ // Layers: copy them with every animatable transform/effect property linked to the source.
+ let (cid, ids) = layers_p(s, p)?;
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ let mut layers = vec![];
+ for l in comp.layers.iter().filter(|l| ids.contains(&l.id)) {
+ let mut copy = l.clone();
+ let mut uids = vec![];
+ for g in ["transform", "effects"] {
+ if let Some(grp) = l.props.sub(g) {
+ grp.walk("", &mut |_, pr| {
+ if !pr.static_only && !pr.hold_only {
+ uids.push(pr.uid);
+ }
+ });
+ }
+ }
+ for uid in uids {
+ if let (Some(e), Some(pr)) = (link_expression(s, l.id, uid, relative), copy.props.find_mut(uid)) {
+ pr.expr = Some(Expression { text: e, enabled: true });
+ }
+ }
+ layers.push(copy);
+ }
+ let n = layers.len();
+ clear_clipboards(s);
+ s.state.clipboard = layers;
+ return Ok(json!({"layers": n}));
+ }
+ let comp = s.active_comp().ok_or(EngineError::NoComp)?;
+ let mut links = vec![];
+ for (lid, uid) in &props {
+ let Some(path) = comp.layer(*lid).and_then(|l| match_path_of(&l.props, *uid)) else { continue };
+ if let Some(e) = link_expression(s, *lid, *uid, relative) {
+ links.push((path, e));
+ }
+ }
+ let n = links.len();
+ clear_clipboards(s);
+ s.state.link_clipboard = Some(LinkClip::Links { relative, links });
+ Ok(json!({"links": n}))
+}
+
+fn copy_expression_only(s: &mut Session, _: &Value) -> Result {
+ let comp = s.active_comp().ok_or(EngineError::NoComp)?;
+ let mut out = vec![];
+ for (lid, uid) in selected_leaf_props(s) {
+ let Some(l) = comp.layer(lid) else { continue };
+ if let (Some(pr), Some(path)) = (l.props.find(uid), match_path_of(&l.props, uid))
+ && let Some(e) = &pr.expr
+ {
+ out.push((path, e.clone()));
+ }
+ }
+ if out.is_empty() {
+ return Err(EngineError::Other("the selected properties have no expressions".into()));
+ }
+ let n = out.len();
+ clear_clipboards(s);
+ s.state.link_clipboard = Some(LinkClip::Expressions(out));
+ Ok(json!({"expressions": n}))
+}
+
+/// Paste the keyframe clipboard at the CTI onto the selected layers (same property paths).
+fn paste_keys(s: &mut Session, reversed: bool) -> Result {
+ let cid = s.active_comp_id().ok_or(EngineError::NoComp)?;
+ let ids = s.state.selected_layers.clone();
+ if ids.is_empty() {
+ return Err(EngineError::Other("select a layer to paste keyframes into".into()));
+ }
+ let clip = s.state.key_clipboard.clone();
+ let t = s.time();
+ let n = s.edit(if reversed { "Paste Reversed Keyframes" } else { "Paste Keyframes" }, None, |proj, st| {
+ let mut n = 0;
+ st.selected_keys.clear();
+ for lid in &ids {
+ let l = super::layer_mut(proj, cid, *lid)?;
+ let lt = l.layer_time(t);
+ for c in &clip {
+ let Some(pr) = l.props.prop_mut(&c.path) else { continue };
+ let span = c.keys.last().map(|k| k.time).unwrap_or(Tick::ZERO);
+ for k in &c.keys {
+ let mut k = k.clone();
+ if std::mem::discriminant(&k.value) != std::mem::discriminant(&pr.value) {
+ continue;
+ }
+ if reversed {
+ k.time = span - k.time;
+ std::mem::swap(&mut k.in_interp, &mut k.out_interp);
+ std::mem::swap(&mut k.in_ease, &mut k.out_ease);
+ std::mem::swap(&mut k.spatial_in, &mut k.spatial_out);
+ }
+ k.time += lt;
+ st.selected_keys.push(crate::KeyRef { layer: *lid, prop: pr.uid, time: k.time });
+ effectcraft_keyframe::set_key(&mut pr.keys, k);
+ n += 1;
+ }
+ }
+ }
+ Ok(n)
+ })?;
+ Ok(json!({"keys": n}))
+}
+
+fn paste_links(s: &mut Session, clip: LinkClip) -> Result {
+ let cid = s.active_comp_id().ok_or(EngineError::NoComp)?;
+ let ids = s.state.selected_layers.clone();
+ if ids.is_empty() {
+ return Err(EngineError::Other("select a layer to paste into".into()));
+ }
+ let pairs: Vec<(String, Expression)> = match clip {
+ LinkClip::Links { links, .. } => links.into_iter().map(|(p, e)| (p, Expression { text: e, enabled: true })).collect(),
+ LinkClip::Expressions(v) => v,
+ };
+ let n = s.edit("Paste", None, |proj, _| {
+ let mut n = 0;
+ for lid in &ids {
+ let l = super::layer_mut(proj, cid, *lid)?;
+ for (path, e) in &pairs {
+ if let Some(pr) = l.props.prop_mut(path) {
+ pr.expr = Some(e.clone());
+ n += 1;
+ }
+ }
+ }
+ Ok(n)
+ })?;
+ Ok(json!({"expressions": n}))
+}
+
fn cut(s: &mut Session, p: &Value) -> Result {
if !s.state.selected_keys.is_empty() && p.get("layers").is_none() {
s.execute("keys.copy", json!({}))?;
@@ -122,6 +310,9 @@ fn cut(s: &mut Session, p: &Value) -> Result {
}
fn paste(s: &mut Session, p: &Value) -> Result {
+ if let Some(clip) = s.state.link_clipboard.clone() {
+ return paste_links(s, clip);
+ }
if s.state.clip_is_keys && !s.state.key_clipboard.is_empty() {
return s.execute("keys.paste", p.clone());
}
@@ -196,6 +387,123 @@ fn label(s: &mut Session, p: &Value) -> Result {
Ok(Value::Null)
}
+fn paste_reversed(s: &mut Session, _: &Value) -> Result {
+ paste_keys(s, true)
+}
+
+/// Lift (leave a gap) or extract (close the gap) the work area from the selected layers (all
+/// unlocked layers when none are selected).
+fn work_area_cut(s: &mut Session, p: &Value, extract: bool) -> Result {
+ let cid = super::comp_id(s, p)?;
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ let (a, b) = comp.work_area;
+ let ids: Vec = match layers_p(s, p)?.1 {
+ v if v.is_empty() => comp.layers.iter().map(|l| l.id).collect(),
+ v => v,
+ };
+ let gap = b - a;
+ s.edit(if extract { "Extract Work Area" } else { "Lift Work Area" }, None, |proj, st| {
+ let mut next = proj.next_id;
+ let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+ let shift = |l: &mut Layer, d: Tick| {
+ l.start_time += d;
+ l.in_point += d;
+ l.out_point += d;
+ };
+ let mut i = 0;
+ while i < c.layers.len() {
+ if !ids.contains(&c.layers[i].id) || c.layers[i].switches.locked {
+ i += 1;
+ continue;
+ }
+ let (lin, lout) = (c.layers[i].in_point, c.layers[i].out_point);
+ if lout <= a {
+ i += 1;
+ } else if lin >= b {
+ if extract {
+ shift(&mut c.layers[i], Tick::ZERO - gap);
+ }
+ i += 1;
+ } else if lin >= a && lout <= b {
+ c.layers.remove(i);
+ } else if lin < a && lout > b {
+ // Split around the work area: the layer keeps the head, a copy takes the tail.
+ let mut tail = c.layers[i].clone();
+ reid(&mut tail, &mut next);
+ tail.in_point = b;
+ if extract {
+ shift(&mut tail, Tick::ZERO - gap);
+ }
+ c.layers[i].out_point = a;
+ c.layers.insert(i, tail);
+ i += 2;
+ } else if lin < a {
+ c.layers[i].out_point = a;
+ i += 1;
+ } else {
+ c.layers[i].in_point = b;
+ if extract {
+ shift(&mut c.layers[i], Tick::ZERO - gap);
+ }
+ i += 1;
+ }
+ }
+ let alive: Vec = c.layers.iter().map(|l| l.id).collect();
+ st.selected_layers.retain(|l| alive.contains(l));
+ proj.next_id = next;
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn lift(s: &mut Session, p: &Value) -> Result {
+ work_area_cut(s, p, false)
+}
+fn extract(s: &mut Session, p: &Value) -> Result {
+ work_area_cut(s, p, true)
+}
+
+fn select_label_group(s: &mut Session, _: &Value) -> Result {
+ let comp = s.active_comp().ok_or(EngineError::NoComp)?;
+ let labels: Vec = s.state.selected_layers.iter().filter_map(|l| comp.layer(*l)).map(|l| l.label).collect();
+ if labels.is_empty() {
+ // Project panel: items with the same labels.
+ let items: Vec = s.state.project_selection.iter().filter_map(|i| s.project.item(*i)).map(|i| i.label).collect();
+ s.state.project_selection = s.project.items.values().filter(|i| items.contains(&i.label)).map(|i| i.id).collect();
+ return Ok(json!({"items": s.state.project_selection.len()}));
+ }
+ s.state.selected_layers = comp.layers.iter().filter(|l| labels.contains(&l.label)).map(|l| l.id).collect();
+ Ok(json!({"layers": s.state.selected_layers.len()}))
+}
+
+fn purge_caches(s: &mut Session, p: &Value) -> Result {
+ let what = str_p(p, "what").unwrap_or("all").to_string();
+ s.events.push(crate::Event::PurgeCaches);
+ s.toast(format!("Purged {what} cache"));
+ Ok(json!({"purged": what}))
+}
+
+/// Path of the footage behind the selected layer or project item.
+fn original_path(s: &Session) -> Option {
+ let comp = s.active_comp();
+ let from_layer = s.state.selected_layers.first().and_then(|l| comp?.layer(*l)).and_then(|l| match l.source {
+ LayerSource::Footage { item } => Some(item),
+ _ => None,
+ });
+ let item = from_layer.or_else(|| s.state.project_selection.first().copied())?;
+ match &s.project.item(item)?.kind {
+ ItemKind::Footage(f) if !f.path.is_empty() => Some(f.path.clone()),
+ _ => None,
+ }
+}
+
+fn edit_original(s: &mut Session, _: &Value) -> Result {
+ let path = original_path(s).ok_or_else(|| super::bad("edit.editOriginal", "select a footage item or layer"))?;
+ let url = format!("file://{path}");
+ s.events.push(crate::Event::OpenUrl(url.clone()));
+ Ok(json!({"url": url}))
+}
+
fn purge(s: &mut Session, _: &Value) -> Result {
s.history.undo.clear();
s.history.redo.clear();
@@ -209,14 +517,39 @@ pub fn specs() -> Vec {
cmd!("edit.redo", "Redo", ["Edit"], Some("Cmd+Shift+Z"), "{}", can_redo, redo),
cmd!("edit.cut", "Cut", ["Edit"], Some("Cmd+X"), "{layers?} (keyframes when keys are selected)", layers_or_keys, cut),
cmd!("edit.copy", "Copy", ["Edit"], Some("Cmd+C"), "{layers?} (keyframes when keys are selected)", layers_or_keys, copy),
- cmd!("edit.paste", "Paste", ["Edit"], Some("Cmd+V"), "{}", has_clip, paste),
+ cmd!(
+ "edit.copyWithPropertyLinks",
+ "Copy with Property Links",
+ ["Edit"],
+ Some("Cmd+Alt+C"),
+ "{layers?} (selected properties, or layers, as expressions linking to the originals)",
+ has_props_or_layers,
+ |s, p| copy_links(s, p, false)
+ ),
+ cmd!(
+ "edit.copyWithRelativePropertyLinks",
+ "Copy with Relative Property Links",
+ ["Edit"],
+ None,
+ "{layers?} (like Copy with Property Links, using thisComp)",
+ has_props_or_layers,
+ |s, p| copy_links(s, p, true)
+ ),
+ cmd!("edit.copyExpressionOnly", "Copy Expression Only", ["Edit"], None, "{}", has_props_or_layers, copy_expression_only),
+ cmd!("edit.paste", "Paste", ["Edit"], Some("Cmd+V"), "{} (layers, keyframes at the CTI, or property links / expressions)", has_clip, paste),
+ cmd!("edit.pasteReversedKeyframes", "Paste Reversed Keyframes", ["Edit"], None, "{}", has_key_clip, paste_reversed),
cmd!("edit.clear", "Clear", ["Edit"], Some("Delete"), "{layers?}", layers_or_keys, delete),
cmd!("edit.duplicate", "Duplicate", ["Edit"], Some("Cmd+D"), "{layers?}", has_layers, duplicate),
cmd!("edit.splitLayer", "Split Layer", ["Edit"], Some("Cmd+Shift+D"), "{layers?}", has_layers, split),
+ cmd!("edit.liftWorkArea", "Lift Work Area", ["Edit"], None, "{layers?}", has_comp, lift),
+ cmd!("edit.extractWorkArea", "Extract Work Area", ["Edit"], None, "{layers?}", has_comp, extract),
cmd!("edit.selectAll", "Select All", ["Edit"], Some("Cmd+A"), "{}", has_comp, select_all),
cmd!("edit.deselectAll", "Deselect All", ["Edit"], Some("Cmd+Shift+A"), "{}", always_ok, deselect_all),
cmd!("edit.label", "Label", ["Edit", "Label"], None, "{label: Red|Yellow|Aqua|…, layers?}", always_ok, label),
+ cmd!("edit.selectLabelGroup", "Select Label Group", ["Edit", "Label"], None, "{}", has_props_or_layers_or_items, select_label_group),
cmd!("edit.purgeUndo", "Undo", ["Edit", "Purge"], None, "{}", always_ok, purge),
+ cmd!("edit.purge", "Purge", [], None, "{what?: all|memoryAndDisk|memory|disk|3d|image|snapshot}", always_ok, purge_caches),
+ cmd!("edit.editOriginal", "Edit Original...", ["Edit"], Some("Cmd+E"), "{}", has_selected_footage, edit_original),
]
}
diff --git a/crates/engine/src/commands/file.rs b/crates/engine/src/commands/file.rs
index aa9b8fb26..343ca6113 100644
--- a/crates/engine/src/commands/file.rs
+++ b/crates/engine/src/commands/file.rs
@@ -141,16 +141,16 @@ fn cycle_depth(s: &mut Session, _: &Value) -> Result {
pub fn specs() -> Vec {
vec![
cmd!("file.newProject", "New Project", ["File", "New"], Some("Cmd+Alt+N"), "{}", always, new_project),
- cmd!("file.openDemoProject", "Open Demo Project", ["File"], None, "{}", always, demo),
- cmd!("file.open", "Open Project…", ["File"], Some("Cmd+O"), "{path}", always, open),
+ cmd!("file.openDemoProject", "Open Demo Project", ["Help"], None, "{}", always, demo),
+ cmd!("file.open", "Open Project...", ["File"], Some("Cmd+O"), "{path}", always, open),
cmd!("file.save", "Save", ["File"], Some("Cmd+S"), "{path?}", always, save),
- cmd!("file.saveAs", "Save As…", ["File", "Save As"], Some("Cmd+Shift+S"), "{path}", always, save_as),
+ cmd!("file.saveAs", "Save As...", ["File", "Save As"], Some("Cmd+Shift+S"), "{path}", always, save_as),
cmd!("file.incrementAndSave", "Increment and Save", ["File"], Some("Cmd+Alt+Shift+S"), "{}", has_path, increment_save),
cmd!("file.revert", "Revert", ["File"], None, "{}", has_path, revert),
- cmd!("file.import", "File…", ["File", "Import"], Some("Cmd+I"), "{paths: [string]}", always, import),
+ cmd!("file.import", "File...", ["File", "Import"], Some("Cmd+I"), "{paths: [string]}", always, import),
cmd!(
"file.projectSettings",
- "Project Settings…",
+ "Project Settings...",
["File"],
Some("Cmd+Alt+Shift+K"),
"{bitDepth?: 8|16|32, linearize?, timeDisplay?: timecode|frames}",
diff --git a/crates/engine/src/commands/file_more.rs b/crates/engine/src/commands/file_more.rs
new file mode 100644
index 000000000..0180d2798
--- /dev/null
+++ b/crates/engine/src/commands/file_more.rs
@@ -0,0 +1,681 @@
+//! File menu, part two: folders, close, save a copy, import placeholders/solids, New Comp from
+//! Selection, Dependencies (collect / consolidate / remove unused / reduce / find missing),
+//! scripts, footage interpretation, replace/reload footage, reveal in Finder.
+
+use std::collections::{BTreeMap, BTreeSet};
+
+use effectcraft_color::Label;
+use effectcraft_project::{AlphaMode, Comp, Footage, FootageKind, ItemId, ItemKind, LayerSource, Project, Solid};
+use effectcraft_time::{FrameRate, Tick};
+use serde_json::{Value, json};
+
+use super::{CommandSpec, always, bad, f_p, has_comp, has_project_selection, str_p};
+use crate::{EngineError, Result, Session, cmd};
+
+fn has_footage_selection(s: &Session) -> std::result::Result<(), String> {
+ if selected_footage(s).is_empty() { Err("select footage in the Project panel".into()) } else { Ok(()) }
+}
+
+fn has_interpretation(s: &Session) -> std::result::Result<(), String> {
+ has_footage_selection(s)?;
+ if s.state.interpretation.is_none() { Err("no interpretation remembered".into()) } else { Ok(()) }
+}
+
+fn has_items(s: &Session) -> std::result::Result<(), String> {
+ if s.project.items.is_empty() { Err("the project is empty".into()) } else { Ok(()) }
+}
+
+fn has_comp_selection(s: &Session) -> std::result::Result<(), String> {
+ if s.state.project_selection.iter().any(|i| s.project.comp(*i).is_some()) { Ok(()) } else { Err("select compositions in the Project panel".into()) }
+}
+
+/// Selected project items that are footage (or the source of the selected layer).
+fn selected_footage(s: &Session) -> Vec {
+ let mut v: Vec =
+ s.state.project_selection.iter().copied().filter(|i| matches!(s.project.item(*i).map(|x| &x.kind), Some(ItemKind::Footage(_)))).collect();
+ if v.is_empty()
+ && let Some(c) = s.active_comp()
+ {
+ v = s
+ .state
+ .selected_layers
+ .iter()
+ .filter_map(|l| c.layer(*l))
+ .filter_map(|l| if let LayerSource::Footage { item } = l.source { Some(item) } else { None })
+ .collect();
+ }
+ v
+}
+
+fn items_p(s: &Session, p: &Value) -> Vec {
+ match p.get("items").or(p.get("item")) {
+ Some(Value::Array(a)) => a.iter().filter_map(Value::as_u64).map(ItemId).collect(),
+ Some(Value::Number(n)) => n.as_u64().map(ItemId).into_iter().collect(),
+ _ => selected_footage(s),
+ }
+}
+
+fn new_folder(s: &mut Session, p: &Value) -> Result {
+ let name = str_p(p, "name").unwrap_or("Untitled Folder").to_string();
+ let parent = p.get("parent").and_then(Value::as_u64).map(ItemId).filter(|i| s.project.item(*i).is_some_and(|x| x.is_folder()));
+ let id = s.edit("New Folder", None, |proj, st| {
+ let id = proj.add_item(&name, Label::Yellow, parent, ItemKind::Folder);
+ st.project_selection = vec![id];
+ Ok(id)
+ })?;
+ Ok(json!({"item": id.0}))
+}
+
+fn close(s: &mut Session, p: &Value) -> Result {
+ s.execute("comp.close", p.clone())
+}
+
+fn close_project(s: &mut Session, _: &Value) -> Result {
+ s.replace_project(Project::default(), None);
+ Ok(Value::Null)
+}
+
+fn save_copy(s: &mut Session, p: &Value) -> Result {
+ let path = str_p(p, "path").ok_or_else(|| bad("file.saveCopy", "missing `path`"))?;
+ let json = s.project.to_json();
+ s.services.write_file(path, json.as_bytes()).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+ Ok(json!({"path": path, "bytes": json.len()}))
+}
+
+fn rate_of(p: &Value) -> FrameRate {
+ f_p(p, "frameRate").map(FrameRate::from_f64).unwrap_or(FrameRate::FPS_29_97)
+}
+
+fn placeholder_footage(p: &Value) -> Footage {
+ let w = p.get("width").and_then(Value::as_u64).unwrap_or(1920) as u32;
+ let h = p.get("height").and_then(Value::as_u64).unwrap_or(1080) as u32;
+ Footage {
+ path: String::new(),
+ kind: FootageKind::Video,
+ width: w,
+ height: h,
+ pixel_aspect: 1.0,
+ frame_rate: rate_of(p),
+ native_rate: None,
+ duration: Tick::from_seconds_f64(f_p(p, "duration").unwrap_or(30.0)),
+ has_video: true,
+ has_audio: false,
+ alpha: AlphaMode::Straight,
+ premul_color: [0.0; 3],
+ loop_count: 1,
+ codec: "Placeholder".into(),
+ missing: true,
+ sequence: vec![],
+ }
+}
+
+fn import_placeholder(s: &mut Session, p: &Value) -> Result {
+ let name = str_p(p, "name").unwrap_or("Placeholder").to_string();
+ let f = placeholder_footage(p);
+ let id = s.edit("Import Placeholder", None, |proj, st| {
+ let id = proj.add_item(&name, Label::Aqua, None, ItemKind::Footage(f));
+ st.project_selection = vec![id];
+ Ok(id)
+ })?;
+ Ok(json!({"item": id.0}))
+}
+
+fn solid_from(p: &Value, s: &Session) -> Solid {
+ let (cw, ch) = s.active_comp().map(|c| (c.width, c.height)).unwrap_or((1920, 1080));
+ let color = match p.get("color") {
+ Some(Value::String(h)) => effectcraft_color::Rgba::from_hex(h).map(|c| [c.r, c.g, c.b]),
+ Some(Value::Array(a)) => Some([0, 1, 2].map(|i| a.get(i).and_then(Value::as_f64).unwrap_or(0.0) as f32)),
+ _ => None,
+ }
+ .unwrap_or([0.5, 0.5, 0.5]);
+ Solid {
+ color,
+ width: p.get("width").and_then(Value::as_u64).map(|v| v as u32).unwrap_or(cw).max(1),
+ height: p.get("height").and_then(Value::as_u64).map(|v| v as u32).unwrap_or(ch).max(1),
+ pixel_aspect: 1.0,
+ }
+}
+
+fn import_solid(s: &mut Session, p: &Value) -> Result {
+ let so = solid_from(p, s);
+ let name = str_p(p, "name").unwrap_or("Solid").to_string();
+ let id = s.edit("Import Solid", None, |proj, st| {
+ let folder = proj.folder_named("Solids").unwrap_or_else(|| proj.add_item("Solids", Label::Yellow, None, ItemKind::Folder));
+ let id = proj.add_item(&name, Label::Red, Some(folder), ItemKind::Solid(so));
+ st.project_selection = vec![id];
+ Ok(id)
+ })?;
+ Ok(json!({"item": id.0}))
+}
+
+fn new_comp_from_selection(s: &mut Session, p: &Value) -> Result {
+ let items: Vec = s.state.project_selection.iter().copied().filter(|i| s.project.item(*i).is_some_and(|x| !x.is_folder())).collect();
+ if items.is_empty() {
+ return Err(bad("file.newCompFromSelection", "select footage in the Project panel"));
+ }
+ let mut made = vec![];
+ for item in items {
+ let it = s.project.item(item).ok_or(EngineError::NoComp)?.clone();
+ let (w, h) = it.dimensions().unwrap_or((1920, 1080));
+ let rate = it.frame_rate().unwrap_or(FrameRate::FPS_29_97);
+ let dur = it.duration().filter(|d| *d > Tick::ZERO).unwrap_or(Tick::from_seconds_f64(f_p(p, "duration").unwrap_or(10.0)));
+ let name = it.name.rsplit_once('.').map(|(a, _)| a.to_string()).unwrap_or(it.name.clone());
+ let c = Comp::new(w.max(1), h.max(1), rate, dur);
+ let cid = s.edit("New Comp from Selection", None, |proj, st| {
+ let cid = proj.add_item(&name, Label::Sandstone, None, ItemKind::Comp(c.into()));
+ st.project_selection = vec![cid];
+ Ok(cid)
+ })?;
+ s.open_comp(cid);
+ s.execute("layer.addItem", json!({"comp": cid.0, "item": item.0}))?;
+ made.push(cid.0);
+ }
+ Ok(json!({"comps": made}))
+}
+
+// ---------------------------------------------------------------- dependencies
+
+/// Items used (transitively) by `roots`.
+fn used_items(proj: &Project, roots: &[ItemId]) -> BTreeSet {
+ let mut seen = BTreeSet::new();
+ let mut stack: Vec = roots.to_vec();
+ while let Some(i) = stack.pop() {
+ if !seen.insert(i) {
+ continue;
+ }
+ if let Some(c) = proj.comp(i) {
+ stack.extend(c.layers.iter().filter_map(|l| l.source.item()));
+ }
+ // Parent folders stay so the structure is kept.
+ if let Some(parent) = proj.item(i).and_then(|x| x.parent) {
+ stack.push(parent);
+ }
+ }
+ seen
+}
+
+fn referenced_sources(proj: &Project) -> BTreeSet {
+ proj.comps().flat_map(|(_, c)| c.layers.iter().filter_map(|l| l.source.item())).collect()
+}
+
+fn remove_unused(s: &mut Session, _: &Value) -> Result {
+ let used = referenced_sources(&s.project);
+ let n = s.edit("Remove Unused Footage", None, |proj, _| {
+ let before = proj.items.len();
+ proj.items.retain(|id, it| !matches!(it.kind, ItemKind::Footage(_) | ItemKind::Solid(_)) || used.contains(id));
+ Ok(before - proj.items.len())
+ })?;
+ s.sanitize_state();
+ s.toast(format!("Removed {n} unused footage item(s)"));
+ Ok(json!({"removed": n}))
+}
+
+fn consolidate(s: &mut Session, _: &Value) -> Result {
+ // Footage with the same file and interpretation collapses into the first such item.
+ let mut first: BTreeMap = BTreeMap::new();
+ let mut remap: BTreeMap = BTreeMap::new();
+ for (id, it) in &s.project.items {
+ if let ItemKind::Footage(f) = &it.kind
+ && !f.path.is_empty()
+ {
+ let key = serde_json::to_string(f).unwrap_or_default();
+ match first.get(&key) {
+ Some(keep) => {
+ remap.insert(*id, *keep);
+ }
+ None => {
+ first.insert(key, *id);
+ }
+ }
+ }
+ }
+ let n = remap.len();
+ s.edit("Consolidate All Footage", None, |proj, _| {
+ let ids: Vec = proj.comps().map(|(id, _)| *id).collect();
+ for cid in ids {
+ if let Some(c) = proj.comp_mut(cid) {
+ for l in &mut c.layers {
+ if let LayerSource::Footage { item } = &mut l.source
+ && let Some(k) = remap.get(item)
+ {
+ *item = *k;
+ }
+ }
+ }
+ }
+ proj.items.retain(|id, _| !remap.contains_key(id));
+ Ok(())
+ })?;
+ s.sanitize_state();
+ s.toast(format!("Consolidated {n} duplicate footage item(s)"));
+ Ok(json!({"removed": n}))
+}
+
+fn reduce(s: &mut Session, _: &Value) -> Result {
+ let roots: Vec = s.state.project_selection.iter().copied().filter(|i| s.project.comp(*i).is_some()).collect();
+ let keep = used_items(&s.project, &roots);
+ let n = s.edit("Reduce Project", None, |proj, _| {
+ let before = proj.items.len();
+ proj.items.retain(|id, _| keep.contains(id));
+ Ok(before - proj.items.len())
+ })?;
+ s.sanitize_state();
+ s.toast(format!("Removed {n} item(s)"));
+ Ok(json!({"removed": n}))
+}
+
+fn find_missing(s: &mut Session, p: &Value) -> Result {
+ let what = str_p(p, "what").unwrap_or("footage");
+ match what {
+ "footage" => {
+ let ids: Vec = s.project.items.values().filter(|i| matches!(&i.kind, ItemKind::Footage(f) if f.missing)).map(|i| i.id).collect();
+ s.state.project_selection = ids.clone();
+ s.toast(format!("{} missing footage item(s)", ids.len()));
+ Ok(json!({"items": ids.iter().map(|i| i.0).collect::>()}))
+ }
+ "effects" => {
+ let mut found = vec![];
+ for (cid, c) in s.project.comps() {
+ for l in &c.layers {
+ for g in l.effects().into_iter().flat_map(|fx| fx.groups()) {
+ if let effectcraft_project::GroupKind::Effect { effect } = &g.kind
+ && crate::effects::find(effect).is_none()
+ {
+ found.push(json!({"comp": cid.0, "layer": l.id.0, "effect": effect}));
+ }
+ }
+ }
+ }
+ s.toast(format!("{} missing effect(s)", found.len()));
+ Ok(json!({"effects": found}))
+ }
+ "fonts" => {
+ let families = crate::text_families();
+ let mut found = vec![];
+ for (cid, c) in s.project.comps() {
+ for l in &c.layers {
+ if let Some(pr) = l.props.prop("text/sourceText")
+ && let Some(doc) = pr.value.as_text()
+ && !families.iter().any(|f| f.eq_ignore_ascii_case(&doc.font))
+ {
+ found.push(json!({"comp": cid.0, "layer": l.id.0, "font": doc.font}));
+ }
+ }
+ }
+ s.toast(format!("{} layer(s) with missing fonts", found.len()));
+ Ok(json!({"fonts": found}))
+ }
+ w => Err(bad("file.findMissing", format!("what: footage|effects|fonts, not `{w}`"))),
+ }
+}
+
+fn collect_files(s: &mut Session, p: &Value) -> Result {
+ let folder = str_p(p, "folder").ok_or_else(|| bad("file.collectFiles", "missing `folder`"))?.trim_end_matches('/').to_string();
+ let mut proj = (*s.project).clone();
+ let mut copied = 0;
+ let mut errors = vec![];
+ let mut used_names = BTreeSet::new();
+ for it in proj.items.values_mut() {
+ let ItemKind::Footage(f) = &mut it.kind else { continue };
+ if f.path.is_empty() {
+ continue;
+ }
+ let files: Vec = if f.sequence.is_empty() { vec![f.path.clone()] } else { f.sequence.clone() };
+ let mut new_paths = vec![];
+ for src in &files {
+ let mut name = std::path::Path::new(src).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "footage".into());
+ let mut k = 2;
+ while !used_names.insert(name.clone()) {
+ name = format!("{k}_{name}");
+ k += 1;
+ }
+ let dst = format!("{folder}/(Footage)/{name}");
+ match s.services.read_file(src).and_then(|bytes| s.services.write_file(&dst, &bytes)) {
+ Ok(()) => copied += 1,
+ Err(e) => errors.push(format!("{src}: {e}")),
+ }
+ new_paths.push(dst);
+ }
+ if f.sequence.is_empty() {
+ f.path = new_paths.remove(0);
+ } else {
+ f.path = new_paths.first().cloned().unwrap_or_default();
+ f.sequence = new_paths;
+ }
+ }
+ let stem = s
+ .path
+ .as_deref()
+ .and_then(|p| std::path::Path::new(p).file_stem())
+ .map(|n| n.to_string_lossy().to_string())
+ .unwrap_or_else(|| "Untitled Project".into());
+ let out = format!("{folder}/{stem}.ecproj");
+ s.services.write_file(&out, proj.to_json().as_bytes()).map_err(|e| EngineError::Other(format!("cannot write {out}: {e}")))?;
+ s.toast(format!("Collected {copied} file(s) into {folder}"));
+ Ok(json!({"project": out, "copied": copied, "errors": errors}))
+}
+
+// ---------------------------------------------------------------- scripts
+
+/// Run a command script: a JSON array or JSON lines of `{"command": id, "params": {…}}` (also
+/// accepts the control channel's `{"method": "engine.execute", "params": {"id", "params"}}`).
+fn run_script(s: &mut Session, p: &Value) -> Result {
+ let steps: Vec = match (p.get("steps"), str_p(p, "path")) {
+ (Some(Value::Array(a)), _) => a.clone(),
+ (_, Some(path)) => {
+ let bytes = s.services.read_file(path).map_err(|e| EngineError::Other(format!("cannot read {path}: {e}")))?;
+ let text = String::from_utf8_lossy(&bytes).to_string();
+ match serde_json::from_str::(&text) {
+ Ok(Value::Array(a)) => a,
+ _ => text
+ .lines()
+ .map(str::trim)
+ .filter(|l| !l.is_empty() && !l.starts_with("//") && !l.starts_with('#'))
+ .map(|l| serde_json::from_str(l).map_err(|e| bad("file.runScript", format!("{e}: {l}"))))
+ .collect::>>()?,
+ }
+ }
+ _ => return Err(bad("file.runScript", "missing `path` (or inline `steps`)")),
+ };
+ let mut results = vec![];
+ for (i, step) in steps.iter().enumerate() {
+ let (id, params) = match (step.get("command").or(step.get("id")).and_then(Value::as_str), step.get("method").and_then(Value::as_str)) {
+ (Some(id), _) => (id.to_string(), step.get("params").cloned().unwrap_or(json!({}))),
+ (None, Some("engine.execute")) => {
+ let pp = step.get("params").cloned().unwrap_or(json!({}));
+ (pp.get("id").and_then(Value::as_str).unwrap_or_default().to_string(), pp.get("params").cloned().unwrap_or(json!({})))
+ }
+ _ => return Err(bad("file.runScript", format!("step {}: needs `command`", i + 1))),
+ };
+ if id == "file.runScript" {
+ return Err(bad("file.runScript", "scripts can't run scripts"));
+ }
+ let r = s.execute(&id, params).map_err(|e| EngineError::Other(format!("step {} ({id}): {e}", i + 1)))?;
+ results.push(r);
+ }
+ Ok(json!({"steps": results.len(), "results": results}))
+}
+
+// ---------------------------------------------------------------- footage
+
+fn interpret(s: &mut Session, p: &Value) -> Result {
+ let items = items_p(s, p);
+ if items.is_empty() {
+ return Err(bad("file.interpretFootage", "select footage"));
+ }
+ let rate = f_p(p, "frameRate").map(FrameRate::from_f64);
+ let alpha = match str_p(p, "alpha") {
+ Some("straight") => Some(AlphaMode::Straight),
+ Some("premultiplied") => Some(AlphaMode::Premultiplied),
+ Some("ignore") => Some(AlphaMode::Ignore),
+ Some(a) => return Err(bad("file.interpretFootage", format!("alpha: straight|premultiplied|ignore, not `{a}`"))),
+ None => None,
+ };
+ let loops = p.get("loop").and_then(Value::as_u64).map(|v| v.max(1) as u32);
+ let par = f_p(p, "pixelAspect");
+ s.edit("Interpret Footage", None, |proj, _| {
+ for i in &items {
+ if let Some(ItemKind::Footage(f)) = proj.item_mut(*i).map(|x| &mut x.kind) {
+ if let Some(r) = rate {
+ if f.native_rate.is_none() {
+ f.native_rate = Some(f.frame_rate);
+ }
+ f.frame_rate = r;
+ }
+ if let Some(a) = alpha {
+ f.alpha = a;
+ }
+ if let Some(l) = loops {
+ f.loop_count = l;
+ }
+ if let Some(x) = par {
+ f.pixel_aspect = x;
+ }
+ }
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn remember_interpretation(s: &mut Session, p: &Value) -> Result {
+ let item = *items_p(s, p).first().ok_or_else(|| bad("file.rememberInterpretation", "select footage"))?;
+ if let Some(ItemKind::Footage(f)) = s.project.item(item).map(|x| &x.kind) {
+ s.state.interpretation = Some(f.clone());
+ }
+ Ok(Value::Null)
+}
+
+fn apply_interpretation(s: &mut Session, p: &Value) -> Result {
+ let src = s.state.interpretation.clone().ok_or_else(|| bad("file.applyInterpretation", "no interpretation remembered"))?;
+ let items = items_p(s, p);
+ s.edit("Apply Interpretation", None, |proj, _| {
+ for i in &items {
+ if let Some(ItemKind::Footage(f)) = proj.item_mut(*i).map(|x| &mut x.kind) {
+ f.alpha = src.alpha;
+ f.premul_color = src.premul_color;
+ f.pixel_aspect = src.pixel_aspect;
+ f.loop_count = src.loop_count;
+ if src.native_rate.is_some() {
+ if f.native_rate.is_none() {
+ f.native_rate = Some(f.frame_rate);
+ }
+ f.frame_rate = src.frame_rate;
+ }
+ }
+ }
+ Ok(())
+ })?;
+ Ok(json!({"items": items.len()}))
+}
+
+fn replace_footage(s: &mut Session, p: &Value) -> Result {
+ let path = str_p(p, "path").ok_or_else(|| bad("file.replaceFootage", "missing `path`"))?.to_string();
+ let item = *items_p(s, p).first().ok_or_else(|| bad("file.replaceFootage", "select footage"))?;
+ let importer = s.importer.clone().ok_or_else(|| EngineError::Other("media import is not available in this build".into()))?;
+ let f = importer.probe(&path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
+ let name = std::path::Path::new(&path).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or(path.clone());
+ s.edit("Replace Footage", None, |proj, _| {
+ let it = proj.item_mut(item).ok_or_else(|| bad("file.replaceFootage", "no such item"))?;
+ it.name = name;
+ it.kind = ItemKind::Footage(f);
+ retarget_layers(proj, item, |_| LayerSource::Footage { item });
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+/// Point every layer using `item` at a new source kind.
+fn retarget_layers(proj: &mut Project, item: ItemId, src: impl Fn(&LayerSource) -> LayerSource) {
+ let ids: Vec = proj.comps().map(|(id, _)| *id).collect();
+ for cid in ids {
+ if let Some(c) = proj.comp_mut(cid) {
+ for l in &mut c.layers {
+ if l.source.item() == Some(item) {
+ l.source = src(&l.source);
+ }
+ }
+ }
+ }
+}
+
+fn replace_with_placeholder(s: &mut Session, p: &Value) -> Result {
+ let item = *items_p(s, p).first().ok_or_else(|| bad("file.replaceWithPlaceholder", "select footage"))?;
+ let base = match s.project.item(item).map(|x| &x.kind) {
+ Some(ItemKind::Footage(f)) => json!({"width": f.width, "height": f.height, "frameRate": f.frame_rate.as_f64(), "duration": f.duration.seconds()}),
+ _ => json!({}),
+ };
+ let mut merged = base;
+ if let (Some(m), Some(pm)) = (merged.as_object_mut(), p.as_object()) {
+ for (k, v) in pm {
+ m.insert(k.clone(), v.clone());
+ }
+ }
+ let f = placeholder_footage(&merged);
+ s.edit("Replace Footage", None, |proj, _| {
+ let it = proj.item_mut(item).ok_or_else(|| bad("file.replaceWithPlaceholder", "no such item"))?;
+ it.kind = ItemKind::Footage(f);
+ retarget_layers(proj, item, |_| LayerSource::Footage { item });
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn replace_with_solid(s: &mut Session, p: &Value) -> Result {
+ let item = *items_p(s, p).first().ok_or_else(|| bad("file.replaceWithSolid", "select footage"))?;
+ let mut so = solid_from(p, s);
+ if let Some((w, h)) = s.project.item(item).and_then(|x| x.dimensions())
+ && p.get("width").is_none()
+ {
+ so.width = w.max(1);
+ so.height = h.max(1);
+ }
+ s.edit("Replace Footage", None, |proj, _| {
+ let it = proj.item_mut(item).ok_or_else(|| bad("file.replaceWithSolid", "no such item"))?;
+ it.kind = ItemKind::Solid(so);
+ retarget_layers(proj, item, |_| LayerSource::Solid { item });
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn reload(s: &mut Session, p: &Value) -> Result {
+ let items = items_p(s, p);
+ let Some(importer) = s.importer.clone() else { return Err(EngineError::Other("media import is not available in this build".into())) };
+ let mut updates = vec![];
+ for i in &items {
+ if let Some(ItemKind::Footage(f)) = s.project.item(*i).map(|x| &x.kind) {
+ let mut nf = match importer.probe(&f.path) {
+ Ok(n) => n,
+ Err(_) => Footage { missing: true, ..f.clone() },
+ };
+ // Keep the interpretation.
+ nf.alpha = f.alpha;
+ nf.loop_count = f.loop_count;
+ nf.pixel_aspect = f.pixel_aspect;
+ updates.push((*i, nf));
+ }
+ }
+ let n = updates.len();
+ s.edit("Reload Footage", None, |proj, _| {
+ for (i, f) in updates {
+ if let Some(it) = proj.item_mut(i) {
+ it.kind = ItemKind::Footage(f);
+ }
+ }
+ Ok(())
+ })?;
+ s.events.push(crate::Event::PurgeCaches);
+ Ok(json!({"reloaded": n}))
+}
+
+fn reveal_in_finder(s: &mut Session, p: &Value) -> Result {
+ let item = *items_p(s, p).first().ok_or_else(|| bad("file.revealInFinder", "select footage"))?;
+ let path = match s.project.item(item).map(|x| &x.kind) {
+ Some(ItemKind::Footage(f)) if !f.path.is_empty() => f.path.clone(),
+ _ => return Err(bad("file.revealInFinder", "the item is not a file")),
+ };
+ let url = super::layer_menu::folder_url(&path);
+ s.events.push(crate::Event::OpenUrl(url.clone()));
+ Ok(json!({"url": url}))
+}
+
+pub fn specs() -> Vec {
+ vec![
+ cmd!("project.newFolder", "New Folder", ["File", "New"], Some("Cmd+Alt+Shift+N"), "{name?, parent?}", always, new_folder),
+ cmd!("file.close", "Close", ["File"], Some("Cmd+W"), "{comp?}", has_comp, close),
+ cmd!("file.closeProject", "Close Project", ["File"], None, "{}", always, close_project),
+ cmd!("file.saveCopy", "Save a Copy...", ["File", "Save As"], None, "{path}", always, save_copy),
+ cmd!("file.importMultiple", "Multiple Files...", ["File", "Import"], Some("Cmd+Alt+I"), "{paths: [string]}", always, |s, p| s
+ .execute("file.import", p.clone())),
+ cmd!(
+ "file.importPlaceholder",
+ "Placeholder...",
+ ["File", "Import"],
+ None,
+ "{name?, width?, height?, frameRate?, duration? (s)}",
+ always,
+ import_placeholder
+ ),
+ cmd!("file.importSolid", "Solid...", ["File", "Import"], None, "{name?, color?, width?, height?}", always, import_solid),
+ cmd!(
+ "file.newCompFromSelection",
+ "New Comp from Selection...",
+ ["File"],
+ Some("Cmd+Alt+\\"),
+ "{duration? (s, for stills)}",
+ has_project_selection,
+ new_comp_from_selection
+ ),
+ cmd!("file.collectFiles", "Collect Files...", ["File", "Dependencies"], None, "{folder}", has_items, collect_files),
+ cmd!("file.consolidateFootage", "Consolidate All Footage", ["File", "Dependencies"], None, "{}", has_items, consolidate),
+ cmd!("file.removeUnusedFootage", "Remove Unused Footage", ["File", "Dependencies"], None, "{}", has_items, remove_unused),
+ cmd!(
+ "file.reduceProject",
+ "Reduce Project",
+ ["File", "Dependencies"],
+ None,
+ "{} (keeps the selected comps and what they use)",
+ has_comp_selection,
+ reduce
+ ),
+ cmd!("file.findMissing", "Find Missing", [], None, "{what: footage|effects|fonts}", has_items, find_missing),
+ cmd!(
+ "file.runScript",
+ "Run Script File...",
+ ["File", "Scripts"],
+ None,
+ "{path (.jsonl/.json command script) | steps: [{command, params}]}",
+ always,
+ run_script
+ ),
+ cmd!(
+ "file.interpretFootage",
+ "Main...",
+ ["File", "Interpret Footage"],
+ Some("Cmd+Alt+G"),
+ "{items?, frameRate?, alpha?: straight|premultiplied|ignore, loop?, pixelAspect?}",
+ has_footage_selection,
+ interpret
+ ),
+ cmd!(
+ "file.rememberInterpretation",
+ "Remember Interpretation",
+ ["File", "Interpret Footage"],
+ None,
+ "{item?}",
+ has_footage_selection,
+ remember_interpretation
+ ),
+ cmd!(
+ "file.applyInterpretation",
+ "Apply Interpretation",
+ ["File", "Interpret Footage"],
+ Some("Cmd+Alt+V"),
+ "{items?}",
+ has_interpretation,
+ apply_interpretation
+ ),
+ cmd!("file.replaceFootage", "File...", ["File", "Replace Footage"], Some("Cmd+H"), "{path, item?}", has_footage_selection, replace_footage),
+ cmd!(
+ "file.replaceWithPlaceholder",
+ "Placeholder...",
+ ["File", "Replace Footage"],
+ None,
+ "{item?, width?, height?, frameRate?, duration?}",
+ has_footage_selection,
+ replace_with_placeholder
+ ),
+ cmd!(
+ "file.replaceWithSolid",
+ "Solid...",
+ ["File", "Replace Footage"],
+ None,
+ "{item?, color?, width?, height?}",
+ has_footage_selection,
+ replace_with_solid
+ ),
+ cmd!("file.reloadFootage", "Reload Footage", ["File"], Some("Cmd+Alt+L"), "{items?}", has_footage_selection, reload),
+ cmd!("file.revealInFinder", "Reveal in Finder", ["File"], None, "{item?}", has_footage_selection, reveal_in_finder),
+ ]
+}
diff --git a/crates/engine/src/commands/frontend.rs b/crates/engine/src/commands/frontend.rs
new file mode 100644
index 000000000..b344c2a0a
--- /dev/null
+++ b/crates/engine/src/commands/frontend.rs
@@ -0,0 +1,78 @@
+//! Frontend-only commands: viewer zoom/resolution/overlays, panels, workspaces, dialogs and app
+//! chrome. They live in the registry so every menu entry is a command (menus, shortcuts, the
+//! control channel and MCP all see them); running one emits [`crate::Event::Frontend`] and the UI
+//! performs it. Headless sessions accept and ignore them.
+
+use super::{CommandSpec, always, frontend, has_comp, has_layers};
+use crate::cmd;
+
+macro_rules! fe {
+ ($id:literal, $label:literal, [$($m:literal),*], $sc:expr, $params:literal, $en:expr) => {
+ cmd!($id, $label, [$($m),*], $sc, $params, $en, |s, p| frontend(s, $id, p))
+ };
+}
+
+pub fn specs() -> Vec {
+ vec![
+ // Application.
+ fe!("app.about", "About EffectCraft...", [], None, "{}", always),
+ fe!(
+ "app.settings",
+ "Settings...",
+ [],
+ None,
+ "{page?: general|startup|project|composition|previews|appearance|grids|labels|type|import|export|audio|disk|memory|video|3d|scripting}",
+ always
+ ),
+ fe!("app.hide", "Hide EffectCraft", [], None, "{}", always),
+ fe!("app.quit", "Quit EffectCraft", [], Some("Cmd+Q"), "{}", always),
+ fe!("app.commandPalette", "Quick Apply...", ["Edit"], Some("Cmd+Shift+Space"), "{query?}", always),
+ fe!("app.keyboardShortcuts", "Keyboard Shortcuts", ["Edit"], Some("Cmd+Alt+'"), "{}", always),
+ fe!("app.templates", "Templates", [], None, "{kind: renderSettings|outputModule}", always),
+ fe!("app.find", "Find", ["File"], Some("Cmd+F"), "{query?}", always),
+ // Preview.
+ fe!("playback.toggle", "Play Current Preview", ["Composition", "Preview"], Some("Space"), "{}", has_comp),
+ fe!("playback.cacheWhenIdle", "Cache Frames When Idle", ["Composition", "Preview"], None, "{value?}", always),
+ fe!("playback.audio", "Audio", ["Composition", "Preview"], None, "{value?: include audio in previews}", always),
+ // Viewer.
+ fe!("view.zoomIn", "Zoom In", ["View"], Some("."), "{}", has_comp),
+ fe!("view.zoomOut", "Zoom Out", ["View"], Some(","), "{}", has_comp),
+ fe!("view.res.full", "Full", ["View", "Resolution"], Some("Cmd+J"), "{}", has_comp),
+ fe!("view.res.half", "Half", ["View", "Resolution"], Some("Cmd+Shift+J"), "{}", has_comp),
+ fe!("view.res.third", "Third", ["View", "Resolution"], None, "{}", has_comp),
+ fe!("view.res.quarter", "Quarter", ["View", "Resolution"], Some("Cmd+Alt+Shift+J"), "{}", has_comp),
+ fe!("view.rulers", "Show Rulers", ["View"], Some("Cmd+R"), "{value?}", always),
+ fe!("view.panelBackground", "Panel Background Color", [], None, "{color?: black|darkGray|mediumGray|lightGray|white|custom|#hex, pick?: true}", always),
+ fe!("view.guides", "Show Guides", ["View"], Some("Cmd+;"), "{value?}", always),
+ fe!("view.snapToGuides", "Snap to Guides", ["View"], Some("Cmd+Shift+;"), "{value?}", always),
+ fe!("view.lockGuides", "Lock Guides", ["View"], Some("Cmd+Alt+Shift+;"), "{value?}", always),
+ fe!("view.grid", "Show Grid", ["View"], Some("Cmd+'"), "{value?}", always),
+ fe!("view.snapToGrid", "Snap to Grid", ["View"], Some("Cmd+Shift+'"), "{value?}", always),
+ fe!("view.options", "View Options...", ["View"], Some("Cmd+Alt+U"), "{}", has_comp),
+ fe!("view.layerControls", "Show Layer Controls", ["View"], Some("Cmd+Shift+H"), "{value?}", always),
+ fe!("view.fullScreen", "Enter Full Screen", ["View"], Some("Ctrl+Cmd+F"), "{}", always),
+ // Panels and workspaces.
+ fe!(
+ "window.panel",
+ "Show Panel",
+ [],
+ None,
+ "{panel: project|effectControls|composition|layer|timeline|info|audio|preview|effectsPresets|properties|character|paragraph|align|tracker|wiggler|smoother|motionSketch|paint|brushes|renderQueue|flowchart|history|markers|tools}",
+ always
+ ),
+ fe!(
+ "window.workspace",
+ "Workspace",
+ [],
+ None,
+ "{name: Default|Standard|Small Screen|Animation|Effects|Motion Tracking|Paint|Text|Minimal|All Panels}",
+ always
+ ),
+ fe!("window.resetWorkspace", "Reset to Saved Layout", ["Window", "Workspace"], None, "{}", always),
+ fe!("comp.flowchart", "Composition Flowchart", ["Composition"], Some("Cmd+F11"), "{}", always),
+ fe!("comp.miniFlowchart", "Composition Mini-Flowchart", ["Composition"], None, "{}", has_comp),
+ fe!("layer.openLayer", "Open Layer", ["Layer"], None, "{layer?}", has_layers),
+ fe!("effect.manage", "Manage Effects...", ["Effect"], None, "{}", always),
+ fe!("anim.browsePresets", "Browse Presets...", ["Animation"], None, "{}", always),
+ ]
+}
diff --git a/crates/engine/src/commands/help.rs b/crates/engine/src/commands/help.rs
index 4cd9a799a..2ed358b54 100644
--- a/crates/engine/src/commands/help.rs
+++ b/crates/engine/src/commands/help.rs
@@ -16,13 +16,26 @@ fn sibling(s: &mut Session, p: &Value) -> Result {
if str_p(p, "kind") == Some("github") { open(s, links::github_of(&slug)) } else { open(s, links::page_of(&slug)) }
}
+/// Help ▸ EffectCraft Help / Scripting Help / Expression Reference / Effect Reference.
+fn docs(s: &mut Session, p: &Value) -> Result {
+ let page = match str_p(p, "page").unwrap_or("help") {
+ "scripting" => "docs/control-protocol.md",
+ "expressions" => "docs/expressions.md",
+ "effects" => "docs/effects.md",
+ "agents" => "docs/agents.md",
+ _ => "README.md",
+ };
+ open(s, format!("{}/blob/main/{page}", links::GITHUB))
+}
+
pub fn specs() -> Vec {
vec![
- cmd!("help.discord", "Join the ArtCraft Discord…", ["Help"], None, "{}", always, |s, _| open(s, links::DISCORD.into())),
+ cmd!("help.docs", "EffectCraft Help...", [], Some("F1"), "{page?: help|scripting|expressions|effects|agents}", always, docs),
+ cmd!("help.discord", "Join the ArtCraft Discord...", ["Help"], None, "{}", always, |s, _| open(s, links::DISCORD.into())),
cmd!("help.website", "ArtCraft Website", ["Help"], None, "{}", always, |s, _| open(s, links::WEBSITE.into())),
cmd!("help.appPage", "EffectCraft Home Page", ["Help"], None, "{}", always, |s, _| open(s, links::APP_PAGE.into())),
cmd!("help.github", "EffectCraft on GitHub", ["Help"], None, "{}", always, |s, _| open(s, links::GITHUB.into())),
- cmd!("help.reportIssue", "Report an Issue…", ["Help"], None, "{}", always, |s, _| open(s, links::ISSUES.into())),
+ cmd!("help.reportIssue", "Provide Feedback...", ["Help"], None, "{}", always, |s, _| open(s, links::ISSUES.into())),
cmd!(
"help.sibling",
"Other ArtCraft Apps",
diff --git a/crates/engine/src/commands/layer.rs b/crates/engine/src/commands/layer.rs
index 94559f83c..5d9e6a38b 100644
--- a/crates/engine/src/commands/layer.rs
+++ b/crates/engine/src/commands/layer.rs
@@ -942,7 +942,7 @@ fn with_layer(p: &Value, lid: LayerId) -> Value {
pub fn specs() -> Vec {
vec![
cmd!("layer.newText", "Text", ["Layer", "New"], Some("Cmd+Alt+Shift+T"), "{text?, size?, font?, fill?, position? [x,y], justify?}", has_comp, new_text),
- cmd!("layer.newSolid", "Solid…", ["Layer", "New"], Some("Cmd+Y"), "{name?, color? #hex|[r,g,b], width?, height?}", has_comp, new_solid),
+ cmd!("layer.newSolid", "Solid...", ["Layer", "New"], Some("Cmd+Y"), "{name?, color? #hex|[r,g,b], width?, height?}", has_comp, new_solid),
cmd!("layer.newNull", "Null Object", ["Layer", "New"], Some("Cmd+Alt+Shift+Y"), "{name?}", has_comp, new_null),
cmd!(
"layer.newShape",
@@ -954,7 +954,7 @@ pub fn specs() -> Vec {
new_shape
),
cmd!("layer.newAdjustment", "Adjustment Layer", ["Layer", "New"], Some("Cmd+Alt+Y"), "{name?}", has_comp, new_adjustment),
- cmd!("layer.settings", "Layer Settings…", ["Layer"], Some("Cmd+Shift+Y"), "{layer?, name?, color?, width?, height?}", has_layers, layer_settings),
+ cmd!("layer.settings", "Layer Settings...", ["Layer"], Some("Cmd+Shift+Y"), "{layer?, name?, color?, width?, height?}", has_layers, layer_settings),
cmd!("layer.addItem", "Add Footage to Comp", ["File"], Some("Cmd+/"), "{item: id|name, time?}", has_comp, add_item),
cmd!("layer.select", "Select Layers", [], None, "{layers: [id|name|#n], add?, toggle?}", has_comp, select),
cmd!("layer.selectNext", "Select Next Layer", [], Some("Cmd+ArrowDown"), "{add?}", has_comp, select_next),
@@ -990,7 +990,7 @@ pub fn specs() -> Vec {
timing
),
cmd!("layer.arrange", "Arrange", ["Layer", "Arrange"], None, "{layers?, to: front|forward|backward|back, index?}", has_layers, arrange),
- cmd!("layer.precompose", "Pre-compose…", ["Layer"], Some("Cmd+Shift+C"), "{layers?, name?}", has_layers, precompose),
+ cmd!("layer.precompose", "Pre-compose...", ["Layer"], Some("Cmd+Shift+C"), "{layers?, name?}", has_layers, precompose),
cmd!(
"layer.addMask",
"New Mask",
@@ -1022,7 +1022,7 @@ pub fn specs() -> Vec {
cmd!(
"layer.addTextAnimator",
"Animate Text",
- ["Animation"],
+ [],
None,
"{layer?, properties: [position|scale|rotation|opacity|fillColor|tracking|…]}",
has_layers,
diff --git a/crates/engine/src/commands/layer_menu.rs b/crates/engine/src/commands/layer_menu.rs
new file mode 100644
index 000000000..f183e7a05
--- /dev/null
+++ b/crates/engine/src/commands/layer_menu.rs
@@ -0,0 +1,805 @@
+//! Layer menu: quality / sampling / frame blending, switches, transform dialogs, masks on existing
+//! layers, markers, track matte shortcuts, open/reveal, and Keyframe Assistant ▸ Sequence Layers.
+
+use effectcraft_keyframe::{Keyframe, ShapePath, Value as KV};
+use effectcraft_project::{FrameBlend, GroupKind, ItemId, LayerId, LayerSource, Marker, MaskMode, MatteKind, Node, Quality, Sampling, TrackMatte, Uid};
+use effectcraft_time::Tick;
+use serde_json::{Value, json};
+
+use super::{CommandSpec, b_p, bad, comp_id, f_p, frontend, has_comp, has_layers, layer_mut, layer_p, layers_p, merge_p, str_p};
+use crate::{EngineError, Result, Session, cmd};
+
+// ---------------------------------------------------------------- enablement
+
+fn has_masks(s: &Session) -> std::result::Result<(), String> {
+ has_layers(s)?;
+ let c = s.active_comp().ok_or("no composition")?;
+ let any = s.state.selected_layers.iter().filter_map(|l| c.layer(*l)).any(|l| l.masks().is_some_and(|m| !m.children.is_empty()));
+ if any { Ok(()) } else { Err("the selected layers have no masks".into()) }
+}
+
+fn has_markers(s: &Session) -> std::result::Result<(), String> {
+ has_layers(s)?;
+ let c = s.active_comp().ok_or("no composition")?;
+ if s.state.selected_layers.iter().filter_map(|l| c.layer(*l)).any(|l| !l.markers.is_empty()) {
+ Ok(())
+ } else {
+ Err("the selected layers have no markers".into())
+ }
+}
+
+fn has_source_item(s: &Session) -> std::result::Result<(), String> {
+ has_layers(s)?;
+ let c = s.active_comp().ok_or("no composition")?;
+ if s.state.selected_layers.iter().filter_map(|l| c.layer(*l)).any(|l| l.source.item().is_some()) {
+ Ok(())
+ } else {
+ Err("the selected layer has no source item".into())
+ }
+}
+
+fn has_footage_layer(s: &Session) -> std::result::Result<(), String> {
+ has_layers(s)?;
+ let c = s.active_comp().ok_or("no composition")?;
+ let any = s.state.selected_layers.iter().filter_map(|l| c.layer(*l)).any(|l| matches!(l.source, LayerSource::Footage { .. }));
+ if any { Ok(()) } else { Err("select a footage layer".into()) }
+}
+
+fn has_multiple_layers(s: &Session) -> std::result::Result<(), String> {
+ has_comp(s)?;
+ if s.state.selected_layers.len() >= 2 { Ok(()) } else { Err("select two or more layers".into()) }
+}
+
+// ---------------------------------------------------------------- quality / sampling / blending
+
+fn quality(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ let q = match str_p(p, "quality").unwrap_or("best").to_ascii_lowercase().as_str() {
+ "best" => Quality::Best,
+ "draft" => Quality::Draft,
+ "wireframe" => Quality::Wireframe,
+ q => return Err(bad("layer.quality", format!("quality must be best|draft|wireframe, not `{q}`"))),
+ };
+ s.edit("Layer Quality", None, |proj, _| {
+ for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+ l.switches.quality = q;
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn sampling(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ let q = match str_p(p, "sampling").unwrap_or("bilinear").to_ascii_lowercase().as_str() {
+ "bilinear" => Sampling::Bilinear,
+ "bicubic" => Sampling::Bicubic,
+ q => return Err(bad("layer.sampling", format!("sampling must be bilinear|bicubic, not `{q}`"))),
+ };
+ s.edit("Layer Sampling", None, |proj, _| {
+ for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+ l.switches.sampling = q;
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn frame_blending(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ let m = match str_p(p, "mode").unwrap_or("off") {
+ "off" => FrameBlend::Off,
+ "frameMix" => FrameBlend::FrameMix,
+ "pixelMotion" => FrameBlend::PixelMotion,
+ m => return Err(bad("layer.frameBlending", format!("mode must be off|frameMix|pixelMotion, not `{m}`"))),
+ };
+ s.edit("Frame Blending", None, |proj, _| {
+ for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+ l.switches.frame_blend = m;
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+// ---------------------------------------------------------------- switches
+
+fn hide_other_video(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ s.edit("Hide Other Video", None, |proj, _| {
+ for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut() {
+ if !ids.contains(&l.id) && l.source.is_av() {
+ l.switches.video = false;
+ }
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn show_all_video(s: &mut Session, p: &Value) -> Result {
+ let cid = comp_id(s, p)?;
+ s.edit("Show All Video", None, |proj, _| {
+ let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+ // Track mattes stay hidden (their video switch is off by design).
+ let mattes: Vec = c.layers.iter().filter_map(|l| l.track_matte.map(|m| m.layer)).collect();
+ for l in c.layers.iter_mut().filter(|l| !mattes.contains(&l.id)) {
+ l.switches.video = true;
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn unlock_all(s: &mut Session, p: &Value) -> Result {
+ let cid = comp_id(s, p)?;
+ s.edit("Unlock All Layers", None, |proj, _| {
+ for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut() {
+ l.switches.locked = false;
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn expressions(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ let on = b_p(p, "enabled").unwrap_or(true);
+ let n = s.edit(if on { "Enable Expressions" } else { "Disable Expressions" }, None, |proj, _| {
+ let mut n = 0;
+ for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+ l.props.walk_mut(&mut |pr| {
+ if let Some(e) = &mut pr.expr {
+ e.enabled = on;
+ n += 1;
+ }
+ });
+ }
+ Ok(n)
+ })?;
+ Ok(json!({"expressions": n}))
+}
+
+// ---------------------------------------------------------------- transform
+
+fn transform_member(prop: &str) -> Option<&'static str> {
+ Some(match prop {
+ "anchor" | "anchorPoint" => "anchor",
+ "position" => "position",
+ "scale" => "scale",
+ "orientation" => "orientation",
+ "rotation" => "rotation",
+ "opacity" => "opacity",
+ _ => return None,
+ })
+}
+
+fn set_transform(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ let prop = str_p(p, "prop").ok_or_else(|| bad("layer.setTransform", "missing `prop`"))?;
+ let m = transform_member(prop).ok_or_else(|| bad("layer.setTransform", "prop: anchor|position|scale|orientation|rotation|opacity"))?;
+ let v = p.get("value").ok_or_else(|| bad("layer.setTransform", "missing `value`"))?.clone();
+ let t = s.time();
+ let label = match m {
+ "anchor" => "Anchor Point",
+ "position" => "Position",
+ "scale" => "Scale",
+ "orientation" => "Orientation",
+ "rotation" => "Rotation",
+ _ => "Opacity",
+ };
+ s.edit(label, merge_p(p), |proj, _| {
+ for lid in &ids {
+ let l = layer_mut(proj, cid, *lid)?;
+ let lt = l.layer_time(t);
+ let Some(pr) = l.transform_mut().and_then(|tr| tr.get_mut(m)) else { continue };
+ let cur = pr.value_at(lt);
+ // Two numbers for a 3D value keep the current z.
+ let j = match (&cur, &v) {
+ (KV::Vec3(c), Value::Array(a)) if a.len() == 2 => json!([a[0], a[1], c[2]]),
+ _ => v.clone(),
+ };
+ let nv = cur.coerce_json(&j).ok_or_else(|| bad("layer.setTransform", format!("can't use {v} for {label}")))?;
+ pr.set_value_at(lt, nv);
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn center_anchor(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ let t = s.time();
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ let ctx = effectcraft_render::EvalCtx::new(&s.project, cid, comp, t);
+ let mut centers = vec![];
+ for lid in &ids {
+ let Some(l) = comp.layer(*lid) else { continue };
+ if let Some([x0, y0, x1, y1]) = effectcraft_render::content_bounds(&ctx, l) {
+ centers.push((*lid, [(x0 + x1) / 2.0, (y0 + y1) / 2.0]));
+ }
+ }
+ s.edit("Center Anchor Point", None, |proj, _| {
+ for (lid, c) in ¢ers {
+ let l = layer_mut(proj, cid, *lid)?;
+ let lt = l.layer_time(t);
+ let Some(tr) = l.transform_mut() else { continue };
+ let get = |tr: &effectcraft_project::PropGroup, m: &str, d: [f64; 3]| tr.get(m).map(|p| p.value_at(lt).as_vec3()).unwrap_or(d);
+ let anchor = get(tr, "anchor", [0.0; 3]);
+ let scale = get(tr, "scale", [100.0; 3]);
+ let rot = tr.get("rotation").map(|p| p.value_at(lt).as_f64()).unwrap_or(0.0).to_radians();
+ let (dx, dy) = ((c[0] - anchor[0]) * scale[0] / 100.0, (c[1] - anchor[1]) * scale[1] / 100.0);
+ let (sn, cs) = rot.sin_cos();
+ let shift = [dx * cs - dy * sn, dx * sn + dy * cs];
+ if let Some(a) = tr.get_mut("anchor") {
+ a.set_value_at(lt, KV::Vec3([c[0], c[1], anchor[2]]));
+ }
+ if let Some(pos) = tr.get_mut("position") {
+ // Shift every key so the layer stays put over its whole animation.
+ if pos.keys.is_empty() {
+ let v = pos.value.as_vec3();
+ pos.value = KV::Vec3([v[0] + shift[0], v[1] + shift[1], v[2]]);
+ } else {
+ for k in &mut pos.keys {
+ let v = k.value.as_vec3();
+ k.value = KV::Vec3([v[0] + shift[0], v[1] + shift[1], v[2]]);
+ }
+ }
+ }
+ }
+ Ok(())
+ })?;
+ Ok(json!({"layers": centers.len()}))
+}
+
+// ---------------------------------------------------------------- masks
+
+/// Masks the command applies to: `mask` (index / uid / name) on `layer`, else selected masks,
+/// else every mask of the selected layers.
+fn target_masks(s: &Session, p: &Value) -> Result<(ItemId, Vec<(LayerId, Uid)>)> {
+ let (cid, ids) = layers_p(s, p)?;
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ let mut out = vec![];
+ if let Some(m) = p.get("mask") {
+ for lid in &ids {
+ let Some(masks) = comp.layer(*lid).and_then(|l| l.masks()) else { continue };
+ let g = match m {
+ Value::Number(n) => {
+ let n = n.as_u64().unwrap_or(1);
+ masks.children.iter().find(|c| c.uid() == n).or_else(|| masks.children.get(n.saturating_sub(1) as usize))
+ }
+ Value::String(name) => masks.children.iter().find(|c| c.name() == name),
+ _ => None,
+ };
+ if let Some(g) = g {
+ out.push((*lid, g.uid()));
+ }
+ }
+ return Ok((cid, out));
+ }
+ for (lid, uid) in &s.state.selected_props {
+ let Some(masks) = comp.layer(*lid).and_then(|l| l.masks()) else { continue };
+ for g in masks.groups() {
+ if g.uid == *uid || g.find(*uid).is_some() {
+ out.push((*lid, g.uid));
+ }
+ }
+ }
+ if out.is_empty() {
+ for lid in &ids {
+ if let Some(masks) = comp.layer(*lid).and_then(|l| l.masks()) {
+ out.extend(masks.groups().map(|g| (*lid, g.uid)));
+ }
+ }
+ }
+ out.dedup();
+ Ok((cid, out))
+}
+
+fn edit_masks(
+ s: &mut Session,
+ p: &Value,
+ label: &str,
+ mut f: impl FnMut(&mut effectcraft_project::PropGroup, (f64, f64), Tick) -> Result<()>,
+) -> Result {
+ let (cid, targets) = target_masks(s, p)?;
+ if targets.is_empty() {
+ return Err(EngineError::Other("no masks".into()));
+ }
+ let t = s.time();
+ let sizes: Vec<(LayerId, (f64, f64))> = targets
+ .iter()
+ .filter_map(|(lid, _)| s.project.comp(cid)?.layer(*lid).map(|l| (*lid, effectcraft_render::source_size(&s.project, l))))
+ .map(|(l, (w, h))| (l, (w as f64, h as f64)))
+ .collect();
+ let n = targets.len();
+ s.edit(label, merge_p(p), |proj, _| {
+ for (lid, uid) in &targets {
+ let size = sizes.iter().find(|(l, _)| l == lid).map(|x| x.1).unwrap_or((0.0, 0.0));
+ let l = layer_mut(proj, cid, *lid)?;
+ let lt = l.layer_time(t);
+ let Some(g) = l.props.sub_mut("masks").and_then(|m| m.find_group_mut(*uid)) else { continue };
+ f(g, size, lt)?;
+ }
+ Ok(())
+ })?;
+ Ok(json!({"masks": n}))
+}
+
+fn mask_kind(g: &mut effectcraft_project::PropGroup) -> Option<(&mut MaskMode, &mut bool, &mut bool)> {
+ match &mut g.kind {
+ GroupKind::Mask { mode, inverted, locked, .. } => Some((mode, inverted, locked)),
+ _ => None,
+ }
+}
+
+fn mask_set(s: &mut Session, p: &Value) -> Result {
+ let field = str_p(p, "field").ok_or_else(|| bad("layer.mask.set", "missing `field` (feather|opacity|expansion)"))?.to_string();
+ if !matches!(field.as_str(), "feather" | "opacity" | "expansion") {
+ return Err(bad("layer.mask.set", "field: feather|opacity|expansion"));
+ }
+ let v = p.get("value").ok_or_else(|| bad("layer.mask.set", "missing `value`"))?.clone();
+ let label = match field.as_str() {
+ "feather" => "Mask Feather",
+ "opacity" => "Mask Opacity",
+ _ => "Mask Expansion",
+ };
+ edit_masks(s, p, label, |g, _, lt| {
+ let pr = g.get_mut(&field).ok_or_else(|| bad("layer.mask.set", "mask has no such property"))?;
+ let cur = pr.value_at(lt);
+ let j = match (&cur, &v) {
+ (KV::Vec2(_), Value::Number(n)) => json!([n, n]),
+ _ => v.clone(),
+ };
+ let nv = cur.coerce_json(&j).ok_or_else(|| bad("layer.mask.set", format!("can't use {v} for {label}")))?;
+ pr.set_value_at(lt, nv);
+ Ok(())
+ })
+}
+
+fn mask_shape(s: &mut Session, p: &Value) -> Result {
+ let r = p.get("rect").and_then(Value::as_array).filter(|a| a.len() == 4).map(|a| [0, 1, 2, 3].map(|i| a[i].as_f64().unwrap_or(0.0)));
+ let r = r.ok_or_else(|| bad("layer.mask.shape", "missing `rect` [left, top, width, height] (layer px)"))?;
+ let ellipse = str_p(p, "shape") == Some("ellipse");
+ edit_masks(s, p, "Mask Shape", |g, _, lt| {
+ let (cx, cy) = (r[0] + r[2] / 2.0, r[1] + r[3] / 2.0);
+ let path = if ellipse { ShapePath::ellipse([cx, cy], r[2], r[3]) } else { ShapePath::rect([cx, cy], r[2], r[3]) };
+ if let Some(pr) = g.get_mut("path") {
+ pr.set_value_at(lt, KV::Path(path));
+ }
+ Ok(())
+ })
+}
+
+fn mask_reset(s: &mut Session, p: &Value) -> Result {
+ edit_masks(s, p, "Reset Mask", |g, (w, h), _| {
+ let (w, h) = if w > 0.0 { (w, h) } else { (400.0, 300.0) };
+ let reset = |g: &mut effectcraft_project::PropGroup, m: &str, v: KV| {
+ if let Some(pr) = g.get_mut(m) {
+ pr.keys.clear();
+ pr.expr = None;
+ pr.value = v;
+ }
+ };
+ reset(g, "path", KV::Path(ShapePath::rect([w / 2.0, h / 2.0], w, h)));
+ reset(g, "feather", KV::Vec2([0.0, 0.0]));
+ reset(g, "opacity", KV::Scalar(100.0));
+ reset(g, "expansion", KV::Scalar(0.0));
+ if let Some((mode, inv, _)) = mask_kind(g) {
+ *mode = MaskMode::Add;
+ *inv = false;
+ }
+ Ok(())
+ })
+}
+
+fn mask_remove(s: &mut Session, p: &Value) -> Result {
+ let (cid, targets) = target_masks(s, p)?;
+ // Without an explicit `mask`, Remove Mask only removes selected masks (AE), else the first.
+ let selected: Vec<(LayerId, Uid)> = targets
+ .iter()
+ .copied()
+ .filter(|(l, u)| {
+ p.get("mask").is_some()
+ || s.state.selected_props.iter().any(|(sl, su)| {
+ sl == l
+ && (su == u || s.active_comp().and_then(|c| c.layer(*l)).and_then(|ly| ly.props.find_group(*u)).is_some_and(|g| g.find(*su).is_some()))
+ })
+ })
+ .collect();
+ let remove = if selected.is_empty() { targets.into_iter().take(1).collect() } else { selected };
+ remove_masks(s, cid, remove, "Remove Mask")
+}
+
+fn remove_masks(s: &mut Session, cid: ItemId, remove: Vec<(LayerId, Uid)>, label: &str) -> Result {
+ let n = remove.len();
+ s.edit(label, None, |proj, st| {
+ for (lid, uid) in &remove {
+ if let Some(m) = layer_mut(proj, cid, *lid)?.props.sub_mut("masks") {
+ m.children.retain(|c| c.uid() != *uid);
+ }
+ }
+ st.selected_props.retain(|(l, u)| !remove.iter().any(|(rl, ru)| rl == l && ru == u));
+ Ok(())
+ })?;
+ Ok(json!({"removed": n}))
+}
+
+fn mask_remove_all(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ let all: Vec<(LayerId, Uid)> =
+ ids.iter().filter_map(|l| comp.layer(*l)).flat_map(|l| l.masks().into_iter().flat_map(|m| m.groups().map(|g| (l.id, g.uid)))).collect();
+ remove_masks(s, cid, all, "Remove All Masks")
+}
+
+fn mask_mode(s: &mut Session, p: &Value) -> Result {
+ let m =
+ str_p(p, "mode").and_then(MaskMode::from_name).ok_or_else(|| bad("layer.mask.mode", "mode: None|Add|Subtract|Intersect|Lighten|Darken|Difference"))?;
+ edit_masks(s, p, "Mask Mode", |g, _, _| {
+ if let Some((mode, ..)) = mask_kind(g) {
+ *mode = m;
+ }
+ Ok(())
+ })
+}
+
+fn mask_invert(s: &mut Session, p: &Value) -> Result {
+ let v = b_p(p, "value");
+ edit_masks(s, p, "Mask Inverted", |g, _, _| {
+ if let Some((_, inv, _)) = mask_kind(g) {
+ *inv = v.unwrap_or(!*inv);
+ }
+ Ok(())
+ })
+}
+
+fn mask_lock(s: &mut Session, p: &Value) -> Result {
+ let v = b_p(p, "value");
+ edit_masks(s, p, "Mask Locked", |g, _, _| {
+ if let Some((_, _, locked)) = mask_kind(g) {
+ *locked = v.unwrap_or(!*locked);
+ }
+ Ok(())
+ })
+}
+
+fn mask_unlock_all(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ s.edit("Unlock All Masks", None, |proj, _| {
+ for lid in &ids {
+ if let Some(m) = layer_mut(proj, cid, *lid)?.props.sub_mut("masks") {
+ for c in &mut m.children {
+ if let Node::Group(g) = c
+ && let Some((_, _, locked)) = mask_kind(g)
+ {
+ *locked = false;
+ }
+ }
+ }
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn mask_lock_others(s: &mut Session, p: &Value) -> Result {
+ let (cid, keep) = target_masks(s, p)?;
+ let layers: Vec = keep.iter().map(|(l, _)| *l).collect();
+ s.edit("Lock Other Masks", None, |proj, _| {
+ for lid in &layers {
+ if let Some(m) = layer_mut(proj, cid, *lid)?.props.sub_mut("masks") {
+ for c in &mut m.children {
+ let uid = c.uid();
+ if let Node::Group(g) = c
+ && let Some((_, _, locked)) = mask_kind(g)
+ {
+ *locked = !keep.contains(&(*lid, uid));
+ }
+ }
+ }
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+// ---------------------------------------------------------------- markers
+
+fn add_marker(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ if ids.is_empty() {
+ return Err(bad("layer.addMarker", "no layer"));
+ }
+ let t = f_p(p, "time").map(Tick::from_seconds_f64).unwrap_or(s.time());
+ let comment = str_p(p, "comment").unwrap_or_default().to_string();
+ s.edit("Add Marker", None, |proj, _| {
+ for lid in &ids {
+ let l = layer_mut(proj, cid, *lid)?;
+ if l.markers_locked {
+ continue;
+ }
+ // Layer markers are stored in layer time.
+ let lt = l.layer_time(t);
+ l.markers.retain(|m| m.time != lt);
+ l.markers.push(Marker { time: lt, comment: comment.clone(), ..Default::default() });
+ l.markers.sort_by_key(|m| m.time);
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn markers_lock(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ let v = b_p(p, "value");
+ let r = s.edit("Lock Markers", None, |proj, _| {
+ let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+ let target = v.unwrap_or_else(|| !c.layers.iter().find(|l| ids.contains(&l.id)).is_some_and(|l| l.markers_locked));
+ for l in c.layers.iter_mut().filter(|l| ids.contains(&l.id)) {
+ l.markers_locked = target;
+ }
+ Ok(target)
+ })?;
+ Ok(json!(r))
+}
+
+fn delete_all_markers(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ s.edit("Delete All Markers", None, |proj, _| {
+ for l in proj.comp_mut(cid).ok_or(EngineError::NoComp)?.layers.iter_mut().filter(|l| ids.contains(&l.id) && !l.markers_locked) {
+ l.markers.clear();
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+// ---------------------------------------------------------------- track matte
+
+fn track_matte_op(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = layers_p(s, p)?;
+ let op = str_p(p, "op").ok_or_else(|| bad("layer.trackMatte", "missing `op`"))?.to_string();
+ let kind = match op.as_str() {
+ "alpha" => Some(MatteKind::Alpha),
+ "alphaInverted" => Some(MatteKind::AlphaInverted),
+ "luma" => Some(MatteKind::Luma),
+ "lumaInverted" => Some(MatteKind::LumaInverted),
+ "none" | "above" | "below" => None,
+ o => return Err(bad("layer.trackMatte", format!("op: none|alpha|alphaInverted|luma|lumaInverted|above|below, not `{o}`"))),
+ };
+ s.edit("Track Matte", None, |proj, _| {
+ let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+ let order: Vec = c.layers.iter().map(|l| l.id).collect();
+ let mut hide = vec![];
+ for lid in &ids {
+ let i = order.iter().position(|x| x == lid).unwrap_or(0);
+ let l = c.layer_mut(*lid).ok_or(EngineError::NoComp)?;
+ let cur_kind = l.track_matte.map(|m| m.kind).unwrap_or_default();
+ l.track_matte = match op.as_str() {
+ "none" => None,
+ "above" | "below" => {
+ let j = if op == "above" { i.checked_sub(1) } else { Some(i + 1) };
+ match j.and_then(|j| order.get(j)) {
+ Some(m) => Some(TrackMatte { layer: *m, kind: cur_kind }),
+ None => return Err(bad("layer.trackMatte", format!("there is no layer {op}"))),
+ }
+ }
+ _ => match (l.track_matte, i.checked_sub(1).and_then(|j| order.get(j))) {
+ (Some(m), _) => Some(TrackMatte { layer: m.layer, kind: kind.unwrap_or_default() }),
+ (None, Some(above)) => Some(TrackMatte { layer: *above, kind: kind.unwrap_or_default() }),
+ (None, None) => return Err(bad("layer.trackMatte", "the top layer has no layer above to use as a matte")),
+ },
+ };
+ if let Some(m) = l.track_matte {
+ hide.push(m.layer);
+ }
+ }
+ for m in hide {
+ if let Some(ml) = c.layer_mut(m) {
+ ml.switches.video = false;
+ }
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+// ---------------------------------------------------------------- open / reveal
+
+fn source_item(s: &Session, p: &Value, cmd: &str) -> Result {
+ let (cid, lid) = layer_p(s, p, cmd)?;
+ s.project.comp(cid).and_then(|c| c.layer(lid)).and_then(|l| l.source.item()).ok_or_else(|| bad(cmd, "the layer has no source item"))
+}
+
+fn open_source(s: &mut Session, p: &Value) -> Result {
+ let item = source_item(s, p, "layer.openSource")?;
+ if s.project.comp(item).is_some() {
+ s.open_comp(item);
+ return Ok(json!({"comp": item.0}));
+ }
+ frontend(s, "window.panel", &json!({"panel": "layer"}))
+}
+
+/// Folder containing a file as a `file://` URL.
+pub(crate) fn folder_url(path: &str) -> String {
+ let dir = std::path::Path::new(path).parent().map(|d| d.to_string_lossy().to_string()).unwrap_or_default();
+ format!("file://{dir}")
+}
+
+fn reveal_in_finder(s: &mut Session, p: &Value) -> Result {
+ let item = source_item(s, p, "layer.revealInFinder")?;
+ let path = match s.project.item(item).map(|i| &i.kind) {
+ Some(effectcraft_project::ItemKind::Footage(f)) if !f.path.is_empty() => f.path.clone(),
+ _ => return Err(bad("layer.revealInFinder", "the layer's source is not a file")),
+ };
+ let url = folder_url(&path);
+ s.events.push(crate::Event::OpenUrl(url.clone()));
+ Ok(json!({"url": url}))
+}
+
+fn reveal_source(s: &mut Session, p: &Value) -> Result {
+ let item = source_item(s, p, "layer.revealSource")?;
+ s.state.project_selection = vec![item];
+ frontend(s, "window.panel", &json!({"panel": "project"}))?;
+ Ok(json!({"item": item.0}))
+}
+
+fn reveal_comp(s: &mut Session, p: &Value) -> Result {
+ let cid = comp_id(s, p)?;
+ s.state.project_selection = vec![cid];
+ frontend(s, "window.panel", &json!({"panel": "project"}))?;
+ Ok(json!({"item": cid.0}))
+}
+
+fn reveal_expression_errors(s: &mut Session, p: &Value) -> Result {
+ let cid = comp_id(s, p)?;
+ let t = s.time();
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ let mut errors = vec![];
+ for l in &comp.layers {
+ let mut has = vec![];
+ l.props.walk("", &mut |_, pr| {
+ if pr.has_expression() {
+ has.push(pr);
+ }
+ });
+ for pr in has {
+ let text = pr.expr.as_ref().map(|e| e.text.clone()).unwrap_or_default();
+ let err = match &s.expr {
+ Some(host) => {
+ let mut ctx = effectcraft_render::EvalCtx::new(&s.project, cid, comp, t);
+ ctx.expr = Some(host.as_ref());
+ host.eval(&ctx, l, pr, &pr.value_at(l.layer_time(t))).err()
+ }
+ None => None,
+ };
+ if let Some(e) = err {
+ errors.push(json!({"layer": l.id.0, "prop": pr.uid, "name": pr.name, "expression": text, "error": e}));
+ }
+ }
+ }
+ let props: Vec = errors.iter().map(|e| json!({"layer": e["layer"], "prop": e["prop"]})).collect();
+ frontend(s, "timeline.revealProps", &json!({"props": props}))?;
+ if errors.is_empty() {
+ s.toast("No expression errors");
+ }
+ Ok(json!({"errors": errors}))
+}
+
+// ---------------------------------------------------------------- sequence layers
+
+fn sequence(s: &mut Session, p: &Value) -> Result {
+ let cid = comp_id(s, p)?;
+ // Selection order (AE sequences in the order layers were selected).
+ let ids: Vec = match p.get("layers") {
+ Some(_) => layers_p(s, p)?.1,
+ None => s.state.selected_layers.clone(),
+ };
+ if ids.len() < 2 {
+ return Err(bad("layer.sequence", "select two or more layers"));
+ }
+ let overlap = b_p(p, "overlap").unwrap_or(false);
+ let dur = if overlap { Tick::from_seconds_f64(f_p(p, "duration").unwrap_or(1.0)) } else { Tick::ZERO };
+ let transition = str_p(p, "transition").unwrap_or("off").to_string();
+ s.edit("Sequence Layers", None, |proj, _| {
+ let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+ let mut next: Option = None;
+ for (k, lid) in ids.iter().enumerate() {
+ let l = c.layer_mut(*lid).ok_or(EngineError::NoComp)?;
+ if let Some(at) = next {
+ let d = at - l.in_point;
+ l.start_time += d;
+ l.in_point += d;
+ l.out_point += d;
+ }
+ if overlap && transition != "off" {
+ let (a, b) = (l.layer_time(l.in_point), l.layer_time(l.in_point + dur));
+ let (oa, ob) = (l.layer_time(l.out_point - dur), l.layer_time(l.out_point));
+ let last = k + 1 == ids.len();
+ if let Some(op) = l.transform_mut().and_then(|tr| tr.get_mut("opacity")) {
+ op.keys.clear();
+ if k > 0 {
+ op.keys.push(Keyframe::new(a, KV::Scalar(0.0)));
+ op.keys.push(Keyframe::new(b, KV::Scalar(100.0)));
+ }
+ if transition == "crossDissolve" && !last {
+ op.keys.push(Keyframe::new(oa, KV::Scalar(100.0)));
+ op.keys.push(Keyframe::new(ob, KV::Scalar(0.0)));
+ }
+ op.keys.sort_by_key(|k| k.time);
+ op.keys.dedup_by_key(|k| k.time);
+ }
+ }
+ next = Some(l.out_point - dur);
+ }
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+pub fn specs() -> Vec {
+ vec![
+ cmd!("layer.quality", "Quality", [], None, "{layers?, quality: best|draft|wireframe}", has_layers, quality),
+ cmd!("layer.sampling", "Sampling", [], None, "{layers?, sampling: bilinear|bicubic}", has_layers, sampling),
+ cmd!("layer.frameBlending", "Frame Blending", [], None, "{layers?, mode: off|frameMix|pixelMotion}", has_layers, frame_blending),
+ cmd!("layer.hideOtherVideo", "Hide Other Video", ["Layer", "Switches"], Some("Cmd+Alt+Shift+V"), "{layers?}", has_layers, hide_other_video),
+ cmd!("layer.showAllVideo", "Show All Video", ["Layer", "Switches"], None, "{comp?}", has_comp, show_all_video),
+ cmd!("layer.unlockAll", "Unlock All Layers", ["Layer", "Switches"], Some("Cmd+Shift+L"), "{comp?}", has_comp, unlock_all),
+ cmd!("layer.expressions", "Enable/Disable Expressions", [], None, "{layers?, enabled: bool}", has_layers, expressions),
+ cmd!(
+ "layer.setTransform",
+ "Transform Value",
+ [],
+ None,
+ "{layers?, prop: anchor|position|scale|orientation|rotation|opacity, value}",
+ has_layers,
+ set_transform
+ ),
+ cmd!(
+ "layer.centerAnchor",
+ "Center Anchor Point in Layer Content",
+ ["Layer", "Transform"],
+ Some("Cmd+Alt+Home"),
+ "{layers?}",
+ has_layers,
+ center_anchor
+ ),
+ cmd!(
+ "layer.mask.shape",
+ "Mask Shape...",
+ ["Layer", "Mask"],
+ Some("Cmd+Shift+M"),
+ "{layer?, mask?, rect: [x, y, w, h], shape?: rect|ellipse}",
+ has_masks,
+ mask_shape
+ ),
+ cmd!("layer.mask.set", "Mask Settings", [], None, "{layer?, mask?, field: feather|opacity|expansion, value}", has_masks, mask_set),
+ cmd!("layer.mask.reset", "Reset Mask", ["Layer", "Mask"], None, "{layer?, mask?}", has_masks, mask_reset),
+ cmd!("layer.mask.remove", "Remove Mask", ["Layer", "Mask"], None, "{layer?, mask?}", has_masks, mask_remove),
+ cmd!("layer.mask.removeAll", "Remove All Masks", ["Layer", "Mask"], None, "{layers?}", has_masks, mask_remove_all),
+ cmd!("layer.mask.mode", "Mask Mode", [], None, "{layer?, mask?, mode: None|Add|Subtract|Intersect|Lighten|Darken|Difference}", has_masks, mask_mode),
+ cmd!("layer.mask.invert", "Inverted", ["Layer", "Mask"], Some("Cmd+Shift+I"), "{layer?, mask?, value?}", has_masks, mask_invert),
+ cmd!("layer.mask.lock", "Locked", ["Layer", "Mask"], None, "{layer?, mask?, value?}", has_masks, mask_lock),
+ cmd!("layer.mask.unlockAll", "Unlock All Masks", ["Layer", "Mask"], None, "{layers?}", has_masks, mask_unlock_all),
+ cmd!("layer.mask.lockOthers", "Lock Other Masks", ["Layer", "Mask"], None, "{layer?, mask?}", has_masks, mask_lock_others),
+ cmd!("layer.addMarker", "Add Marker", ["Layer", "Markers"], None, "{layers?, time?, comment?}", has_layers, add_marker),
+ cmd!("layer.markersLock", "Lock Markers", ["Layer", "Markers"], None, "{layers?, value?}", has_layers, markers_lock),
+ cmd!("layer.deleteAllMarkers", "Delete All Markers", ["Layer", "Markers"], None, "{layers?}", has_markers, delete_all_markers),
+ cmd!("layer.trackMatte", "Track Matte", [], None, "{layers?, op: none|alpha|alphaInverted|luma|lumaInverted|above|below}", has_layers, track_matte_op),
+ cmd!("layer.openSource", "Open Layer Source", ["Layer"], None, "{layer?}", has_source_item, open_source),
+ cmd!("layer.revealInFinder", "Reveal in Finder", ["Layer"], None, "{layer?}", has_footage_layer, reveal_in_finder),
+ cmd!("layer.revealSource", "Reveal Layer Source in Project", ["Layer", "Reveal"], None, "{layer?}", has_source_item, reveal_source),
+ cmd!("comp.revealInProject", "Reveal Composition in Project", ["Layer", "Reveal"], None, "{comp?}", has_comp, reveal_comp),
+ cmd!("layer.revealExpressionErrors", "Reveal Expression Errors", ["Layer", "Reveal"], None, "{comp?}", has_comp, reveal_expression_errors),
+ cmd!(
+ "layer.sequence",
+ "Sequence Layers...",
+ ["Animation", "Keyframe Assistant"],
+ None,
+ "{layers? (in order), overlap?: bool, duration? (s), transition?: off|dissolveFront|crossDissolve}",
+ has_multiple_layers,
+ sequence
+ ),
+ ]
+}
diff --git a/crates/engine/src/commands/layer_time.rs b/crates/engine/src/commands/layer_time.rs
index 2bc031aac..d8090352f 100644
--- a/crates/engine/src/commands/layer_time.rs
+++ b/crates/engine/src/commands/layer_time.rs
@@ -136,7 +136,7 @@ fn freeze(s: &mut Session, p: &Value, last: bool) -> Result {
(l.id, at.source_time(l).seconds())
})
.collect();
- s.edit(if last { "Freeze on Last Frame" } else { "Freeze Frame" }, None, |proj, _| {
+ s.edit(if last { "Freeze On Last Frame" } else { "Freeze Frame" }, None, |proj, _| {
let mut next = proj.next_id;
let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
for (lid, src) in &now {
@@ -169,7 +169,7 @@ pub fn specs() -> Vec {
vec![
cmd!(
"layer.timeStretch",
- "Time Stretch…",
+ "Time Stretch...",
["Layer", "Time"],
None,
"{layers?, percent?|duration? (s), hold?: in|current|out, op?: reverse}",
@@ -183,6 +183,6 @@ pub fn specs() -> Vec {
}),
cmd!("layer.enableTimeRemap", "Enable Time Remapping", ["Layer", "Time"], Some("Cmd+Alt+T"), "{layers?, value?}", has_layers, enable_time_remap),
cmd!("layer.freezeFrame", "Freeze Frame", ["Layer", "Time"], None, "{layers?}", has_layers, |s, p| freeze(s, p, false)),
- cmd!("layer.freezeOnLastFrame", "Freeze on Last Frame", ["Layer", "Time"], None, "{layers?}", has_layers, |s, p| freeze(s, p, true)),
+ cmd!("layer.freezeOnLastFrame", "Freeze On Last Frame", ["Layer", "Time"], None, "{layers?}", has_layers, |s, p| freeze(s, p, true)),
]
}
diff --git a/crates/engine/src/commands/mask.rs b/crates/engine/src/commands/mask.rs
index 9387055b3..617346c1d 100644
--- a/crates/engine/src/commands/mask.rs
+++ b/crates/engine/src/commands/mask.rs
@@ -254,7 +254,7 @@ pub fn specs() -> Vec {
cmd!("mask.selectVertices", "Select Mask Vertices", [], None, "{vertices: [{layer, mask, index}], add?, toggle?}", has_comp, select_vertices),
cmd!("mask.moveVertices", "Move Mask Vertices", [], None, "{vertices?: [{layer, mask, index}], delta: [dx,dy], merge?}", has_vertices, move_vertices),
cmd!("mask.deleteVertices", "Delete Mask Vertices", [], None, "{vertices?}", has_vertices, delete_vertices),
- cmd!("mask.remove", "Remove Mask", ["Layer", "Mask"], None, "{layer?, mask}", has_layers, |s, p| remove_masks(s, p, false)),
- cmd!("mask.removeAll", "Remove All Masks", ["Layer", "Mask"], None, "{layer?}", has_layers, |s, p| remove_masks(s, p, true)),
+ cmd!("mask.remove", "Remove Mask", [], None, "{layer?, mask}", has_layers, |s, p| remove_masks(s, p, false)),
+ cmd!("mask.removeAll", "Remove All Masks", [], None, "{layer?}", has_layers, |s, p| remove_masks(s, p, true)),
]
}
diff --git a/crates/engine/src/commands/mod.rs b/crates/engine/src/commands/mod.rs
index 4abdc7a8e..1c59d69f7 100644
--- a/crates/engine/src/commands/mod.rs
+++ b/crates/engine/src/commands/mod.rs
@@ -2,20 +2,28 @@
//! shortcut and viewer/timeline gesture maps to one of these.
mod anim;
+mod animation;
mod comp;
+mod comp_more;
mod edit;
mod effect;
mod file;
+mod file_more;
+mod frontend;
mod help;
mod layer;
+mod layer_menu;
mod layer_time;
mod link;
mod mask;
mod prop;
mod query;
mod render_queue;
+mod stubs;
+mod styles;
mod three_d;
mod time;
+mod view;
use std::sync::OnceLock;
@@ -74,6 +82,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(edit::specs());
v.extend(comp::specs());
v.extend(layer::specs());
+ v.extend(styles::specs());
v.extend(three_d::specs());
v.extend(layer_time::specs());
v.extend(prop::specs());
@@ -85,6 +94,13 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(render_queue::specs());
v.extend(help::specs());
v.extend(query::specs());
+ v.extend(layer_menu::specs());
+ v.extend(animation::specs());
+ v.extend(view::specs());
+ v.extend(file_more::specs());
+ v.extend(comp_more::specs());
+ v.extend(frontend::specs());
+ v.extend(stubs::specs());
v
})
}
@@ -169,6 +185,60 @@ pub(crate) fn has_keys(s: &Session) -> std::result::Result<(), String> {
if s.state.selected_keys.is_empty() { Err("select keyframes first".into()) } else { Ok(()) }
}
+pub(crate) fn has_project_selection(s: &Session) -> std::result::Result<(), String> {
+ if s.state.project_selection.is_empty() { Err("select an item in the Project panel first".into()) } else { Ok(()) }
+}
+
+/// Disabled-command enablement (menu entries whose implementation lands with another milestone).
+pub(crate) fn not_yet(_: &Session) -> std::result::Result<(), String> {
+ Err("not available yet in EffectCraft".into())
+}
+
+/// `run` of a not-yet-available command.
+pub(crate) fn not_yet_run(_: &mut Session, _: &Value) -> Result {
+ Err(EngineError::Other("not available yet in EffectCraft".into()))
+}
+
+/// Hand a frontend-only command to the UI ([`crate::Event::Frontend`]).
+pub(crate) fn frontend(s: &mut Session, id: &str, p: &Value) -> Result {
+ s.events.push(crate::Event::Frontend { command: id.to_string(), params: p.clone() });
+ Ok(serde_json::json!({"frontend": id}))
+}
+
+/// Match path of a node (`transform/position`, `effects/#2/blurriness` style with `match#n`
+/// occurrences) so it can be found again on another layer.
+pub fn match_path_of(g: &effectcraft_project::PropGroup, uid: effectcraft_project::Uid) -> Option {
+ for c in &g.children {
+ let nth = g.children.iter().take_while(|x| !std::ptr::eq(*x, c)).filter(|x| x.match_id() == c.match_id()).count() + 1;
+ let seg = if nth == 1 { c.match_id().to_string() } else { format!("{}#{nth}", c.match_id()) };
+ if c.uid() == uid {
+ return Some(seg);
+ }
+ if let effectcraft_project::Node::Group(sub) = c
+ && let Some(rest) = match_path_of(sub, uid)
+ {
+ return Some(format!("{seg}/{rest}"));
+ }
+ }
+ None
+}
+
+/// Selected properties (leaves) of the active comp as (layer, uid); selected groups expand to
+/// their properties.
+pub(crate) fn selected_leaf_props(s: &Session) -> Vec<(LayerId, effectcraft_project::Uid)> {
+ let Some(comp) = s.active_comp() else { return vec![] };
+ let mut out = vec![];
+ for (lid, uid) in &s.state.selected_props {
+ let Some(l) = comp.layer(*lid) else { continue };
+ if l.props.find(*uid).is_some() {
+ out.push((*lid, *uid));
+ } else if let Some(g) = l.props.find_group(*uid) {
+ g.walk("", &mut |_, p| out.push((*lid, p.uid)));
+ }
+ }
+ out
+}
+
// ---------- params ----------
pub(crate) fn bad(cmd: &str, msg: impl Into) -> EngineError {
diff --git a/crates/engine/src/commands/prop.rs b/crates/engine/src/commands/prop.rs
index 1c5313e4a..3164274c5 100644
--- a/crates/engine/src/commands/prop.rs
+++ b/crates/engine/src/commands/prop.rs
@@ -590,7 +590,7 @@ pub fn specs() -> Vec {
cmd!("keys.toggleHold", "Toggle Hold Keyframe", ["Animation"], Some("Cmd+Alt+H"), "{}", has_keys, toggle_hold),
cmd!(
"keys.interpolation",
- "Keyframe Interpolation…",
+ "Keyframe Interpolation...",
["Animation"],
Some("Cmd+Alt+K"),
"{interpolation?: linear|bezier|continuousBezier|autoBezier|hold, in?|out?: linear|bezier|hold, autoBezier?, continuous?, spatial?: linear|bezier|continuousBezier|autoBezier, roving?}",
@@ -599,7 +599,7 @@ pub fn specs() -> Vec {
),
cmd!(
"keys.velocity",
- "Keyframe Velocity…",
+ "Keyframe Velocity...",
["Animation"],
Some("Cmd+Shift+K"),
"{inSpeed?, inInfluence? %, outSpeed?, outInfluence? % (numbers or per-dimension arrays), continuous?}",
diff --git a/crates/engine/src/commands/render_queue.rs b/crates/engine/src/commands/render_queue.rs
index 10c44eb72..ecf01b35d 100644
--- a/crates/engine/src/commands/render_queue.rs
+++ b/crates/engine/src/commands/render_queue.rs
@@ -393,7 +393,7 @@ pub fn specs() -> Vec {
cmd!("renderQueue.setRender", "Render Queue: Render Checkbox", [], None, "{item?|index?, render?: bool (toggles)}", has_items, set_render),
cmd!(
"renderQueue.setRenderSettings",
- "Render Settings…",
+ "Render Settings...",
[],
None,
"{item?|index?, quality?: best|draft, resolution?: full|half|third|quarter|scale, timeSpan?: workArea|comp|custom, start?: s, end?: s, frameRate?: fps|null, motionBlur?: bool, skipExisting?: bool}",
@@ -402,7 +402,7 @@ pub fn specs() -> Vec {
),
cmd!(
"renderQueue.setOutputModule",
- "Output Module Settings…",
+ "Output Module Settings...",
[],
None,
"{item?|index?, format?, channels?: rgb|rgba, quality?: 1-100, bitrate?: kbps, proresProfile?: proxy|lt|standard|hq|4444|4444xq, audio?: auto|on|off, sampleRate?, loop?: bool, output?}",
@@ -411,7 +411,7 @@ pub fn specs() -> Vec {
),
cmd!(
"renderQueue.setOutput",
- "Output To…",
+ "Output To...",
[],
None,
"{item?|index?, path: file path or template like [compName].[fileExtension]}",
diff --git a/crates/engine/src/commands/stubs.rs b/crates/engine/src/commands/stubs.rs
new file mode 100644
index 000000000..40e323ede
--- /dev/null
+++ b/crates/engine/src/commands/stubs.rs
@@ -0,0 +1,100 @@
+//! Menu entries whose implementation is owned by another milestone (3D, render queue/export,
+//! time remapping, pen/mask-vertex editing, motion tracking, layer styles…) or that have no
+//! EffectCraft equivalent yet. They are registered so the menu bar matches After Effects, and are
+//! always disabled. When a feature lands, delete its line here and register the real command
+//! with the same id (the menu tree in `menus.rs` already points at it).
+
+use super::{CommandSpec, not_yet, not_yet_run};
+
+macro_rules! stub {
+ ($id:literal, $label:literal, [$($m:literal),*], $params:literal) => {
+ CommandSpec { id: $id, label: $label, menu: &[$($m),*], shortcut: None, params: $params, enabled: not_yet, run: not_yet_run, journal: true }
+ };
+ ($id:literal, $label:literal, [$($m:literal),*], $sc:literal, $params:literal) => {
+ CommandSpec { id: $id, label: $label, menu: &[$($m),*], shortcut: Some($sc), params: $params, enabled: not_yet, run: not_yet_run, journal: true }
+ };
+}
+
+pub fn specs() -> Vec {
+ vec![
+ // macOS application menu items handled by the OS.
+ stub!("app.hideOthers", "Hide Others", [], "{}"),
+ stub!("app.showAll", "Show All", [], "{}"),
+ // Render queue / export (export milestone).
+ stub!("render.addOutputModule", "Add Output Module", ["Composition"], "{}"),
+ stub!("render.preRender", "Pre-render...", ["Composition"], "{}"),
+ stub!("render.saveCurrentPreview", "Save Current Preview...", ["Composition"], "{path}"),
+ stub!("file.createProxy", "Create Proxy", [], "{kind: still|movie}"),
+ // Proxies (no proxy model yet).
+ stub!("file.setProxy", "File...", ["File", "Set Proxy"], "{path}"),
+ stub!("file.setProxyNone", "None", ["File", "Set Proxy"], "{}"),
+ stub!("file.interpretProxy", "Proxy...", ["File", "Interpret Footage"], "{}"),
+ // Text editing in the viewer.
+ stub!("edit.pasteTextMatchFormatting", "Paste Text and Match Formatting", ["Edit"], "{}"),
+ stub!("edit.pasteTextFormattingOnly", "Paste Text Formatting Only", ["Edit"], "{}"),
+ stub!("keys.selectLabelGroup", "Select Keyframe Label Group", [], "{scope}"),
+ // Layer ▸ New (3D / content-aware fill).
+ stub!("layer.newContentAwareFill", "Content-Aware Fill Layer...", ["Layer", "New"], "{}"),
+ stub!("layer.new3dPrimitive", "3D Primitive", [], "{kind: cube|sphere|plane|torus|cone|cylinder}"),
+ // Mask options not in the mask model yet; pen / vertex editing (timeline milestone).
+ stub!("layer.mask.motionBlur", "Motion Blur", [], "{mode: sameAsLayer|on|off}"),
+ stub!("layer.mask.featherFalloff", "Feather Falloff", [], "{mode: smooth|linear}"),
+ stub!("layer.mask.hideLocked", "Hide Locked Masks", ["Layer", "Mask"], "{}"),
+ stub!("path.rotoBezier", "RotoBezier", ["Layer", "Mask and Shape Path"], "{}"),
+ stub!("path.convertToBezier", "Convert To Bezier Path", ["Layer", "Mask and Shape Path"], "{}"),
+ stub!("path.groupShapes", "Group Shapes", ["Layer", "Mask and Shape Path"], "Cmd+G", "{}"),
+ stub!("path.ungroupShapes", "Ungroup Shapes", ["Layer", "Mask and Shape Path"], "Cmd+Shift+G", "{}"),
+ stub!("path.setFirstVertex", "Set First Vertex", ["Layer", "Mask and Shape Path"], "{}"),
+ stub!("path.freeTransform", "Free Transform Points", ["Layer", "Mask and Shape Path"], "{}"),
+ // Time (timeline milestone).
+ stub!("layer.alignVideoToData", "Align Video to Data", ["Layer", "Time"], "{}"),
+ stub!("layer.environment", "Environment Layer", ["Layer"], "{}"),
+ stub!("layer.updateMarkersFromSource", "Update Markers From Source", ["Layer", "Markers"], "{}"),
+ stub!("layer.create", "Create", [], "{op}"),
+ stub!("layer.autoTrace", "Auto-trace...", ["Layer"], "{}"),
+ stub!("layer.sceneEditDetection", "Scene Edit Detection...", ["Layer"], "{}"),
+ // Cameras / lights / materials / 3D views (3D milestone).
+ stub!("camera.fromView", "Create Camera from 3D View", ["Layer", "Camera"], "{}"),
+ stub!("camera.stereoRig", "Create Stereo 3D Rig", ["Layer", "Camera"], "{}"),
+ stub!("camera.orbitNull", "Create Orbit Null", ["Layer", "Camera"], "{}"),
+ stub!("camera.fromModel", "Create Cameras from 3D Model", ["Layer", "Camera"], "{}"),
+ stub!("camera.linkFocusToPoi", "Link Focus Distance to Point of Interest", ["Layer", "Camera"], "{}"),
+ stub!("camera.linkFocusToLayer", "Link Focus Distance to Layer", ["Layer", "Camera"], "{}"),
+ stub!("camera.setFocusToLayer", "Set Focus Distance to Layer", ["Layer", "Camera"], "{}"),
+ stub!("light.fromModel", "Create Lights from 3D Model", ["Layer", "Light"], "{}"),
+ stub!("light.controlWithCamera", "Control Light with Camera", ["Layer", "Light"], "{}"),
+ stub!("light.environmentBackground", "Create Environment Light Background Layer", ["Layer", "Light"], "{}"),
+ stub!("material.revealSource", "Reveal Material Source in Project", ["Layer", "Material"], "{}"),
+ stub!("material.reset", "Reset Material", ["Layer", "Material"], "{}"),
+ stub!("material.duplicateAssign", "Duplicate and Assign Material", ["Layer", "Material"], "{}"),
+ stub!("view.layout", "Switch View Layout", [], "{views: 1|2|4}"),
+ stub!("view.shareViewOptions", "Share View Options", ["View", "Switch View Layout"], "{}"),
+ stub!("view.3d.default", "Default", ["View", "Switch 3D View"], "{}"),
+ stub!("view.lookAtSelected", "Look at Selected Layers", ["View"], "Cmd+Alt+Shift+\\", "{}"),
+ stub!("view.lookAtAll", "Look at All Layers", ["View"], "{}"),
+ stub!("view.splitLockedViewer", "Split with New Locked Viewer", ["View"], "{}"),
+ stub!("view.res.custom", "Custom...", ["View", "Resolution"], "{}"),
+ // Color management.
+ stub!("view.displayColorManagement", "Use Display Color Management", ["View"], "{}"),
+ stub!("view.simulateOutput", "Simulate Output", [], "{profile}"),
+ // Keyframes / text / tracking.
+ stub!("keys.audioToKeyframes", "Convert Audio to Keyframes", ["Animation", "Keyframe Assistant"], "{}"),
+ stub!("keys.rpfCameraImport", "RPF Camera Import", ["Animation", "Keyframe Assistant"], "{}"),
+ stub!("text.perCharacter3d", "Enable Per-character 3D", ["Animation", "Animate Text"], "{}"),
+ stub!("text.animatorLineAnchor", "Line Anchor", ["Animation", "Animate Text"], "{}"),
+ stub!("text.animatorCharacterValue", "Character Value", ["Animation", "Animate Text"], "{}"),
+ stub!("text.animatorFontAxes", "Variable Font Axes", ["Animation", "Animate Text"], "{}"),
+ stub!("text.addWigglySelector", "Wiggly", ["Animation", "Add Text Selector"], "{}"),
+ stub!("text.addExpressionSelector", "Expression", ["Animation", "Add Text Selector"], "{}"),
+ stub!("track.camera", "Track Camera", ["Animation"], "{}"),
+ stub!("track.warpStabilizer", "Warp Stabilizer VFX", ["Animation"], "{}"),
+ stub!("track.motion", "Track Motion", ["Animation"], "{}"),
+ stub!("track.mask", "Track Mask", ["Animation"], "{}"),
+ stub!("track.property", "Track this Property", ["Animation"], "{}"),
+ // Workspaces and panels that don't exist yet.
+ stub!("window.saveWorkspace", "Save Changes to this Workspace", ["Window", "Workspace"], "{}"),
+ stub!("window.saveWorkspaceAs", "Save as New Workspace...", ["Window", "Workspace"], "{name}"),
+ stub!("window.editWorkspaces", "Edit Workspaces...", ["Window", "Workspace"], "{}"),
+ stub!("window.unavailablePanel", "Panel", [], "{panel}"),
+ ]
+}
diff --git a/crates/engine/src/commands/styles.rs b/crates/engine/src/commands/styles.rs
new file mode 100644
index 000000000..82bbf5eba
--- /dev/null
+++ b/crates/engine/src/commands/styles.rs
@@ -0,0 +1,244 @@
+//! Layer ▸ Layer Styles: add / remove / show styles and the comp's Global Light.
+//!
+//! Styles are property groups under the layer's `layerStyles` group (see
+//! [`effectcraft_project::styles`]); their values are edited with `prop.set` like any other
+//! property (`layerStyles/dropShadow/distance`). Global Light is shared by every layer of a comp:
+//! editing one layer's `layerStyles/blendingOptions/globalLightAngle` updates them all.
+
+use effectcraft_project::build::Ids;
+use effectcraft_project::styles::{self as st, GROUP, STYLES};
+use effectcraft_project::{ItemId, LayerId, Uid};
+use serde_json::{Value, json};
+
+use super::{CommandSpec, b_p, bad, f_p, has_comp, has_layers, layer_mut, layer_p, layers_p, str_p, time_p};
+use crate::{EngineError, Result, Session, cmd};
+
+/// Selected (or given) layers that take layer styles.
+fn style_layers(s: &Session, p: &Value) -> Result<(ItemId, Vec)> {
+ let (cid, ids) = layers_p(s, p)?;
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ Ok((cid, ids.into_iter().filter(|id| comp.layer(*id).is_some_and(|l| l.can_have_styles())).collect()))
+}
+
+fn add_styles(s: &mut Session, p: &Value, cmd: &str, styles: &[&str], enabled: bool, label: &str) -> Result {
+ let (cid, ids) = style_layers(s, p)?;
+ if ids.is_empty() {
+ return Err(bad(cmd, "no layer that takes layer styles (footage, solid, precomp, text or shape layer)"));
+ }
+ let uids = s.edit(label, None, |proj, state| {
+ let gl = proj.comp(cid).ok_or(EngineError::NoComp)?.global_light.clone();
+ let mut out = vec![];
+ let mut sel = vec![];
+ for lid in &ids {
+ let mut next = proj.next_id;
+ let l = layer_mut(proj, cid, *lid)?;
+ for id in styles {
+ let had = l.layer_styles().and_then(|g| g.sub(id)).is_some();
+ let uid = st::add_style(l, &mut Ids(&mut next), id, &gl, enabled).ok_or_else(|| bad(cmd, format!("unknown style `{id}`")))?;
+ // Choosing a style that is already there (e.g. after Show All) switches it on.
+ if had
+ && enabled
+ && let Some(g) = l.props.find_group_mut(uid)
+ {
+ g.enabled = true;
+ }
+ if let Some(g) = l.props.sub_mut(GROUP) {
+ g.enabled = true;
+ }
+ out.push(json!({"layer": lid.0, "style": id, "uid": uid}));
+ sel.push((*lid, uid));
+ }
+ proj.next_id = next;
+ }
+ state.selected_props = sel;
+ Ok(out)
+ })?;
+ Ok(json!({"styles": uids}))
+}
+
+fn add(s: &mut Session, p: &Value) -> Result {
+ let name = str_p(p, "style").ok_or_else(|| bad("layer.style.add", "missing `style` (e.g. dropShadow or \"Drop Shadow\")"))?;
+ let id = st::style_id(name)
+ .ok_or_else(|| bad("layer.style.add", format!("unknown style `{name}`; one of {}", STYLES.iter().map(|s| s.0).collect::>().join(", "))))?;
+ let label = STYLES.iter().find(|s| s.0 == id).map(|s| s.1).unwrap_or(id);
+ add_styles(s, p, "layer.style.add", &[id], true, label)
+}
+
+macro_rules! style_cmd {
+ ($fn:ident, $id:literal) => {
+ fn $fn(s: &mut Session, p: &Value) -> Result {
+ let label = STYLES.iter().find(|x| x.0 == $id).map(|x| x.1).unwrap_or($id);
+ add_styles(s, p, concat!("layer.style.", $id), &[$id], true, label)
+ }
+ };
+}
+style_cmd!(drop_shadow, "dropShadow");
+style_cmd!(inner_shadow, "innerShadow");
+style_cmd!(outer_glow, "outerGlow");
+style_cmd!(inner_glow, "innerGlow");
+style_cmd!(bevel_emboss, "bevelEmboss");
+style_cmd!(satin, "satin");
+style_cmd!(color_overlay, "colorOverlay");
+style_cmd!(gradient_overlay, "gradientOverlay");
+style_cmd!(stroke, "stroke");
+
+/// Show All: every style is added (new ones switched off) so they can be revealed and edited.
+fn show_all(s: &mut Session, p: &Value) -> Result {
+ let all: Vec<&str> = STYLES.iter().map(|s| s.0).collect();
+ add_styles(s, p, "layer.style.showAll", &all, false, "Show All Layer Styles")
+}
+
+fn remove_all(s: &mut Session, p: &Value) -> Result {
+ let (cid, ids) = style_layers(s, p)?;
+ let n = s.edit("Remove All Layer Styles", None, |proj, state| {
+ let mut n = 0;
+ for lid in &ids {
+ let l = layer_mut(proj, cid, *lid)?;
+ if let Some(g) = l.layer_styles() {
+ let gone: Vec = std::iter::once(g.uid).chain(g.groups().map(|x| x.uid)).collect();
+ l.props.children.retain(|c| c.match_id() != GROUP);
+ state.selected_props.retain(|(_, u)| !gone.contains(u));
+ n += 1;
+ }
+ }
+ Ok(n)
+ })?;
+ Ok(json!({"layers": n}))
+}
+
+/// A style group of a layer by match id, display name, uid or the selection.
+fn find_style(s: &Session, p: &Value, cmd: &str) -> Result<(ItemId, LayerId, Uid)> {
+ let (cid, lid) = layer_p(s, p, cmd)?;
+ let layer = s.project.comp(cid).and_then(|c| c.layer(lid)).ok_or(EngineError::NoComp)?;
+ let g = layer.layer_styles().ok_or_else(|| bad(cmd, "the layer has no layer styles"))?;
+ let found = match p.get("style") {
+ Some(Value::Number(n)) => {
+ let n = n.as_u64().unwrap_or(0);
+ if n == g.uid { Some(g.uid) } else { g.groups().find(|x| x.uid == n).map(|x| x.uid) }
+ }
+ Some(Value::String(name)) if name == GROUP || name.eq_ignore_ascii_case("Layer Styles") => Some(g.uid),
+ Some(Value::String(name)) => {
+ let id = st::style_id(name).unwrap_or(name.as_str());
+ g.groups().find(|x| x.match_id == id || x.name.eq_ignore_ascii_case(name)).map(|x| x.uid)
+ }
+ _ => s.state.selected_props.iter().find_map(|(l, u)| (*l == lid).then(|| g.groups().find(|x| x.uid == *u).map(|x| x.uid)).flatten()),
+ }
+ .ok_or_else(|| bad(cmd, "no such layer style"))?;
+ Ok((cid, lid, found))
+}
+
+fn remove(s: &mut Session, p: &Value) -> Result {
+ let (cid, lid, uid) = find_style(s, p, "layer.style.remove")?;
+ s.edit("Remove Layer Style", None, |proj, state| {
+ let l = layer_mut(proj, cid, lid)?;
+ let whole = l.layer_styles().is_some_and(|g| g.uid == uid);
+ if whole {
+ l.props.children.retain(|c| c.match_id() != GROUP);
+ } else if let Some(g) = l.props.sub_mut(GROUP) {
+ if g.sub(st::BLENDING).is_some_and(|b| b.uid == uid) {
+ return Err(bad("layer.style.remove", "Blending Options can't be removed"));
+ }
+ g.children.retain(|c| c.uid() != uid);
+ // The last style gone removes the Layer Styles group, as in AE.
+ if g.children.iter().all(|c| c.match_id() == st::BLENDING) {
+ l.props.children.retain(|c| c.match_id() != GROUP);
+ }
+ }
+ state.selected_props.retain(|(_, u)| *u != uid);
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+/// Eye switch of a style (or of the whole Layer Styles group: `style: "layerStyles"`).
+fn toggle(s: &mut Session, p: &Value) -> Result {
+ let (cid, lid, uid) = find_style(s, p, "layer.style.toggle")?;
+ let v = b_p(p, "value");
+ let r = s.edit("Toggle Layer Style", None, |proj, _| {
+ let g = layer_mut(proj, cid, lid)?.props.find_group_mut(uid).ok_or_else(|| bad("layer.style.toggle", "gone"))?;
+ g.enabled = v.unwrap_or(!g.enabled);
+ Ok(g.enabled)
+ })?;
+ Ok(json!(r))
+}
+
+fn global_light(s: &mut Session, p: &Value) -> Result {
+ let cid = super::comp_id(s, p)?;
+ let (angle, altitude) = (f_p(p, "angle"), f_p(p, "altitude"));
+ if angle.is_none() && altitude.is_none() {
+ let c = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ return Ok(json!({"angle": c.global_light.angle.value.as_f64(), "altitude": c.global_light.altitude.value.as_f64()}));
+ }
+ let t = time_p(s, p, s.project.comp(cid));
+ s.edit("Global Light", super::merge_p(p), |proj, _| {
+ let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+ st::set_global_light(c, angle, altitude, t);
+ Ok(())
+ })?;
+ let c = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ Ok(json!({"angle": c.global_light.angle.value_at(t).as_f64(), "altitude": c.global_light.altitude.value_at(t).as_f64()}))
+}
+
+fn no_psd_styles(s: &Session) -> std::result::Result<(), String> {
+ has_layers(s)?;
+ Err("no Photoshop layer styles to convert (only layers imported from PSD files carry them)".into())
+}
+
+fn convert(_: &mut Session, _: &Value) -> Result {
+ Err(EngineError::Other("no Photoshop layer styles to convert".into()))
+}
+
+fn list(s: &mut Session, p: &Value) -> Result {
+ let (cid, lid) = layer_p(s, p, "layer.style.list")?;
+ let l = s.project.comp(cid).and_then(|c| c.layer(lid)).ok_or(EngineError::NoComp)?;
+ let styles: Vec = l
+ .layer_styles()
+ .map(|g| {
+ g.groups()
+ .filter(|x| x.match_id != st::BLENDING)
+ .map(|x| json!({"style": x.match_id, "name": x.name, "uid": x.uid, "enabled": x.enabled}))
+ .collect()
+ })
+ .unwrap_or_default();
+ Ok(
+ json!({"group": l.layer_styles().map(|g| g.uid), "enabled": l.layer_styles().map(|g| g.enabled), "styles": styles, "available": STYLES.iter().map(|s| json!({"style": s.0, "name": s.1})).collect::>()}),
+ )
+}
+
+pub fn specs() -> Vec {
+ vec![
+ cmd!("layer.style.convertToEditable", "Convert to Editable Styles", ["Layer", "Layer Styles"], None, "{layers?}", no_psd_styles, convert),
+ cmd!("layer.style.showAll", "Show All", ["Layer", "Layer Styles"], None, "{layers?}", has_layers, show_all),
+ cmd!("layer.style.removeAll", "Remove All", ["Layer", "Layer Styles"], None, "{layers?}", has_layers, remove_all),
+ cmd!("layer.style.dropShadow", "Drop Shadow", ["Layer", "Layer Styles"], None, "{layers?}", has_layers, drop_shadow),
+ cmd!("layer.style.innerShadow", "Inner Shadow", ["Layer", "Layer Styles"], None, "{layers?}", has_layers, inner_shadow),
+ cmd!("layer.style.outerGlow", "Outer Glow", ["Layer", "Layer Styles"], None, "{layers?}", has_layers, outer_glow),
+ cmd!("layer.style.innerGlow", "Inner Glow", ["Layer", "Layer Styles"], None, "{layers?}", has_layers, inner_glow),
+ cmd!("layer.style.bevelEmboss", "Bevel and Emboss", ["Layer", "Layer Styles"], None, "{layers?}", has_layers, bevel_emboss),
+ cmd!("layer.style.satin", "Satin", ["Layer", "Layer Styles"], None, "{layers?}", has_layers, satin),
+ cmd!("layer.style.colorOverlay", "Color Overlay", ["Layer", "Layer Styles"], None, "{layers?}", has_layers, color_overlay),
+ cmd!("layer.style.gradientOverlay", "Gradient Overlay", ["Layer", "Layer Styles"], None, "{layers?}", has_layers, gradient_overlay),
+ cmd!("layer.style.stroke", "Stroke", ["Layer", "Layer Styles"], None, "{layers?}", has_layers, stroke),
+ cmd!(
+ "layer.style.add",
+ "Add Layer Style",
+ [],
+ None,
+ "{style: dropShadow|innerShadow|outerGlow|innerGlow|bevelEmboss|satin|colorOverlay|gradientOverlay|stroke (or display name), layers?}",
+ has_layers,
+ add
+ ),
+ cmd!("layer.style.remove", "Remove Layer Style", [], None, "{layer?, style: id|name|uid|layerStyles}", has_layers, remove),
+ cmd!("layer.style.toggle", "Toggle Layer Style", [], None, "{layer?, style: id|name|uid|layerStyles, value?}", has_layers, toggle),
+ cmd!(
+ "layer.style.globalLight",
+ "Global Light",
+ [],
+ None,
+ "{comp?, angle? (deg), altitude? (deg, 0..90), time? (s)} — no values returns the current setting",
+ has_comp,
+ global_light
+ ),
+ crate::query!("layer.style.list", "List Layer Styles", "{layer?}", list),
+ ]
+}
diff --git a/crates/engine/src/commands/three_d.rs b/crates/engine/src/commands/three_d.rs
index 48fca323e..de7331289 100644
--- a/crates/engine/src/commands/three_d.rs
+++ b/crates/engine/src/commands/three_d.rs
@@ -533,7 +533,7 @@ pub fn specs() -> Vec {
vec![
cmd!(
"layer.autoOrient",
- "Auto-Orient…",
+ "Auto-Orient...",
["Layer", "Transform"],
Some("Cmd+Alt+O"),
"{mode: off|alongPath|towardsCamera|towardsPointOfInterest, layers?}",
@@ -542,7 +542,7 @@ pub fn specs() -> Vec {
),
cmd!(
"layer.newLight",
- "Light…",
+ "Light...",
["Layer", "New"],
Some("Cmd+Alt+Shift+L"),
"{kind?: Parallel|Spot|Point|Ambient (default Spot), name?, color?, intensity?, coneAngle?, coneFeather?, falloff?: None|Smooth|Inverse Square Clamped, radius?, falloffDistance?, castsShadows?, shadowDarkness?, shadowDiffusion?, position? [x,y,z], poi? [x,y,z]}",
@@ -551,7 +551,7 @@ pub fn specs() -> Vec {
),
cmd!(
"layer.newCamera",
- "Camera…",
+ "Camera...",
["Layer", "New"],
Some("Cmd+Alt+Shift+C"),
"{name?, type?: oneNode|twoNode (default twoNode), preset?: 15mm|20mm|24mm|28mm|35mm|50mm|80mm|135mm|200mm, zoom?, focalLength? mm, angleOfView? deg, dof?, focusDistance?, aperture?, fStop?, blurLevel?, lockToZoom?, position? [x,y,z], poi? [x,y,z]}",
@@ -560,8 +560,8 @@ pub fn specs() -> Vec {
),
cmd!(
"layer.cameraSettings",
- "Camera Settings…",
- ["Layer"],
+ "Camera Settings...",
+ ["Layer", "Camera"],
None,
"{layer?, name?, type?, preset?, zoom?, focalLength?, angleOfView?, dof?, focusDistance?, aperture?, fStop?, blurLevel?, position?, poi?}",
has_comp,
@@ -569,8 +569,8 @@ pub fn specs() -> Vec {
),
cmd!(
"layer.lightSettings",
- "Light Settings…",
- ["Layer"],
+ "Light Settings...",
+ [],
None,
"{layer?, name?, kind?, color?, intensity?, coneAngle?, coneFeather?, falloff?, radius?, falloffDistance?, castsShadows?, shadowDarkness?, shadowDiffusion?, position?, poi?}",
has_comp,
diff --git a/crates/engine/src/commands/time.rs b/crates/engine/src/commands/time.rs
index df2b7af92..d2971b716 100644
--- a/crates/engine/src/commands/time.rs
+++ b/crates/engine/src/commands/time.rs
@@ -91,7 +91,7 @@ fn go(s: &mut Session, p: &Value) -> Result {
pub fn specs() -> Vec {
vec![
- cmd!("time.set", "Go to Time…", ["View"], Some("Alt+Shift+J"), "{time? (s) | frame? | timecode?}", has_comp, set),
+ cmd!("time.set", "Go to Time...", ["View"], Some("Alt+Shift+J"), "{time? (s) | frame? | timecode?}", has_comp, set),
cmd!("time.nextFrame", "Next Frame", [], Some("PageDown"), "{}", has_comp, |s, _| step(s, &json!({"frames": 1}))),
cmd!("time.previousFrame", "Previous Frame", [], Some("PageUp"), "{}", has_comp, |s, _| step(s, &json!({"frames": -1}))),
cmd!("time.forward10", "Forward 10 Frames", [], Some("Shift+PageDown"), "{}", has_comp, |s, _| step(s, &json!({"frames": 10}))),
diff --git a/crates/engine/src/commands/view.rs b/crates/engine/src/commands/view.rs
new file mode 100644
index 000000000..83b23cd39
--- /dev/null
+++ b/crates/engine/src/commands/view.rs
@@ -0,0 +1,86 @@
+//! View menu commands that change the project (guides) or headless-relevant editor state (the
+//! region of interest).
+
+use effectcraft_project::Guide;
+use serde_json::{Value, json};
+
+use super::{CommandSpec, always, bad, comp_id, f_p, has_comp, str_p};
+use crate::{EngineError, Result, Session, cmd};
+
+fn has_guides(s: &Session) -> std::result::Result<(), String> {
+ has_comp(s)?;
+ if s.active_comp().is_some_and(|c| !c.guides.is_empty()) { Ok(()) } else { Err("the composition has no guides".into()) }
+}
+
+fn add_guide(s: &mut Session, p: &Value) -> Result {
+ let cid = comp_id(s, p)?;
+ let vertical = match str_p(p, "orientation").unwrap_or("vertical") {
+ "vertical" | "v" => true,
+ "horizontal" | "h" => false,
+ o => return Err(bad("view.addGuide", format!("orientation must be vertical or horizontal, not `{o}`"))),
+ };
+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;
+ let position = f_p(p, "position").unwrap_or(if vertical { comp.width as f64 / 2.0 } else { comp.height as f64 / 2.0 });
+ let n = s.edit("Add Guide", None, |proj, _| {
+ let c = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
+ c.guides.push(Guide { vertical, position });
+ Ok(c.guides.len())
+ })?;
+ Ok(json!({"guides": n}))
+}
+
+fn clear_guides(s: &mut Session, p: &Value) -> Result {
+ let cid = comp_id(s, p)?;
+ s.edit("Clear Guides", None, |proj, _| {
+ proj.comp_mut(cid).ok_or(EngineError::NoComp)?.guides.clear();
+ Ok(())
+ })?;
+ Ok(Value::Null)
+}
+
+fn export_guides(s: &mut Session, p: &Value) -> Result {
+ let path = str_p(p, "path").ok_or_else(|| bad("view.exportGuides", "missing `path`"))?;
+ let comp = s.project.comp(comp_id(s, p)?).ok_or(EngineError::NoComp)?;
+ let doc = json!({"effectcraftGuides": 1, "width": comp.width, "height": comp.height, "guides": comp.guides});
+ let text = serde_json::to_string_pretty(&doc).unwrap_or_default();
+ s.services.write_file(path, text.as_bytes()).map_err(|e| EngineError::Other(format!("cannot write {path}: {e}")))?;
+ Ok(json!({"path": path, "guides": comp.guides.len()}))
+}
+
+fn import_guides(s: &mut Session, p: &Value) -> Result {
+ let path = str_p(p, "path").ok_or_else(|| bad("view.importGuides", "missing `path`"))?;
+ let cid = comp_id(s, p)?;
+ let bytes = s.services.read_file(path).map_err(|e| EngineError::Other(format!("cannot read {path}: {e}")))?;
+ let doc: Value = serde_json::from_slice(&bytes).map_err(|e| bad("view.importGuides", format!("not a guides file: {e}")))?;
+ let guides: Vec = serde_json::from_value(doc.get("guides").cloned().unwrap_or(json!([]))).map_err(|e| bad("view.importGuides", e.to_string()))?;
+ let n = guides.len();
+ s.edit("Import Guides", None, |proj, _| {
+ proj.comp_mut(cid).ok_or(EngineError::NoComp)?.guides.extend(guides);
+ Ok(())
+ })?;
+ Ok(json!({"imported": n}))
+}
+
+fn region_of_interest(s: &mut Session, p: &Value) -> Result {
+ s.state.region_of_interest = match p.get("rect") {
+ Some(Value::Array(a)) if a.len() == 4 => {
+ let r = [0, 1, 2, 3].map(|i| a[i].as_f64().unwrap_or(0.0));
+ if r[2] <= 0.0 || r[3] <= 0.0 {
+ return Err(bad("view.setRegionOfInterest", "width and height must be positive"));
+ }
+ Some(r)
+ }
+ _ => None,
+ };
+ Ok(json!(s.state.region_of_interest))
+}
+
+pub fn specs() -> Vec {
+ vec![
+ cmd!("view.addGuide", "Add Guide...", ["View"], None, "{orientation?: vertical|horizontal, position? (comp px)}", has_comp, add_guide),
+ cmd!("view.clearGuides", "Clear Guides", ["View"], None, "{comp?}", has_guides, clear_guides),
+ cmd!("view.importGuides", "Import Guides...", ["View"], None, "{path}", has_comp, import_guides),
+ cmd!("view.exportGuides", "Export Guides...", ["View"], None, "{path}", has_guides, export_guides),
+ cmd!("view.setRegionOfInterest", "Region of Interest", [], None, "{rect?: [x, y, w, h] | null}", always, region_of_interest),
+ ]
+}
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 7dd18722c..6770a5bc7 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -11,6 +11,7 @@
pub mod commands;
pub mod demo;
pub mod links;
+pub mod menus;
pub mod render_queue;
use std::sync::Arc;
@@ -139,18 +140,50 @@ pub struct EditorState {
pub snapping: bool,
/// Last applied effect id (Effect ▸ last effect).
pub last_effect: Option,
+ /// Viewer region of interest `[x, y, w, h]` in comp pixels (Composition ▸ Crop Comp to Region
+ /// of Interest).
+ #[serde(default)]
+ pub region_of_interest: Option<[f64; 4]>,
+ /// Property-link clipboard (Edit ▸ Copy with Property Links / Copy Expression Only).
+ #[serde(skip)]
+ pub link_clipboard: Option,
+ /// File ▸ Interpret Footage ▸ Remember Interpretation.
+ #[serde(skip)]
+ pub interpretation: Option,
/// Viewer 3D view per comp (Active Camera / Front / … / Custom View 3 and edited view cameras).
#[serde(default)]
pub views3d: std::collections::BTreeMap,
}
+/// What Copy with Property Links / Copy Expression Only put on the clipboard.
+#[derive(Clone, Debug, PartialEq)]
+pub enum LinkClip {
+ /// Expressions that link back to the source properties: (match path, expression text).
+ Links { relative: bool, links: Vec<(String, String)> },
+ /// Expressions only: (match path, expression).
+ Expressions(Vec<(String, effectcraft_project::Expression)>),
+}
+
/// Events for frontends (drained each frame).
#[derive(Clone, Debug, PartialEq, Serialize)]
pub enum Event {
- ProjectChanged { revision: u64 },
- Toast { message: String, error: bool },
+ ProjectChanged {
+ revision: u64,
+ },
+ Toast {
+ message: String,
+ error: bool,
+ },
OpenComp(ItemId),
OpenUrl(String),
+ /// A frontend-only command (viewer zoom, panels, dialogs…) ran: the UI performs it. Headless
+ /// sessions ignore these.
+ Frontend {
+ command: String,
+ params: Value,
+ },
+ /// Drop cached frames / renders (Edit ▸ Purge).
+ PurgeCaches,
}
pub struct Session {
@@ -243,6 +276,8 @@ impl Session {
let mut p = (*self.project).clone();
let mut st = self.state.clone();
let r = f(&mut p, &mut st)?;
+ // Layer styles: one Global Light per comp, whichever layer edited it.
+ effectcraft_project::styles::sync_global_light(&before, &mut p);
let same = merge.is_some() && merge.map(str::to_string) == self.history.merge_key;
if !same {
self.history.undo.push((label.to_string(), before));
@@ -419,6 +454,10 @@ mod tests;
#[cfg(test)]
mod tests_3d;
#[cfg(test)]
+mod tests_menu_cmds;
+#[cfg(test)]
+mod tests_styles;
+#[cfg(test)]
mod tests_timeline;
/// Font families available to text layers (bundled + scanned system fonts).
diff --git a/crates/engine/src/menus.rs b/crates/engine/src/menus.rs
new file mode 100644
index 000000000..cac335802
--- /dev/null
+++ b/crates/engine/src/menus.rs
@@ -0,0 +1,925 @@
+//! The menu bar, laid out like After Effects' (same menus, order, submenus, separators and
+//! labels). Every entry runs a registered command (`commands::find`), optionally with bound
+//! parameters (e.g. `layer.setBlendMode {"mode":"Multiply"}`). Frontends render this tree; agents
+//! read it through `ui.menu.list` / the command registry.
+//!
+//! The tree is written in a small indented text format (two spaces per level):
+//!
+//! ```text
+//! Layer top-level menu
+//! Blending Mode submenu (has deeper lines below it)
+//! Multiply | layer.setBlendMode {"mode":"Multiply"}
+//! Next Blending Mode | layer.setBlendMode {"step":1} | Shift+=
+//! --- separator
+//! @effects the effect categories (Effect menu)
+//! [mac] Quit EffectCraft | app.quit only on macOS ([!mac] = everywhere else)
+//! ```
+//!
+//! An entry's shortcut is the command's default shortcut unless the line gives one (needed for
+//! entries with bound parameters). Adobe-service entries (Team Projects, Libraries, Bridge, Media
+//! Encoder, Essential Graphics, Behance, Creative Cloud…) are intentionally absent.
+
+use std::sync::OnceLock;
+
+use serde::Serialize;
+use serde_json::Value;
+
+use crate::Session;
+use crate::commands::{self, CommandSpec};
+
+/// One node of the menu tree.
+#[derive(Clone, Debug, Serialize)]
+#[serde(tag = "type", rename_all = "camelCase")]
+pub enum MenuNode {
+ Item(MenuEntry),
+ Separator,
+ Submenu { label: String, children: Vec },
+}
+
+/// A clickable menu entry.
+#[derive(Clone, Debug, Serialize)]
+pub struct MenuEntry {
+ pub label: String,
+ pub command: String,
+ /// Parameters bound to the entry (`null` = none).
+ #[serde(skip_serializing_if = "Value::is_null")]
+ pub params: Value,
+ pub shortcut: Option,
+}
+
+impl MenuEntry {
+ pub fn spec(&self) -> Option<&'static CommandSpec> {
+ commands::find(&self.command)
+ }
+ pub fn params_or_empty(&self) -> Value {
+ if self.params.is_null() { Value::Object(Default::default()) } else { self.params.clone() }
+ }
+}
+
+/// Top-level menus in order (macOS has the application menu first).
+pub fn top_level() -> Vec<&'static str> {
+ menu_bar()
+ .iter()
+ .filter_map(|n| match n {
+ MenuNode::Submenu { label, .. } => Some(label.as_str()),
+ _ => None,
+ })
+ .collect()
+}
+
+/// The menu bar for this platform.
+pub fn menu_bar() -> &'static [MenuNode] {
+ static BAR: OnceLock> = OnceLock::new();
+ BAR.get_or_init(|| parse(TREE, cfg!(target_os = "macos")).expect("menu tree parses"))
+}
+
+/// Every entry with its submenu path (`["Layer", "Blending Mode"]`), depth first.
+pub fn entries() -> Vec<(Vec, &'static MenuEntry)> {
+ fn rec(nodes: &'static [MenuNode], path: &mut Vec, out: &mut Vec<(Vec, &'static MenuEntry)>) {
+ for n in nodes {
+ match n {
+ MenuNode::Item(e) => out.push((path.clone(), e)),
+ MenuNode::Separator => {}
+ MenuNode::Submenu { label, children } => {
+ path.push(label.clone());
+ rec(children, path, out);
+ path.pop();
+ }
+ }
+ }
+ }
+ let mut out = vec![];
+ rec(menu_bar(), &mut vec![], &mut out);
+ out
+}
+
+/// Check-mark state of an entry (`None` = not a toggle / radio entry). Frontend-only toggles
+/// (rulers, grid…) are answered by the frontend.
+pub fn checked(s: &Session, command: &str, params: &Value) -> Option {
+ let comp = s.active_comp()?;
+ let layer = s.state.selected_layers.first().and_then(|l| comp.layer(*l));
+ let pstr = |k: &str| params.get(k).and_then(Value::as_str);
+ match command {
+ "layer.setBlendMode" => {
+ let want = effectcraft_color::BlendMode::from_name(pstr("mode")?)?;
+ Some(layer?.blend_mode == want)
+ }
+ "layer.setSwitch" => {
+ let l = layer?;
+ let sw = &l.switches;
+ Some(match pstr("switch")? {
+ "shy" => sw.shy,
+ "lock" => sw.locked,
+ "audio" => sw.audio,
+ "video" => sw.video,
+ "solo" => sw.solo,
+ "fx" => sw.effects,
+ "collapse" => sw.collapse,
+ "motionBlur" => sw.motion_blur,
+ "adjustment" => sw.adjustment,
+ "threeD" => sw.three_d,
+ "guide" => sw.guide,
+ "preserveTransparency" => l.preserve_transparency,
+ _ => return None,
+ })
+ }
+ "layer.quality" => {
+ use effectcraft_project::Quality::*;
+ let q = layer?.switches.quality;
+ Some(matches!((pstr("quality")?, q), ("best", Best) | ("draft", Draft) | ("wireframe", Wireframe)))
+ }
+ "layer.sampling" => {
+ use effectcraft_project::Sampling::*;
+ let q = layer?.switches.sampling;
+ Some(matches!((pstr("sampling")?, q), ("bilinear", Bilinear) | ("bicubic", Bicubic)))
+ }
+ "layer.frameBlending" => {
+ use effectcraft_project::FrameBlend::*;
+ let q = layer?.switches.frame_blend;
+ Some(matches!((pstr("mode")?, q), ("off", Off) | ("frameMix", FrameMix) | ("pixelMotion", PixelMotion)))
+ }
+ "layer.trackMatte" => {
+ use effectcraft_project::MatteKind::*;
+ let m = layer?.track_matte;
+ Some(match (pstr("op")?, m) {
+ ("none", None) => true,
+ ("alpha", Some(m)) => m.kind == Alpha,
+ ("alphaInverted", Some(m)) => m.kind == AlphaInverted,
+ ("luma", Some(m)) => m.kind == Luma,
+ ("lumaInverted", Some(m)) => m.kind == LumaInverted,
+ _ => false,
+ })
+ }
+ "layer.markersLock" => Some(layer?.markers_locked),
+ _ => None,
+ }
+}
+
+/// Parse the tree text. `mac` selects `[mac]` / `[!mac]` lines.
+pub fn parse(text: &str, mac: bool) -> Result, String> {
+ struct Line<'a> {
+ depth: usize,
+ body: &'a str,
+ }
+ let mut lines = vec![];
+ // Depth of a skipped (other-platform) line: its whole subtree is skipped too.
+ let mut skip_below: Option = None;
+ for (n, raw) in text.lines().enumerate() {
+ if raw.trim().is_empty() || raw.trim_start().starts_with("//") {
+ continue;
+ }
+ let indent = raw.len() - raw.trim_start().len();
+ if indent % 2 != 0 {
+ return Err(format!("line {}: odd indentation", n + 1));
+ }
+ let depth = indent / 2;
+ match skip_below {
+ Some(d) if depth > d => continue,
+ _ => skip_below = None,
+ }
+ let mut body = raw.trim();
+ let tagged = |tag: &str, keep: bool, body: &mut &str| -> Option {
+ let rest = body.strip_prefix(tag)?;
+ *body = rest;
+ Some(keep)
+ };
+ if let Some(false) = tagged("[mac] ", mac, &mut body).or_else(|| tagged("[!mac] ", !mac, &mut body)) {
+ skip_below = Some(depth);
+ continue;
+ }
+ lines.push(Line { depth, body });
+ }
+ fn build(lines: &[Line], i: &mut usize, depth: usize) -> Result, String> {
+ let mut out = vec![];
+ while *i < lines.len() {
+ let l = &lines[*i];
+ if l.depth < depth {
+ break;
+ }
+ if l.depth > depth {
+ return Err(format!("unexpected indentation at `{}`", l.body));
+ }
+ *i += 1;
+ if l.body == "---" {
+ out.push(MenuNode::Separator);
+ continue;
+ }
+ if l.body == "@effects" {
+ out.extend(effect_categories());
+ continue;
+ }
+ let mut parts = l.body.split(" | ");
+ let label = parts.next().unwrap_or_default().trim().to_string();
+ match parts.next() {
+ Some(cmd) => {
+ let cmd = cmd.trim();
+ let (command, params) = match cmd.split_once(' ') {
+ Some((c, json)) => (c.to_string(), serde_json::from_str(json.trim()).map_err(|e| format!("`{}`: {e}", l.body))?),
+ None => (cmd.to_string(), Value::Null),
+ };
+ // Entries with bound params state their own shortcut; plain entries use the command's.
+ let inherited = if params.is_null() { commands::find(&command).and_then(|c| c.shortcut).map(str::to_string) } else { None };
+ let shortcut = parts.next().map(|s| s.trim().to_string()).or(inherited);
+ out.push(MenuNode::Item(MenuEntry { label, command, params, shortcut }));
+ }
+ None => {
+ let children = build(lines, i, depth + 1)?;
+ if children.is_empty() {
+ return Err(format!("`{label}` has neither a command nor children"));
+ }
+ out.push(MenuNode::Submenu { label, children });
+ }
+ }
+ }
+ Ok(out)
+ }
+ let mut i = 0;
+ build(&lines, &mut i, 0)
+}
+
+/// Effect ▸ category submenus from the effect registry.
+fn effect_categories() -> Vec {
+ let mut cats: Vec<(&str, Vec)> = vec![];
+ for e in crate::effects::registry() {
+ let entry =
+ MenuNode::Item(MenuEntry { label: e.name.into(), command: "effect.apply".into(), params: serde_json::json!({"effect": e.id}), shortcut: None });
+ match cats.iter_mut().find(|(c, _)| *c == e.category) {
+ Some((_, v)) => v.push(entry),
+ None => cats.push((e.category, vec![entry])),
+ }
+ }
+ cats.sort_by_key(|c| c.0.to_ascii_lowercase());
+ for (_, v) in &mut cats {
+ v.sort_by_key(|n| match n {
+ MenuNode::Item(e) => e.label.to_ascii_lowercase(),
+ _ => String::new(),
+ });
+ }
+ cats.into_iter().map(|(c, children)| MenuNode::Submenu { label: c.to_string(), children }).collect()
+}
+
+/// The After Effects menu layout. Labels use "..." like AE's macOS menus.
+pub const TREE: &str = r#"
+[mac] EffectCraft
+ About EffectCraft... | app.about
+ ---
+ Settings...
+ General... | app.settings {"page":"general"} | Cmd+Alt+;
+ Startup & Repair... | app.settings {"page":"startup"}
+ Project... | app.settings {"page":"project"}
+ Composition... | app.settings {"page":"composition"}
+ Previews... | app.settings {"page":"previews"}
+ Appearance... | app.settings {"page":"appearance"}
+ Grids & Guides... | app.settings {"page":"grids"}
+ Labels... | app.settings {"page":"labels"}
+ Type... | app.settings {"page":"type"}
+ Import... | app.settings {"page":"import"}
+ Export... | app.settings {"page":"export"}
+ Audio... | app.settings {"page":"audio"}
+ Disk... | app.settings {"page":"disk"}
+ Memory & CPU... | app.settings {"page":"memory"}
+ Video... | app.settings {"page":"video"}
+ 3D... | app.settings {"page":"3d"}
+ Scripting & Expressions... | app.settings {"page":"scripting"}
+ ---
+ Hide EffectCraft | app.hide
+ Hide Others | app.hideOthers
+ Show All | app.showAll
+ ---
+ Quit EffectCraft | app.quit
+File
+ New
+ New Project | file.newProject
+ New Folder | project.newFolder
+ Open Project... | file.open
+ ---
+ Close | file.close
+ Close Project | file.closeProject
+ Save | file.save
+ Save As
+ Save As... | file.saveAs
+ Save a Copy... | file.saveCopy
+ Increment and Save | file.incrementAndSave
+ Revert | file.revert
+ ---
+ Import
+ File... | file.import
+ Multiple Files... | file.importMultiple
+ Placeholder... | file.importPlaceholder
+ Solid... | file.importSolid
+ Export
+ Add to Render Queue | renderQueue.add
+ ---
+ Find | app.find
+ ---
+ Add Footage to Comp | layer.addItem
+ New Comp from Selection... | file.newCompFromSelection
+ ---
+ Dependencies
+ Collect Files... | file.collectFiles
+ Consolidate All Footage | file.consolidateFootage
+ Remove Unused Footage | file.removeUnusedFootage
+ Reduce Project | file.reduceProject
+ Find Missing Effects | file.findMissing {"what":"effects"}
+ Find Missing Fonts | file.findMissing {"what":"fonts"}
+ Find Missing Footage | file.findMissing {"what":"footage"}
+ ---
+ Scripts
+ Run Script File... | file.runScript
+ ---
+ Create Proxy
+ Still... | file.createProxy {"kind":"still"}
+ Movie... | file.createProxy {"kind":"movie"}
+ Set Proxy
+ File... | file.setProxy
+ None | file.setProxyNone
+ Interpret Footage
+ Main... | file.interpretFootage
+ Proxy... | file.interpretProxy
+ Remember Interpretation | file.rememberInterpretation
+ Apply Interpretation | file.applyInterpretation
+ Replace Footage
+ File... | file.replaceFootage
+ Placeholder... | file.replaceWithPlaceholder
+ Solid... | file.replaceWithSolid
+ Reload Footage | file.reloadFootage
+ Reveal in Finder | file.revealInFinder
+ ---
+ Project Settings... | file.projectSettings
+ [!mac] ---
+ [!mac] Exit | app.quit
+Edit
+ Undo | edit.undo
+ Redo | edit.redo
+ ---
+ Quick Apply... | app.commandPalette
+ ---
+ Cut | edit.cut
+ Copy | edit.copy
+ Copy with Property Links | edit.copyWithPropertyLinks
+ Copy with Relative Property Links | edit.copyWithRelativePropertyLinks
+ Copy Expression Only | edit.copyExpressionOnly
+ Paste | edit.paste
+ Paste Reversed Keyframes | edit.pasteReversedKeyframes
+ Paste Text and Match Formatting | edit.pasteTextMatchFormatting
+ Paste Text Formatting Only | edit.pasteTextFormattingOnly
+ Clear | edit.clear
+ ---
+ Duplicate | edit.duplicate
+ Split Layer | edit.splitLayer
+ Lift Work Area | edit.liftWorkArea
+ Extract Work Area | edit.extractWorkArea
+ Select All | edit.selectAll
+ Deselect All | edit.deselectAll
+ ---
+ Label
+ Select Label Group | edit.selectLabelGroup
+ ---
+ None | edit.label {"label":"None"}
+ Red | edit.label {"label":"Red"}
+ Yellow | edit.label {"label":"Yellow"}
+ Aqua | edit.label {"label":"Aqua"}
+ Pink | edit.label {"label":"Pink"}
+ Lavender | edit.label {"label":"Lavender"}
+ Peach | edit.label {"label":"Peach"}
+ Sea Foam | edit.label {"label":"Sea Foam"}
+ Blue | edit.label {"label":"Blue"}
+ Green | edit.label {"label":"Green"}
+ Purple | edit.label {"label":"Purple"}
+ Orange | edit.label {"label":"Orange"}
+ Brown | edit.label {"label":"Brown"}
+ Fuchsia | edit.label {"label":"Fuchsia"}
+ Cyan | edit.label {"label":"Cyan"}
+ Sandstone | edit.label {"label":"Sandstone"}
+ Dark Green | edit.label {"label":"Dark Green"}
+ ---
+ Edit Label Colors... | app.settings {"page":"labels"}
+ Select Keyframe Label Group
+ On Selected Layers | keys.selectLabelGroup {"scope":"selected"}
+ On All Layers | keys.selectLabelGroup {"scope":"all"}
+ Visible Keyframes on Selected Layers | keys.selectLabelGroup {"scope":"visibleSelected"}
+ Visible Keyframes on All Layers | keys.selectLabelGroup {"scope":"visibleAll"}
+ ---
+ Purge
+ All Cache... | edit.purge {"what":"all"}
+ All Memory & Disk Cache... | edit.purge {"what":"memoryAndDisk"}
+ All Memory | edit.purge {"what":"memory"}
+ All Disk Cache... | edit.purge {"what":"disk"}
+ All 3D Cache... | edit.purge {"what":"3d"}
+ Undo | edit.purgeUndo
+ Image Cache Memory | edit.purge {"what":"image"}
+ Snapshot | edit.purge {"what":"snapshot"}
+ ---
+ Edit Original... | edit.editOriginal
+ ---
+ Templates
+ Render Settings... | app.templates {"kind":"renderSettings"}
+ Output Module... | app.templates {"kind":"outputModule"}
+ Keyboard Shortcuts | app.keyboardShortcuts
+ [!mac] Preferences
+ [!mac] General... | app.settings {"page":"general"} | Cmd+Alt+;
+ [!mac] Startup & Repair... | app.settings {"page":"startup"}
+ [!mac] Project... | app.settings {"page":"project"}
+ [!mac] Composition... | app.settings {"page":"composition"}
+ [!mac] Previews... | app.settings {"page":"previews"}
+ [!mac] Appearance... | app.settings {"page":"appearance"}
+ [!mac] Grids & Guides... | app.settings {"page":"grids"}
+ [!mac] Labels... | app.settings {"page":"labels"}
+ [!mac] Type... | app.settings {"page":"type"}
+ [!mac] Import... | app.settings {"page":"import"}
+ [!mac] Export... | app.settings {"page":"export"}
+ [!mac] Audio... | app.settings {"page":"audio"}
+ [!mac] Disk... | app.settings {"page":"disk"}
+ [!mac] Memory & CPU... | app.settings {"page":"memory"}
+ [!mac] Video... | app.settings {"page":"video"}
+ [!mac] 3D... | app.settings {"page":"3d"}
+ [!mac] Scripting & Expressions... | app.settings {"page":"scripting"}
+Composition
+ New Composition... | comp.new
+ ---
+ Composition Settings... | comp.settings
+ Set Poster Time | comp.setPosterTime
+ Trim Comp to Work Area | comp.trimToWorkArea
+ Crop Comp to Region of Interest | comp.cropToRegionOfInterest
+ Crop Comp to Selected Layer(s) Bounds | comp.cropToLayerBounds
+ ---
+ Add to Render Queue | renderQueue.add
+ Add Output Module | render.addOutputModule
+ ---
+ Preview
+ Play Current Preview | playback.toggle
+ Cache Frames When Idle | playback.cacheWhenIdle
+ Audio | playback.audio
+ Save Frame As
+ File... | comp.saveFrameAs
+ Pre-render... | render.preRender
+ Save Current Preview... | render.saveCurrentPreview
+ ---
+ Responsive Design — Time
+ Create Intro | comp.responsiveTime {"op":"intro"}
+ Create Outro | comp.responsiveTime {"op":"outro"}
+ Create Protected Region from Work Area | comp.responsiveTime {"op":"workArea"}
+ ---
+ Composition Flowchart | comp.flowchart
+ Composition Mini-Flowchart | comp.miniFlowchart
+Layer
+ New
+ Text | layer.newText
+ Solid... | layer.newSolid
+ Light... | layer.newLight
+ Camera... | layer.newCamera
+ Null Object | layer.newNull
+ Shape Layer | layer.newShape
+ Adjustment Layer | layer.newAdjustment
+ Content-Aware Fill Layer... | layer.newContentAwareFill
+ Cube | layer.new3dPrimitive {"kind":"cube"}
+ Sphere | layer.new3dPrimitive {"kind":"sphere"}
+ Plane | layer.new3dPrimitive {"kind":"plane"}
+ Torus | layer.new3dPrimitive {"kind":"torus"}
+ Cone | layer.new3dPrimitive {"kind":"cone"}
+ Cylinder | layer.new3dPrimitive {"kind":"cylinder"}
+ Layer Settings... | layer.settings
+ ---
+ Open Layer | layer.openLayer
+ Open Layer Source | layer.openSource
+ Reveal in Finder | layer.revealInFinder
+ ---
+ Mask
+ New Mask | layer.addMask
+ Mask Shape... | layer.mask.shape
+ Mask Feather... | layer.mask.set {"field":"feather"} | Cmd+Shift+F
+ Mask Opacity... | layer.mask.set {"field":"opacity"}
+ Mask Expansion... | layer.mask.set {"field":"expansion"}
+ Reset Mask | layer.mask.reset
+ Remove Mask | layer.mask.remove
+ Remove All Masks | layer.mask.removeAll
+ Mode
+ None | layer.mask.mode {"mode":"None"}
+ Add | layer.mask.mode {"mode":"Add"}
+ Subtract | layer.mask.mode {"mode":"Subtract"}
+ Intersect | layer.mask.mode {"mode":"Intersect"}
+ Lighten | layer.mask.mode {"mode":"Lighten"}
+ Darken | layer.mask.mode {"mode":"Darken"}
+ Difference | layer.mask.mode {"mode":"Difference"}
+ Inverted | layer.mask.invert
+ Locked | layer.mask.lock
+ Motion Blur
+ Same As Layer | layer.mask.motionBlur {"mode":"sameAsLayer"}
+ On | layer.mask.motionBlur {"mode":"on"}
+ Off | layer.mask.motionBlur {"mode":"off"}
+ Feather Falloff
+ Smooth | layer.mask.featherFalloff {"mode":"smooth"}
+ Linear | layer.mask.featherFalloff {"mode":"linear"}
+ Unlock All Masks | layer.mask.unlockAll
+ Lock Other Masks | layer.mask.lockOthers
+ Hide Locked Masks | layer.mask.hideLocked
+ Mask and Shape Path
+ RotoBezier | path.rotoBezier
+ Closed | mask.setClosed
+ Convert To Bezier Path | path.convertToBezier
+ Group Shapes | path.groupShapes
+ Ungroup Shapes | path.ungroupShapes
+ Set First Vertex | path.setFirstVertex
+ Free Transform Points | path.freeTransform
+ Quality
+ Best | layer.quality {"quality":"best"} | Cmd+U
+ Draft | layer.quality {"quality":"draft"} | Cmd+Shift+U
+ Wireframe | layer.quality {"quality":"wireframe"} | Cmd+Alt+Shift+U
+ ---
+ Bilinear | layer.sampling {"sampling":"bilinear"}
+ Bicubic | layer.sampling {"sampling":"bicubic"}
+ Switches
+ Hide Other Video | layer.hideOtherVideo
+ Show All Video | layer.showAllVideo
+ Unlock All Layers | layer.unlockAll
+ Enable Expressions | layer.expressions {"enabled":true}
+ Disable Expressions | layer.expressions {"enabled":false}
+ ---
+ Shy | layer.setSwitch {"switch":"shy"}
+ Lock | layer.setSwitch {"switch":"lock"} | Cmd+L
+ Audio | layer.setSwitch {"switch":"audio"}
+ Video | layer.setSwitch {"switch":"video"}
+ Solo | layer.setSwitch {"switch":"solo"}
+ Effect | layer.setSwitch {"switch":"fx"}
+ Collapse | layer.setSwitch {"switch":"collapse"}
+ Motion Blur | layer.setSwitch {"switch":"motionBlur"}
+ Adjustment Layer | layer.setSwitch {"switch":"adjustment"}
+ Transform
+ Reset | layer.transform {"op":"reset"}
+ Anchor Point... | layer.setTransform {"prop":"anchor"}
+ Position... | layer.setTransform {"prop":"position"} | Cmd+Shift+P
+ Scale... | layer.setTransform {"prop":"scale"}
+ Orientation... | layer.setTransform {"prop":"orientation"} | Cmd+Alt+Shift+R
+ Rotation... | layer.setTransform {"prop":"rotation"} | Cmd+Shift+R
+ Opacity... | layer.setTransform {"prop":"opacity"} | Cmd+Shift+O
+ ---
+ Flip Horizontal | layer.transform {"op":"flipH"}
+ Flip Vertical | layer.transform {"op":"flipV"}
+ Center In View | layer.transform {"op":"center"}
+ Center Anchor Point in Layer Content | layer.centerAnchor
+ Fit to Comp | layer.transform {"op":"fit"} | Cmd+Alt+F
+ Fit to Comp Width | layer.transform {"op":"fitWidth"} | Cmd+Alt+Shift+H
+ Fit to Comp Height | layer.transform {"op":"fitHeight"} | Cmd+Alt+Shift+G
+ ---
+ Auto-Orient... | layer.autoOrient
+ Time
+ Enable Time Remapping | layer.enableTimeRemap
+ Time-Reverse Layer | layer.timeReverse
+ Time Stretch... | layer.timeStretch
+ Freeze Frame | layer.freezeFrame
+ Freeze On Last Frame | layer.freezeOnLastFrame
+ Align Video to Data | layer.alignVideoToData
+ Frame Blending
+ Off | layer.frameBlending {"mode":"off"}
+ Frame Mix | layer.frameBlending {"mode":"frameMix"}
+ Pixel Motion | layer.frameBlending {"mode":"pixelMotion"}
+ 3D Layer | layer.setSwitch {"switch":"threeD"}
+ Guide Layer | layer.setSwitch {"switch":"guide"}
+ Environment Layer | layer.environment
+ Markers
+ Add Marker | layer.addMarker
+ Update Markers From Source | layer.updateMarkersFromSource
+ Lock Markers | layer.markersLock
+ Delete All Markers | layer.deleteAllMarkers
+ ---
+ Preserve Transparency | layer.setSwitch {"switch":"preserveTransparency"}
+ Blending Mode
+ Normal | layer.setBlendMode {"mode":"Normal"}
+ Dissolve | layer.setBlendMode {"mode":"Dissolve"}
+ Dancing Dissolve | layer.setBlendMode {"mode":"Dancing Dissolve"}
+ ---
+ Darken | layer.setBlendMode {"mode":"Darken"}
+ Multiply | layer.setBlendMode {"mode":"Multiply"}
+ Color Burn | layer.setBlendMode {"mode":"Color Burn"}
+ Classic Color Burn | layer.setBlendMode {"mode":"Classic Color Burn"}
+ Linear Burn | layer.setBlendMode {"mode":"Linear Burn"}
+ Darker Color | layer.setBlendMode {"mode":"Darker Color"}
+ ---
+ Add | layer.setBlendMode {"mode":"Add"}
+ Lighten | layer.setBlendMode {"mode":"Lighten"}
+ Screen | layer.setBlendMode {"mode":"Screen"}
+ Color Dodge | layer.setBlendMode {"mode":"Color Dodge"}
+ Classic Color Dodge | layer.setBlendMode {"mode":"Classic Color Dodge"}
+ Linear Dodge | layer.setBlendMode {"mode":"Linear Dodge"}
+ Lighter Color | layer.setBlendMode {"mode":"Lighter Color"}
+ ---
+ Overlay | layer.setBlendMode {"mode":"Overlay"}
+ Soft Light | layer.setBlendMode {"mode":"Soft Light"}
+ Hard Light | layer.setBlendMode {"mode":"Hard Light"}
+ Linear Light | layer.setBlendMode {"mode":"Linear Light"}
+ Vivid Light | layer.setBlendMode {"mode":"Vivid Light"}
+ Pin Light | layer.setBlendMode {"mode":"Pin Light"}
+ Hard Mix | layer.setBlendMode {"mode":"Hard Mix"}
+ ---
+ Difference | layer.setBlendMode {"mode":"Difference"}
+ Classic Difference | layer.setBlendMode {"mode":"Classic Difference"}
+ Exclusion | layer.setBlendMode {"mode":"Exclusion"}
+ Subtract | layer.setBlendMode {"mode":"Subtract"}
+ Divide | layer.setBlendMode {"mode":"Divide"}
+ ---
+ Hue | layer.setBlendMode {"mode":"Hue"}
+ Saturation | layer.setBlendMode {"mode":"Saturation"}
+ Color | layer.setBlendMode {"mode":"Color"}
+ Luminosity | layer.setBlendMode {"mode":"Luminosity"}
+ ---
+ Stencil Alpha | layer.setBlendMode {"mode":"Stencil Alpha"}
+ Stencil Luma | layer.setBlendMode {"mode":"Stencil Luma"}
+ Silhouette Alpha | layer.setBlendMode {"mode":"Silhouette Alpha"}
+ Silhouette Luma | layer.setBlendMode {"mode":"Silhouette Luma"}
+ ---
+ Alpha Add | layer.setBlendMode {"mode":"Alpha Add"}
+ Luminescent Premul | layer.setBlendMode {"mode":"Luminescent Premul"}
+ Next Blending Mode | layer.setBlendMode {"step":1} | Shift+=
+ Previous Blending Mode | layer.setBlendMode {"step":-1} | Shift+-
+ Track Matte
+ No Track Matte | layer.trackMatte {"op":"none"}
+ Alpha Matte | layer.trackMatte {"op":"alpha"}
+ Alpha Inverted Matte | layer.trackMatte {"op":"alphaInverted"}
+ Luma Matte | layer.trackMatte {"op":"luma"}
+ Luma Inverted Matte | layer.trackMatte {"op":"lumaInverted"}
+ ---
+ Matte with Layer Above | layer.trackMatte {"op":"above"}
+ Matte with Layer Below | layer.trackMatte {"op":"below"}
+ Layer Styles
+ Convert to Editable Styles | layer.style.convertToEditable
+ Show All | layer.style.showAll
+ Remove All | layer.style.removeAll
+ ---
+ Drop Shadow | layer.style.dropShadow
+ Inner Shadow | layer.style.innerShadow
+ Outer Glow | layer.style.outerGlow
+ Inner Glow | layer.style.innerGlow
+ Bevel and Emboss | layer.style.bevelEmboss
+ Satin | layer.style.satin
+ Color Overlay | layer.style.colorOverlay
+ Gradient Overlay | layer.style.gradientOverlay
+ Stroke | layer.style.stroke
+ ---
+ Arrange
+ Bring Layer to Front | layer.arrange {"to":"front"} | Cmd+Shift+]
+ Bring Layer Forward | layer.arrange {"to":"forward"} | Cmd+]
+ Send Layer Backward | layer.arrange {"to":"backward"} | Cmd+[
+ Send Layer to Back | layer.arrange {"to":"back"} | Cmd+Shift+[
+ ---
+ Reveal
+ Reveal in Finder | layer.revealInFinder
+ Reveal Layer Source in Project | layer.revealSource
+ Reveal Layer in Project Flowchart | comp.flowchart
+ Reveal Composition in Project | comp.revealInProject
+ Reveal Expression Errors | layer.revealExpressionErrors
+ Create
+ Convert to Editable Text | layer.create {"op":"editableText"}
+ Create Shapes from Text | layer.create {"op":"shapesFromText"}
+ Create Masks from Text | layer.create {"op":"masksFromText"}
+ Create Shapes from Vector Layer | layer.create {"op":"shapesFromVector"}
+ Create Keyframes from Data | layer.create {"op":"keyframesFromData"}
+ Null Controllers for Positional Points | layer.create {"op":"nullsPositional"}
+ Null Controllers for Path Points | layer.create {"op":"nullsPathPoints"}
+ Nulls Following Path Points | layer.create {"op":"nullsFollowing"}
+ Null Tracing Along Path | layer.create {"op":"nullTracing"}
+ Create 3D Layer Instance | layer.create {"op":"instance3d"}
+ ---
+ Camera
+ Create Camera from 3D View | camera.fromView
+ Create Stereo 3D Rig | camera.stereoRig
+ Create Orbit Null | camera.orbitNull
+ Create Cameras from 3D Model | camera.fromModel
+ Link Focus Distance to Point of Interest | camera.linkFocusToPoi
+ Link Focus Distance to Layer | camera.linkFocusToLayer
+ Set Focus Distance to Layer | camera.setFocusToLayer
+ Camera Settings... | layer.cameraSettings
+ Reset 3D View | view.reset3DView
+ Light
+ Create Lights from 3D Model | light.fromModel
+ Control Light with Camera | light.controlWithCamera
+ Create Environment Light Background Layer | light.environmentBackground
+ Material
+ Reveal Material Source in Project | material.revealSource
+ Reset Material | material.reset
+ Duplicate and Assign Material | material.duplicateAssign
+ Auto-trace... | layer.autoTrace
+ Pre-compose... | layer.precompose
+ Scene Edit Detection... | layer.sceneEditDetection
+Effect
+ Effect Controls | window.panel {"panel":"effectControls"} | F3
+ Last Effect | effect.applyLast
+ Remove All | effect.removeAll
+ ---
+ Manage Effects... | effect.manage
+ ---
+ @effects
+Animation
+ Save Animation Preset... | anim.savePreset
+ Apply Animation Preset... | anim.applyPreset
+ Browse Presets... | anim.browsePresets
+ ---
+ Add Keyframe | anim.addKeyframe
+ Toggle Hold Keyframe | keys.toggleHold
+ Keyframe Interpolation... | keys.interpolation
+ Keyframe Velocity... | keys.velocity
+ Keyframe Assistant
+ Convert Audio to Keyframes | keys.audioToKeyframes
+ Convert Expression to Keyframes | prop.convertExpressionToKeyframes
+ Create Keyframes from Data | layer.create {"op":"keyframesFromData"}
+ Easy Ease | keys.easyEase
+ Easy Ease In | keys.easyEaseIn
+ Easy Ease Out | keys.easyEaseOut
+ Exponential Scale | keys.exponentialScale
+ Null Controllers for Path Points | layer.create {"op":"nullsPathPoints"}
+ Null Controllers for Positional Points | layer.create {"op":"nullsPositional"}
+ Null Tracing Along Path | layer.create {"op":"nullTracing"}
+ Nulls Following Path Points | layer.create {"op":"nullsFollowing"}
+ RPF Camera Import | keys.rpfCameraImport
+ Sequence Layers... | layer.sequence
+ Time-Reverse Keyframes | keys.timeReverse
+ ---
+ Animate Text
+ Enable Per-character 3D | text.perCharacter3d
+ ---
+ Anchor Point | layer.addTextAnimator {"properties":["anchor"]}
+ Position | layer.addTextAnimator {"properties":["position"]}
+ Scale | layer.addTextAnimator {"properties":["scale"]}
+ Skew | layer.addTextAnimator {"properties":["skew"]}
+ Rotation | layer.addTextAnimator {"properties":["rotation"]}
+ Opacity | layer.addTextAnimator {"properties":["opacity"]}
+ ---
+ All Transform Properties | layer.addTextAnimator {"properties":["anchor","position","scale","skew","rotation","opacity"]}
+ ---
+ Fill Color | layer.addTextAnimator {"properties":["fillColor"]}
+ Stroke Color | layer.addTextAnimator {"properties":["strokeColor"]}
+ Stroke Width | layer.addTextAnimator {"properties":["strokeWidth"]}
+ ---
+ Tracking | layer.addTextAnimator {"properties":["tracking"]}
+ Line Anchor | text.animatorLineAnchor
+ Line Spacing | layer.addTextAnimator {"properties":["lineSpacing"]}
+ ---
+ Character Offset | layer.addTextAnimator {"properties":["characterOffset"]}
+ Character Value | text.animatorCharacterValue
+ ---
+ Blur | layer.addTextAnimator {"properties":["blur"]}
+ Variable Font Axes | text.animatorFontAxes
+ Add Text Selector
+ Range | text.addSelector {"kind":"range"}
+ Wiggly | text.addWigglySelector
+ Expression | text.addExpressionSelector
+ Remove All Text Animators | text.removeAllAnimators
+ ---
+ Add Expression | prop.setExpression
+ Separate Dimensions | prop.separateDimensions
+ Track Camera | track.camera
+ Warp Stabilizer VFX | track.warpStabilizer
+ Track Motion | track.motion
+ Track Mask | track.mask
+ Track this Property | track.property
+ ---
+ Reveal Properties with Keyframes | anim.reveal {"kind":"keyframes"} | U
+ Reveal Properties with Animation | anim.reveal {"kind":"animation"}
+ Reveal All Modified Properties | anim.reveal {"kind":"modified"}
+View
+ Split with New Locked Viewer | view.splitLockedViewer
+ ---
+ Zoom In | view.zoomIn
+ Zoom Out | view.zoomOut
+ ---
+ Resolution
+ Full | view.res.full
+ Half | view.res.half
+ Third | view.res.third
+ Quarter | view.res.quarter
+ Custom... | view.res.custom
+ ---
+ Use Display Color Management | view.displayColorManagement
+ Simulate Output
+ No Output Simulation | view.simulateOutput {"profile":"none"}
+ HDTV (Rec. 709) | view.simulateOutput {"profile":"rec709"}
+ SDTV NTSC | view.simulateOutput {"profile":"ntsc"}
+ SDTV PAL | view.simulateOutput {"profile":"pal"}
+ Legacy Macintosh RGB (Gamma 1.8) | view.simulateOutput {"profile":"mac18"}
+ Internet Standard RGB (sRGB) | view.simulateOutput {"profile":"srgb"}
+ Custom... | view.simulateOutput {"profile":"custom"}
+ ---
+ Show Rulers | view.rulers
+ Panel Background Color
+ Black | view.panelBackground {"color":"black"}
+ Dark Gray | view.panelBackground {"color":"darkGray"}
+ Medium Gray (Default) | view.panelBackground {"color":"mediumGray"}
+ Light Gray | view.panelBackground {"color":"lightGray"}
+ White | view.panelBackground {"color":"white"}
+ ---
+ Custom | view.panelBackground {"color":"custom"}
+ Select Custom Background Color... | view.panelBackground {"pick":true}
+ ---
+ Show Guides | view.guides
+ Snap to Guides | view.snapToGuides
+ Lock Guides | view.lockGuides
+ Add Guide... | view.addGuide
+ Clear Guides | view.clearGuides
+ Import Guides... | view.importGuides
+ Export Guides... | view.exportGuides
+ ---
+ Show Grid | view.grid
+ Snap to Grid | view.snapToGrid
+ ---
+ View Options... | view.options
+ Show Layer Controls | view.layerControls
+ ---
+ Camera Settings... | layer.cameraSettings
+ Reset 3D View | view.reset3DView
+ Create Camera from 3D View | camera.fromView
+ Switch View Layout
+ 1 View | view.layout {"views":1}
+ 2 Views | view.layout {"views":2}
+ 4 Views | view.layout {"views":4}
+ ---
+ Share View Options | view.shareViewOptions
+ Switch 3D View
+ Active Camera | view.3d.activeCamera
+ Default | view.3d.default
+ ---
+ Front | view.3d.front
+ Left | view.3d.left
+ Top | view.3d.top
+ Back | view.3d.back
+ Right | view.3d.right
+ Bottom | view.3d.bottom
+ ---
+ Custom View 1 | view.3d.custom1
+ Custom View 2 | view.3d.custom2
+ Custom View 3 | view.3d.custom3
+ ---
+ Reset 3D View | view.reset3DView
+ Switch to Last 3D View | view.3d.last | Escape
+ Look at Selected Layers | view.lookAtSelected
+ Look at All Layers | view.lookAtAll
+ ---
+ Go to Time... | time.set
+ Enter Full Screen | view.fullScreen
+Window
+ Workspace
+ All Panels | window.workspace {"name":"All Panels"}
+ Animation | window.workspace {"name":"Animation"}
+ Default | window.workspace {"name":"Default"} | Shift+F10
+ Effects | window.workspace {"name":"Effects"}
+ Minimal | window.workspace {"name":"Minimal"}
+ Motion Tracking | window.workspace {"name":"Motion Tracking"}
+ Paint | window.workspace {"name":"Paint"}
+ Small Screen | window.workspace {"name":"Small Screen"} | Shift+F12
+ Standard | window.workspace {"name":"Standard"} | Shift+F11
+ Text | window.workspace {"name":"Text"}
+ ---
+ Reset to Saved Layout | window.resetWorkspace
+ Save Changes to this Workspace | window.saveWorkspace
+ Save as New Workspace... | window.saveWorkspaceAs
+ Edit Workspaces... | window.editWorkspaces
+ ---
+ Align | window.panel {"panel":"align"}
+ Audio | window.panel {"panel":"audio"} | Cmd+4
+ Brushes | window.panel {"panel":"brushes"} | Cmd+9
+ Character | window.panel {"panel":"character"} | Cmd+6
+ Content-Aware Fill | window.unavailablePanel {"panel":"contentAwareFill"}
+ Effects & Presets | window.panel {"panel":"effectsPresets"} | Cmd+5
+ Info | window.panel {"panel":"info"} | Cmd+2
+ Lumetri Scopes | window.unavailablePanel {"panel":"lumetriScopes"}
+ Mask Interpolation | window.unavailablePanel {"panel":"maskInterpolation"}
+ Media Browser | window.unavailablePanel {"panel":"mediaBrowser"}
+ Metadata | window.unavailablePanel {"panel":"metadata"}
+ Motion Sketch | window.panel {"panel":"motionSketch"}
+ Paint | window.panel {"panel":"paint"} | Cmd+8
+ Paragraph | window.panel {"panel":"paragraph"} | Cmd+7
+ Preview | window.panel {"panel":"preview"} | Cmd+3
+ Progress | window.unavailablePanel {"panel":"progress"}
+ Properties | window.panel {"panel":"properties"}
+ Smoother | window.panel {"panel":"smoother"}
+ Tools | window.panel {"panel":"tools"} | Cmd+1
+ Tracker | window.panel {"panel":"tracker"}
+ Wiggler | window.panel {"panel":"wiggler"}
+ ---
+ Composition | window.panel {"panel":"composition"}
+ Effect Controls | window.panel {"panel":"effectControls"} | F3
+ Flowchart | window.panel {"panel":"flowchart"}
+ Footage | window.unavailablePanel {"panel":"footage"}
+ Layer | window.panel {"panel":"layer"}
+ Project | window.panel {"panel":"project"} | Cmd+0
+ Render Queue | window.panel {"panel":"renderQueue"} | Cmd+Alt+0
+ Timeline | window.panel {"panel":"timeline"}
+Help
+ EffectCraft Help... | help.docs {"page":"help"} | F1
+ Scripting Help... | help.docs {"page":"scripting"}
+ Expression Reference... | help.docs {"page":"expressions"}
+ Effect Reference... | help.docs {"page":"effects"}
+ Animation Presets... | anim.browsePresets
+ Keyboard Shortcuts... | app.keyboardShortcuts
+ ---
+ Join the ArtCraft Discord... | help.discord
+ Provide Feedback... | help.reportIssue
+ ---
+ ArtCraft Website | help.website
+ EffectCraft Home Page | help.appPage
+ EffectCraft on GitHub | help.github
+ Open Demo Project | file.openDemoProject
+ [!mac] ---
+ [!mac] About EffectCraft... | app.about
+"#;
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/engine/src/menus/tests.rs b/crates/engine/src/menus/tests.rs
new file mode 100644
index 000000000..ee8790c7d
--- /dev/null
+++ b/crates/engine/src/menus/tests.rs
@@ -0,0 +1,157 @@
+use std::collections::BTreeMap;
+
+use super::*;
+
+fn all_entries(nodes: &[MenuNode], path: &mut Vec, out: &mut Vec<(Vec, MenuEntry)>) {
+ for n in nodes {
+ match n {
+ MenuNode::Item(e) => out.push((path.clone(), e.clone())),
+ MenuNode::Separator => {}
+ MenuNode::Submenu { label, children } => {
+ path.push(label.clone());
+ all_entries(children, path, out);
+ path.pop();
+ }
+ }
+ }
+}
+
+fn platform_entries(mac: bool) -> Vec<(Vec, MenuEntry)> {
+ let tree = parse(TREE, mac).unwrap();
+ let mut out = vec![];
+ all_entries(&tree, &mut vec![], &mut out);
+ out
+}
+
+#[test]
+fn top_level_order_matches_after_effects() {
+ let mac: Vec =
+ parse(TREE, true).unwrap().iter().filter_map(|n| if let MenuNode::Submenu { label, .. } = n { Some(label.clone()) } else { None }).collect();
+ assert_eq!(mac, ["EffectCraft", "File", "Edit", "Composition", "Layer", "Effect", "Animation", "View", "Window", "Help"]);
+ let other: Vec =
+ parse(TREE, false).unwrap().iter().filter_map(|n| if let MenuNode::Submenu { label, .. } = n { Some(label.clone()) } else { None }).collect();
+ assert_eq!(other, ["File", "Edit", "Composition", "Layer", "Effect", "Animation", "View", "Window", "Help"]);
+ // The live bar is one of the two.
+ assert!(top_level().len() == mac.len() || top_level().len() == other.len());
+}
+
+#[test]
+fn every_menu_entry_resolves_to_a_registered_command() {
+ for mac in [true, false] {
+ for (path, e) in platform_entries(mac) {
+ assert!(crate::commands::find(&e.command).is_some(), "{} ▸ {}: unknown command `{}`", path.join(" ▸ "), e.label, e.command);
+ assert!(e.params.is_null() || e.params.is_object(), "{}: params must be an object", e.label);
+ }
+ }
+}
+
+#[test]
+fn command_menu_paths_and_labels_agree_with_the_tree() {
+ let entries = platform_entries(true);
+ let mut by_cmd: BTreeMap<&str, Vec<&(Vec, MenuEntry)>> = BTreeMap::new();
+ for e in &entries {
+ by_cmd.entry(e.1.command.as_str()).or_default().push(e);
+ }
+ for spec in crate::command_specs() {
+ if spec.menu.is_empty() {
+ continue;
+ }
+ let places = by_cmd.get(spec.id).unwrap_or_else(|| panic!("`{}` declares menu {:?} but is not in the menu tree", spec.id, spec.menu));
+ assert!(
+ places.iter().any(|(p, _)| p.iter().map(String::as_str).eq(spec.menu.iter().copied())),
+ "`{}` declares menu {:?}; the tree has it at {:?}",
+ spec.id,
+ spec.menu,
+ places.iter().map(|(p, _)| p.join(" ▸ ")).collect::>()
+ );
+ for (p, e) in places {
+ if e.params.is_null() && p.iter().map(String::as_str).eq(spec.menu.iter().copied()) {
+ assert_eq!(e.label, spec.label, "label of `{}`", spec.id);
+ }
+ }
+ }
+}
+
+#[test]
+fn dialog_labels_use_ascii_ellipsis() {
+ for (_, e) in platform_entries(true) {
+ assert!(!e.label.contains('…'), "`{}` uses a Unicode ellipsis; AE's menus use \"...\"", e.label);
+ }
+}
+
+#[test]
+fn shortcuts_are_unambiguous() {
+ // shortcut → (command, params) from command defaults and menu entries.
+ let mut seen: BTreeMap = BTreeMap::new();
+ let mut add = |sc: &str, id: &str, params: String| {
+ if sc == "Num*" {
+ return;
+ }
+ if let Some(prev) = seen.get(sc) {
+ assert_eq!(prev, &(id.to_string(), params.clone()), "shortcut {sc} is bound twice");
+ } else {
+ seen.insert(sc.to_string(), (id.to_string(), params));
+ }
+ };
+ for (_, e) in platform_entries(true) {
+ if let Some(sc) = &e.shortcut {
+ add(sc, &e.command, e.params.to_string());
+ }
+ }
+ for c in crate::command_specs() {
+ // Defaults of commands whose menu entries bind params are carried by the entries.
+ if let Some(sc) = c.shortcut
+ && !platform_entries(true).iter().any(|(_, e)| e.command == c.id && !e.params.is_null())
+ {
+ add(sc, c.id, "null".into());
+ }
+ }
+}
+
+#[test]
+fn menus_cover_after_effects_structure() {
+ let entries = platform_entries(true);
+ let count = |m: &str| entries.iter().filter(|(p, _)| p[0] == m).count();
+ // Floors (AE 2026 minus Adobe-service, history and user-specific entries).
+ assert!(count("File") >= 40, "File {}", count("File"));
+ assert!(count("Edit") >= 54, "Edit {}", count("Edit"));
+ assert!(count("Composition") >= 19, "Composition {}", count("Composition"));
+ assert!(count("Layer") >= 197, "Layer {}", count("Layer"));
+ assert!(count("Animation") >= 53, "Animation {}", count("Animation"));
+ assert!(count("View") >= 59, "View {}", count("View"));
+ assert!(count("Window") >= 43, "Window {}", count("Window"));
+ // 38 blending modes + next/previous.
+ let modes = entries.iter().filter(|(p, e)| p.last().map(String::as_str) == Some("Blending Mode") && e.command == "layer.setBlendMode").count();
+ assert_eq!(modes, 38);
+ // 16 label colours + None.
+ let labels = entries.iter().filter(|(_, e)| e.command == "edit.label").count();
+ assert_eq!(labels, 17);
+}
+
+#[test]
+fn checked_reflects_layer_state() {
+ let mut s = crate::Session::default();
+ s.execute("comp.new", serde_json::json!({"width": 320, "height": 180})).unwrap();
+ s.execute("layer.newSolid", serde_json::json!({})).unwrap();
+ s.execute("layer.setBlendMode", serde_json::json!({"mode": "Screen"})).unwrap();
+ assert_eq!(checked(&s, "layer.setBlendMode", &serde_json::json!({"mode": "Screen"})), Some(true));
+ assert_eq!(checked(&s, "layer.setBlendMode", &serde_json::json!({"mode": "Normal"})), Some(false));
+ assert_eq!(checked(&s, "layer.quality", &serde_json::json!({"quality": "best"})), Some(true));
+ assert_eq!(checked(&s, "file.save", &serde_json::json!({})), None);
+}
+
+/// `cargo test -p effectcraft-engine dump_specs -- --ignored --nocapture`: every command as TSV.
+#[test]
+#[ignore]
+fn dump_specs() {
+ for c in crate::command_specs() {
+ eprintln!("SPEC\t{}\t{}\t{}\t{}\t{}", c.id, c.label, c.menu.join(" > "), c.shortcut.unwrap_or(""), c.params);
+ }
+}
+
+#[test]
+fn parse_rejects_bad_trees() {
+ assert!(parse("File\n Empty\n", true).is_err());
+ assert!(parse("File\n Odd | file.save\n", true).is_err());
+ assert!(parse("File\n Bad | file.save {nope}\n", true).is_err());
+}
diff --git a/crates/engine/src/tests_menu_cmds.rs b/crates/engine/src/tests_menu_cmds.rs
new file mode 100644
index 000000000..095e55afd
--- /dev/null
+++ b/crates/engine/src/tests_menu_cmds.rs
@@ -0,0 +1,492 @@
+//! Tests for the menu-parity command families (Layer / Edit / Animation / File / Composition /
+//! View menus), including undo.
+
+use effectcraft_keyframe::Value as KV;
+use effectcraft_project::{FrameBlend, ItemKind, MatteKind, Quality, Sampling};
+use serde_json::{Value, json};
+
+use crate::{EngineError, Event, Session};
+
+fn comp() -> Session {
+ let mut s = Session::default();
+ s.execute("comp.new", json!({"name": "Main", "width": 640, "height": 360, "frameRate": 30, "duration": 10})).unwrap();
+ s
+}
+
+fn solid(s: &mut Session, color: &str) -> u64 {
+ s.execute("layer.newSolid", json!({"color": color, "width": 200, "height": 100})).unwrap()["layer"].as_u64().unwrap()
+}
+
+fn layer(s: &Session, id: u64) -> effectcraft_project::Layer {
+ s.active_comp().unwrap().layer(effectcraft_project::LayerId(id)).unwrap().clone()
+}
+
+fn tmp(name: &str) -> String {
+ let d = std::env::temp_dir().join(format!("effectcraft-menu-tests-{}", std::process::id()));
+ std::fs::create_dir_all(&d).unwrap();
+ d.join(name).to_string_lossy().to_string()
+}
+
+fn frontend_events(s: &mut Session) -> Vec<(String, Value)> {
+ s.drain_events()
+ .into_iter()
+ .filter_map(|e| match e {
+ Event::Frontend { command, params } => Some((command, params)),
+ _ => None,
+ })
+ .collect()
+}
+
+#[test]
+fn layer_quality_sampling_frame_blending_and_undo() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ s.execute("layer.quality", json!({"quality": "wireframe"})).unwrap();
+ s.execute("layer.sampling", json!({"sampling": "bicubic"})).unwrap();
+ s.execute("layer.frameBlending", json!({"mode": "pixelMotion"})).unwrap();
+ let l = layer(&s, a);
+ assert_eq!((l.switches.quality, l.switches.sampling, l.switches.frame_blend), (Quality::Wireframe, Sampling::Bicubic, FrameBlend::PixelMotion));
+ s.execute("edit.undo", json!({})).unwrap();
+ assert_eq!(layer(&s, a).switches.frame_blend, FrameBlend::Off);
+ assert!(s.execute("layer.quality", json!({"quality": "fancy"})).is_err());
+}
+
+#[test]
+fn layer_switches_menu() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ let b = solid(&mut s, "#00ff00");
+ s.execute("layer.select", json!({"layers": [b]})).unwrap();
+ s.execute("layer.hideOtherVideo", json!({})).unwrap();
+ assert!(!layer(&s, a).switches.video && layer(&s, b).switches.video);
+ s.execute("layer.showAllVideo", json!({})).unwrap();
+ assert!(layer(&s, a).switches.video);
+ s.execute("layer.setSwitch", json!({"layers": [a, b], "switch": "lock"})).unwrap();
+ assert!(layer(&s, a).switches.locked);
+ s.execute("layer.unlockAll", json!({})).unwrap();
+ assert!(!layer(&s, a).switches.locked && !layer(&s, b).switches.locked);
+ s.execute("edit.undo", json!({})).unwrap();
+ assert!(layer(&s, a).switches.locked);
+ // Expressions on / off.
+ s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "50"})).unwrap();
+ s.execute("layer.expressions", json!({"layers": [a], "enabled": false})).unwrap();
+ assert!(!layer(&s, a).props.prop("transform/opacity").unwrap().expr.as_ref().unwrap().enabled);
+ s.execute("layer.expressions", json!({"layers": [a], "enabled": true})).unwrap();
+ assert!(layer(&s, a).props.prop("transform/opacity").unwrap().has_expression());
+}
+
+#[test]
+fn transform_dialog_values_and_center_anchor() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ s.execute("layer.setTransform", json!({"prop": "position", "value": [100, 50]})).unwrap();
+ s.execute("layer.setTransform", json!({"prop": "rotation", "value": 90})).unwrap();
+ s.execute("layer.setTransform", json!({"prop": "opacity", "value": 25})).unwrap();
+ let l = layer(&s, a);
+ assert_eq!(l.props.prop("transform/position").unwrap().value, KV::Vec3([100.0, 50.0, 0.0]));
+ assert_eq!(l.props.prop("transform/opacity").unwrap().value.as_f64(), 25.0);
+ s.execute("edit.undo", json!({})).unwrap();
+ assert_eq!(layer(&s, a).props.prop("transform/opacity").unwrap().value.as_f64(), 100.0);
+ assert!(s.execute("layer.setTransform", json!({"prop": "skew", "value": 1})).is_err());
+
+ // Move the anchor off-centre, then Center Anchor Point keeps the layer in place.
+ s.execute("layer.setTransform", json!({"prop": "anchor", "value": [0, 0]})).unwrap();
+ s.execute("layer.setTransform", json!({"prop": "rotation", "value": 0})).unwrap();
+ let before = layer(&s, a).props.prop("transform/position").unwrap().value.as_vec3();
+ s.execute("layer.centerAnchor", json!({})).unwrap();
+ let l = layer(&s, a);
+ assert_eq!(l.props.prop("transform/anchor").unwrap().value.as_vec2(), [100.0, 50.0]);
+ let after = l.props.prop("transform/position").unwrap().value.as_vec3();
+ assert!((after[0] - before[0] - 100.0).abs() < 1e-6 && (after[1] - before[1] - 50.0).abs() < 1e-6, "{before:?} → {after:?}");
+
+ s.execute("layer.autoOrient", json!({"mode": "alongPath"})).unwrap();
+ assert_eq!(layer(&s, a).auto_orient, effectcraft_project::AutoOrient::AlongPath);
+}
+
+#[test]
+fn mask_menu_on_existing_masks() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ assert!(!s.is_enabled("layer.mask.reset"));
+ s.execute("layer.addMask", json!({})).unwrap();
+ s.execute("layer.addMask", json!({"shape": "ellipse"})).unwrap();
+ assert!(s.is_enabled("layer.mask.reset"));
+ let masks = |s: &Session| layer(s, a).masks().unwrap().groups().cloned().collect::>();
+ s.execute("layer.mask.set", json!({"field": "feather", "value": 12, "mask": 1})).unwrap();
+ assert_eq!(masks(&s)[0].get("feather").unwrap().value, KV::Vec2([12.0, 12.0]));
+ s.execute("layer.mask.set", json!({"field": "opacity", "value": 40})).unwrap();
+ assert!(masks(&s).iter().all(|m| m.get("opacity").unwrap().value.as_f64() == 40.0));
+ s.execute("layer.mask.invert", json!({"mask": 2})).unwrap();
+ s.execute("layer.mask.mode", json!({"mode": "Subtract", "mask": 2})).unwrap();
+ s.execute("layer.mask.lock", json!({"mask": 1})).unwrap();
+ let kinds: Vec<_> = masks(&s).iter().map(|m| m.kind.clone()).collect();
+ assert!(matches!(kinds[1], effectcraft_project::GroupKind::Mask { inverted: true, mode: effectcraft_project::MaskMode::Subtract, .. }));
+ assert!(matches!(kinds[0], effectcraft_project::GroupKind::Mask { locked: true, .. }));
+ s.execute("layer.mask.unlockAll", json!({})).unwrap();
+ assert!(matches!(masks(&s)[0].kind, effectcraft_project::GroupKind::Mask { locked: false, .. }));
+ s.execute("layer.mask.lockOthers", json!({"mask": 1})).unwrap();
+ assert!(matches!(masks(&s)[1].kind, effectcraft_project::GroupKind::Mask { locked: true, .. }));
+ s.execute("layer.mask.reset", json!({"mask": 1})).unwrap();
+ assert_eq!(masks(&s)[0].get("opacity").unwrap().value.as_f64(), 100.0);
+ s.execute("layer.mask.shape", json!({"mask": 1, "rect": [10, 10, 50, 40], "shape": "ellipse"})).unwrap();
+ s.execute("layer.mask.remove", json!({"mask": 2})).unwrap();
+ assert_eq!(masks(&s).len(), 1);
+ s.execute("layer.mask.removeAll", json!({})).unwrap();
+ assert!(masks(&s).is_empty());
+ s.execute("edit.undo", json!({})).unwrap();
+ assert_eq!(masks(&s).len(), 1);
+}
+
+#[test]
+fn layer_markers_lock_and_delete() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ s.execute("time.set", json!({"time": 1.0})).unwrap();
+ s.execute("layer.addMarker", json!({"comment": "hit"})).unwrap();
+ s.execute("layer.addMarker", json!({"time": 2.0})).unwrap();
+ assert_eq!(layer(&s, a).markers.len(), 2);
+ s.execute("layer.markersLock", json!({})).unwrap();
+ assert!(layer(&s, a).markers_locked);
+ s.execute("layer.deleteAllMarkers", json!({})).unwrap();
+ assert_eq!(layer(&s, a).markers.len(), 2, "locked markers survive");
+ s.execute("layer.markersLock", json!({"value": false})).unwrap();
+ s.execute("layer.deleteAllMarkers", json!({})).unwrap();
+ assert!(layer(&s, a).markers.is_empty());
+ s.execute("edit.undo", json!({})).unwrap();
+ assert_eq!(layer(&s, a).markers.len(), 2);
+}
+
+#[test]
+fn track_matte_menu() {
+ let mut s = comp();
+ let below = solid(&mut s, "#ff0000");
+ let top = solid(&mut s, "#00ff00");
+ s.execute("layer.select", json!({"layers": [below]})).unwrap();
+ s.execute("layer.trackMatte", json!({"op": "luma"})).unwrap();
+ let m = layer(&s, below).track_matte.unwrap();
+ assert_eq!((m.layer.0, m.kind), (top, MatteKind::Luma));
+ assert!(!layer(&s, top).switches.video);
+ s.execute("layer.trackMatte", json!({"op": "alphaInverted"})).unwrap();
+ assert_eq!(layer(&s, below).track_matte.unwrap().kind, MatteKind::AlphaInverted);
+ s.execute("layer.trackMatte", json!({"op": "none"})).unwrap();
+ assert!(layer(&s, below).track_matte.is_none());
+ s.execute("layer.select", json!({"layers": [top]})).unwrap();
+ assert!(s.execute("layer.trackMatte", json!({"op": "above"})).is_err());
+ s.execute("layer.trackMatte", json!({"op": "below"})).unwrap();
+ assert_eq!(layer(&s, top).track_matte.unwrap().layer.0, below);
+}
+
+#[test]
+fn keyframe_clipboard_paste_and_paste_reversed() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ let b = solid(&mut s, "#00ff00");
+ s.execute("prop.toggleAnimation", json!({"layer": a, "path": "transform/opacity"})).unwrap();
+ s.execute("time.set", json!({"time": 1.0})).unwrap();
+ s.execute("prop.set", json!({"layer": a, "path": "transform/opacity", "value": 0})).unwrap();
+ s.execute("prop.select", json!({"layer": a, "path": "transform/opacity"})).unwrap();
+ s.execute("edit.copy", json!({})).unwrap();
+ assert_eq!(s.state.key_clipboard.iter().map(|c| c.keys.len()).sum::(), 2);
+ s.execute("layer.select", json!({"layers": [b]})).unwrap();
+ s.execute("time.set", json!({"time": 2.0})).unwrap();
+ s.execute("edit.paste", json!({})).unwrap();
+ let keys = layer(&s, b).props.prop("transform/opacity").unwrap().keys.clone();
+ assert_eq!(keys.len(), 2);
+ assert!((keys[0].time.seconds() - 2.0).abs() < 1e-6 && keys[0].value.as_f64() == 100.0);
+ s.execute("edit.undo", json!({})).unwrap();
+ s.execute("edit.pasteReversedKeyframes", json!({})).unwrap();
+ let keys = layer(&s, b).props.prop("transform/opacity").unwrap().keys.clone();
+ assert_eq!((keys[0].value.as_f64(), keys[1].value.as_f64()), (0.0, 100.0));
+}
+
+#[test]
+fn property_links_and_expression_only() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ let b = solid(&mut s, "#00ff00");
+ s.execute("prop.select", json!({"layer": a, "path": "transform/position"})).unwrap();
+ s.execute("edit.copyWithPropertyLinks", json!({})).unwrap();
+ s.execute("layer.select", json!({"layers": [b]})).unwrap();
+ s.execute("edit.paste", json!({})).unwrap();
+ let e = layer(&s, b).props.prop("transform/position").unwrap().expr.clone().unwrap();
+ let name = layer(&s, a).name;
+ assert_eq!(e.text, format!("comp(\"Main\").layer({}).transform(\"Position\")", serde_json::to_string(&name).unwrap()));
+ // Relative links use thisComp.
+ s.execute("prop.select", json!({"layer": a, "path": "transform/opacity"})).unwrap();
+ s.execute("edit.copyWithRelativePropertyLinks", json!({})).unwrap();
+ s.execute("layer.select", json!({"layers": [b]})).unwrap();
+ s.execute("edit.paste", json!({})).unwrap();
+ assert!(layer(&s, b).props.prop("transform/opacity").unwrap().expr.as_ref().unwrap().text.starts_with("thisComp.layer("));
+ // Copy Expression Only.
+ s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "expression": "time * 90"})).unwrap();
+ s.execute("prop.select", json!({"layer": a, "path": "transform/rotation"})).unwrap();
+ s.execute("edit.copyExpressionOnly", json!({})).unwrap();
+ s.execute("layer.select", json!({"layers": [b]})).unwrap();
+ s.execute("edit.paste", json!({})).unwrap();
+ assert_eq!(layer(&s, b).props.prop("transform/rotation").unwrap().expr.as_ref().unwrap().text, "time * 90");
+ // Layers with property links: the pasted copy follows the original.
+ s.state.selected_props.clear();
+ s.execute("layer.select", json!({"layers": [a]})).unwrap();
+ s.execute("edit.copyWithPropertyLinks", json!({})).unwrap();
+ let new = s.execute("edit.paste", json!({})).unwrap();
+ let nid = new[0].as_u64().unwrap();
+ assert!(layer(&s, nid).props.prop("transform/scale").unwrap().has_expression());
+}
+
+#[test]
+fn lift_and_extract_work_area() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ s.execute("comp.workArea", json!({"start": 2.0, "end": 4.0})).unwrap();
+ s.execute("edit.liftWorkArea", json!({})).unwrap();
+ let c = s.active_comp().unwrap();
+ assert_eq!(c.layers.len(), 2, "split around the gap");
+ let mut spans: Vec<(f64, f64)> = c.layers.iter().map(|l| (l.in_point.seconds(), l.out_point.seconds())).collect();
+ spans.sort_by(|x, y| x.0.total_cmp(&y.0));
+ assert!((spans[0].1 - 2.0).abs() < 1e-6 && (spans[1].0 - 4.0).abs() < 1e-6);
+ s.execute("edit.undo", json!({})).unwrap();
+ s.execute("layer.select", json!({"layers": [a]})).unwrap();
+ s.execute("edit.extractWorkArea", json!({})).unwrap();
+ let c = s.active_comp().unwrap();
+ let mut spans: Vec<(f64, f64)> = c.layers.iter().map(|l| (l.in_point.seconds(), l.out_point.seconds())).collect();
+ spans.sort_by(|x, y| x.0.total_cmp(&y.0));
+ assert!((spans[1].0 - 2.0).abs() < 1e-6 && (spans[1].1 - 8.0).abs() < 1e-6, "{spans:?}");
+}
+
+#[test]
+fn label_group_purge_and_edit_original() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ let b = solid(&mut s, "#00ff00");
+ let _c = solid(&mut s, "#0000ff");
+ s.execute("edit.label", json!({"layers": [a, b], "label": "Cyan"})).unwrap();
+ s.execute("layer.select", json!({"layers": [a]})).unwrap();
+ s.execute("edit.selectLabelGroup", json!({})).unwrap();
+ assert_eq!(s.state.selected_layers.len(), 2);
+ s.drain_events();
+ s.execute("edit.purge", json!({"what": "memory"})).unwrap();
+ assert!(s.drain_events().contains(&Event::PurgeCaches));
+ assert!(!s.is_enabled("edit.editOriginal"));
+}
+
+#[test]
+fn animation_menu_keys_presets_text() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ // Add Keyframe on selected properties.
+ s.execute("prop.select", json!({"layer": a, "path": "transform/scale"})).unwrap();
+ s.execute("anim.addKeyframe", json!({})).unwrap();
+ s.execute("time.set", json!({"time": 1.0})).unwrap();
+ s.execute("prop.set", json!({"layer": a, "path": "transform/scale", "value": [400, 400]})).unwrap();
+ assert_eq!(layer(&s, a).props.prop("transform/scale").unwrap().keys.len(), 2);
+ // Exponential Scale: a key per frame, geometric in between.
+ s.execute("prop.select", json!({"layer": a, "path": "transform/scale"})).unwrap();
+ s.execute("keys.exponentialScale", json!({})).unwrap();
+ let keys = layer(&s, a).props.prop("transform/scale").unwrap().keys.clone();
+ assert_eq!(keys.len(), 31);
+ assert!((keys[15].value.as_vec3()[0] - 200.0).abs() < 1e-6, "{:?}", keys[15].value);
+ s.execute("edit.undo", json!({})).unwrap();
+ // Time-Reverse Keyframes.
+ s.execute("prop.select", json!({"layer": a, "path": "transform/scale"})).unwrap();
+ s.execute("keys.timeReverse", json!({})).unwrap();
+ let keys = layer(&s, a).props.prop("transform/scale").unwrap().keys.clone();
+ assert_eq!((keys[0].value.as_vec3()[0], keys[1].value.as_vec3()[0]), (400.0, 100.0));
+
+ // Presets round-trip through a file onto another layer at the CTI.
+ let path = tmp("scale.ecpreset");
+ s.execute("prop.select", json!({"layer": a, "path": "transform/scale"})).unwrap();
+ s.execute("anim.savePreset", json!({"path": path})).unwrap();
+ let b = solid(&mut s, "#00ff00");
+ s.execute("time.set", json!({"time": 3.0})).unwrap();
+ let r = s.execute("anim.applyPreset", json!({"path": path, "layers": [b]})).unwrap();
+ assert_eq!(r["applied"], 1);
+ let keys = layer(&s, b).props.prop("transform/scale").unwrap().keys.clone();
+ assert_eq!(keys.len(), 2);
+ assert!((keys[0].time.seconds() - 3.0).abs() < 1e-6);
+
+ // Text: animate, add selector, reveal, remove all.
+ let t = s.execute("layer.newText", json!({"text": "Hi"})).unwrap()["layer"].as_u64().unwrap();
+ s.execute("layer.addTextAnimator", json!({"properties": ["anchor", "position", "scale", "skew", "rotation", "opacity"]})).unwrap();
+ s.execute("text.addSelector", json!({"kind": "range"})).unwrap();
+ let anim = layer(&s, t).props.group("text/animators").unwrap().groups().next().unwrap().clone();
+ assert_eq!(anim.sub("selectors").unwrap().children.len(), 2);
+ assert_eq!(anim.sub("properties").unwrap().children.len(), 6);
+ assert!(s.execute("text.addSelector", json!({"kind": "wiggly"})).is_err());
+ s.execute("text.removeAllAnimators", json!({})).unwrap();
+ assert!(layer(&s, t).props.group("text/animators").unwrap().children.is_empty());
+ s.execute("edit.undo", json!({})).unwrap();
+ assert_eq!(layer(&s, t).props.group("text/animators").unwrap().children.len(), 1);
+}
+
+#[test]
+fn reveal_properties() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ s.execute("prop.toggleAnimation", json!({"layer": a, "path": "transform/rotation"})).unwrap();
+ s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "50"})).unwrap();
+ s.execute("prop.set", json!({"layer": a, "path": "transform/scale", "value": [50, 50]})).unwrap();
+ s.drain_events();
+ let n = |v: &Value| v["props"].as_array().unwrap().len();
+ assert_eq!(n(&s.execute("anim.reveal", json!({"kind": "keyframes"})).unwrap()), 1);
+ assert_eq!(n(&s.execute("anim.reveal", json!({"kind": "animation"})).unwrap()), 2);
+ assert_eq!(n(&s.execute("anim.reveal", json!({"kind": "modified"})).unwrap()), 3);
+ assert!(frontend_events(&mut s).iter().all(|(c, _)| c == "timeline.revealProps"));
+}
+
+#[test]
+fn sequence_layers() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ let b = solid(&mut s, "#00ff00");
+ let c = solid(&mut s, "#0000ff");
+ for (id, out) in [(a, 2.0), (b, 3.0), (c, 1.0)] {
+ s.execute("layer.timing", json!({"layers": [id], "out": out})).unwrap();
+ }
+ s.execute("layer.sequence", json!({"layers": [a, b, c], "overlap": true, "duration": 0.5, "transition": "dissolveFront"})).unwrap();
+ assert!((layer(&s, b).in_point.seconds() - 1.5).abs() < 1e-6);
+ assert!((layer(&s, c).in_point.seconds() - 4.0).abs() < 1e-6);
+ assert_eq!(layer(&s, c).props.prop("transform/opacity").unwrap().keys.len(), 2);
+}
+
+#[test]
+fn file_menu_project_ops() {
+ let mut s = comp();
+ let f = s.execute("project.newFolder", json!({"name": "Stuff"})).unwrap()["item"].as_u64().unwrap();
+ assert!(s.project.item(effectcraft_project::ItemId(f)).unwrap().is_folder());
+ let p1 = s.execute("file.importPlaceholder", json!({"name": "Shot 1", "width": 320, "height": 240})).unwrap()["item"].as_u64().unwrap();
+ let p2 = s.execute("file.importPlaceholder", json!({"name": "Unused"})).unwrap()["item"].as_u64().unwrap();
+ s.execute("file.importSolid", json!({"name": "Grey"})).unwrap();
+ s.state.project_selection = vec![effectcraft_project::ItemId(p1)];
+ let r = s.execute("file.newCompFromSelection", json!({})).unwrap();
+ let nc = effectcraft_project::ItemId(r["comps"][0].as_u64().unwrap());
+ assert_eq!((s.project.comp(nc).unwrap().width, s.project.comp(nc).unwrap().layers.len()), (320, 1));
+ // Missing footage = the placeholders.
+ let miss = s.execute("file.findMissing", json!({"what": "footage"})).unwrap();
+ assert_eq!(miss["items"].as_array().unwrap().len(), 2);
+ assert!(s.execute("file.findMissing", json!({"what": "fonts"})).is_ok());
+ // Interpretation.
+ s.state.project_selection = vec![effectcraft_project::ItemId(p1)];
+ s.execute("file.interpretFootage", json!({"frameRate": 24, "alpha": "premultiplied", "loop": 3})).unwrap();
+ s.execute("file.rememberInterpretation", json!({})).unwrap();
+ s.state.project_selection = vec![effectcraft_project::ItemId(p2)];
+ s.execute("file.applyInterpretation", json!({})).unwrap();
+ match &s.project.item(effectcraft_project::ItemId(p2)).unwrap().kind {
+ ItemKind::Footage(f) => assert_eq!((f.alpha, f.loop_count, f.frame_rate.as_f64().round()), (effectcraft_project::AlphaMode::Premultiplied, 3, 24.0)),
+ _ => panic!(),
+ }
+ // Remove Unused Footage drops the unused placeholder and the unused solid.
+ let before = s.project.items.len();
+ s.execute("file.removeUnusedFootage", json!({})).unwrap();
+ assert_eq!(s.project.items.len(), before - 2);
+ s.execute("edit.undo", json!({})).unwrap();
+ assert_eq!(s.project.items.len(), before);
+ // Replace with a solid retargets the layer.
+ s.state.project_selection = vec![effectcraft_project::ItemId(p1)];
+ s.execute("file.replaceWithSolid", json!({"color": "#336699"})).unwrap();
+ assert!(matches!(s.project.comp(nc).unwrap().layers[0].source, effectcraft_project::LayerSource::Solid { .. }));
+ // Reduce Project keeps only the selected comp and what it uses (+ folders of kept items).
+ s.state.project_selection = vec![nc];
+ s.execute("file.reduceProject", json!({})).unwrap();
+ assert!(s.project.items.len() <= 2, "{:?}", s.project.items.values().map(|i| &i.name).collect::>());
+ // Save a copy leaves the session path alone.
+ let path = tmp("copy.ecproj");
+ s.execute("file.saveCopy", json!({"path": path})).unwrap();
+ assert!(s.path.is_none() && std::fs::metadata(&path).is_ok());
+ s.execute("file.closeProject", json!({})).unwrap();
+ assert!(s.project.items.is_empty());
+}
+
+#[test]
+fn consolidate_duplicate_footage() {
+ let mut s = comp();
+ let f = |s: &mut Session| s.execute("file.importPlaceholder", json!({})).unwrap()["item"].as_u64().unwrap();
+ let a = f(&mut s);
+ let b = f(&mut s);
+ // Give both the same file path.
+ let mut p = (*s.project).clone();
+ for id in [a, b] {
+ if let Some(ItemKind::Footage(ft)) = p.item_mut(effectcraft_project::ItemId(id)).map(|i| &mut i.kind) {
+ ft.path = "/media/shot.mov".into();
+ }
+ }
+ s.project = std::sync::Arc::new(p);
+ s.execute("layer.addItem", json!({"item": b})).unwrap();
+ assert_eq!(s.execute("file.consolidateFootage", json!({})).unwrap()["removed"], 1);
+ let c = s.active_comp().unwrap();
+ assert_eq!(c.layers[0].source.item().unwrap().0, a);
+}
+
+#[test]
+fn run_script_steps() {
+ let mut s = comp();
+ let path = tmp("script.jsonl");
+ std::fs::write(&path, "// make two solids\n{\"command\":\"layer.newSolid\",\"params\":{\"color\":\"#ff0000\"}}\n{\"method\":\"engine.execute\",\"params\":{\"id\":\"layer.newNull\",\"params\":{}}}\n").unwrap();
+ let r = s.execute("file.runScript", json!({"path": path})).unwrap();
+ assert_eq!(r["steps"], 2);
+ assert_eq!(s.active_comp().unwrap().layers.len(), 2);
+ assert!(s.execute("file.runScript", json!({"steps": [{"command": "nope.nope"}]})).is_err());
+}
+
+#[test]
+fn crop_comp_and_save_frame() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ // ROI crop moves layers so nothing shifts on screen.
+ assert!(!s.is_enabled("comp.cropToRegionOfInterest"));
+ s.execute("view.setRegionOfInterest", json!({"rect": [100, 50, 200, 100]})).unwrap();
+ s.execute("comp.cropToRegionOfInterest", json!({})).unwrap();
+ let c = s.active_comp().unwrap();
+ assert_eq!((c.width, c.height), (200, 100));
+ assert_eq!(layer(&s, a).props.prop("transform/position").unwrap().value.as_vec2(), [220.0, 130.0]);
+ s.execute("edit.undo", json!({})).unwrap();
+ assert_eq!(s.active_comp().unwrap().width, 640);
+ // Crop to the selected layer's bounds (a 200×100 solid centred in 640×360).
+ s.execute("layer.select", json!({"layers": [a]})).unwrap();
+ let r = s.execute("comp.cropToLayerBounds", json!({})).unwrap();
+ assert_eq!((r["width"].as_u64(), r["height"].as_u64()), (Some(200), Some(100)));
+ assert_eq!(layer(&s, a).props.prop("transform/position").unwrap().value.as_vec2(), [100.0, 50.0]);
+ // Save Frame As ▸ File… writes a PNG.
+ let path = tmp("frame.png");
+ let r = s.execute("comp.saveFrameAs", json!({"path": path, "scale": 0.5})).unwrap();
+ assert_eq!(r["width"], 100);
+ let bytes = std::fs::read(&path).unwrap();
+ assert_eq!(&bytes[..8], b"\x89PNG\r\n\x1a\n");
+ // Responsive Design — Time.
+ s.execute("time.set", json!({"time": 2.0})).unwrap();
+ s.execute("comp.responsiveTime", json!({"op": "intro"})).unwrap();
+ let m = &s.active_comp().unwrap().markers[0];
+ assert!(m.protected && (m.duration.seconds() - 2.0).abs() < 1e-6);
+}
+
+#[test]
+fn guides_add_clear_import_export() {
+ let mut s = comp();
+ s.execute("view.addGuide", json!({"orientation": "horizontal", "position": 40})).unwrap();
+ s.execute("view.addGuide", json!({})).unwrap();
+ assert_eq!(s.active_comp().unwrap().guides.len(), 2);
+ assert_eq!(s.active_comp().unwrap().guides[1].position, 320.0);
+ let path = tmp("guides.json");
+ s.execute("view.exportGuides", json!({"path": path})).unwrap();
+ s.execute("view.clearGuides", json!({})).unwrap();
+ assert!(s.active_comp().unwrap().guides.is_empty());
+ s.execute("edit.undo", json!({})).unwrap();
+ assert_eq!(s.active_comp().unwrap().guides.len(), 2);
+ s.execute("view.clearGuides", json!({})).unwrap();
+ s.execute("view.importGuides", json!({"path": path})).unwrap();
+ assert_eq!(s.active_comp().unwrap().guides.len(), 2);
+}
+
+#[test]
+fn frontend_commands_emit_events_and_stubs_are_disabled() {
+ let mut s = comp();
+ s.drain_events();
+ s.execute("view.zoomIn", json!({})).unwrap();
+ s.execute("window.panel", json!({"panel": "align"})).unwrap();
+ let ev = frontend_events(&mut s);
+ assert_eq!(ev[0].0, "view.zoomIn");
+ assert_eq!(ev[1], ("window.panel".to_string(), json!({"panel": "align"})));
+ for id in ["render.addOutputModule", "path.rotoBezier", "camera.fromView", "view.3d.default", "layer.create", "track.motion"] {
+ assert!(!s.is_enabled(id), "{id}");
+ assert!(matches!(s.execute(id, json!({})), Err(EngineError::Disabled(..))), "{id}");
+ }
+}
diff --git a/crates/engine/src/tests_styles.rs b/crates/engine/src/tests_styles.rs
new file mode 100644
index 000000000..e589241fb
--- /dev/null
+++ b/crates/engine/src/tests_styles.rs
@@ -0,0 +1,119 @@
+//! Layer Styles commands: add/remove/show, eye switches, Global Light linkage, undo, serde.
+
+use serde_json::json;
+
+use crate::Session;
+
+fn session() -> (Session, u64, u64) {
+ let mut s = Session::default();
+ s.execute("comp.new", json!({"name": "Styles", "width": 200, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
+ let a = s.execute("layer.newSolid", json!({"color": "#ffffff", "width": 40, "height": 40})).unwrap()["layer"].as_u64().unwrap();
+ let b = s.execute("layer.newSolid", json!({"color": "#808080", "width": 40, "height": 40})).unwrap()["layer"].as_u64().unwrap();
+ (s, a, b)
+}
+
+fn styles_of(s: &Session, layer: u64) -> Vec<(String, bool)> {
+ let v = s.execute_query("layer.style.list", json!({"layer": layer}));
+ v["styles"].as_array().unwrap().iter().map(|x| (x["style"].as_str().unwrap().to_string(), x["enabled"].as_bool().unwrap())).collect()
+}
+
+impl Session {
+ fn execute_query(&self, id: &str, p: serde_json::Value) -> serde_json::Value {
+ let mut c = Session { project: self.project.clone(), state: self.state.clone(), ..Default::default() };
+ c.execute(id, p).unwrap()
+ }
+}
+
+#[test]
+fn add_remove_show_all_with_undo() {
+ let (mut s, a, _) = session();
+ s.execute("layer.select", json!({"layers": [a]})).unwrap();
+ s.execute("layer.style.stroke", json!({})).unwrap();
+ s.execute("layer.style.dropShadow", json!({})).unwrap();
+ s.execute("layer.style.add", json!({"style": "Bevel and Emboss"})).unwrap();
+ assert_eq!(styles_of(&s, a), vec![("dropShadow".into(), true), ("bevelEmboss".into(), true), ("stroke".into(), true)]);
+ // Values are ordinary properties.
+ s.execute("prop.set", json!({"layer": a, "path": "layerStyles/dropShadow/distance", "value": 12})).unwrap();
+ let v = s.execute("prop.get", json!({"layer": a, "path": "layerStyles/dropShadow/distance"})).unwrap();
+ assert!(v.to_string().contains("12"));
+ // Eye switch.
+ s.execute("layer.style.toggle", json!({"layer": a, "style": "stroke"})).unwrap();
+ assert!(styles_of(&s, a).contains(&("stroke".into(), false)));
+ s.execute("edit.undo", json!({})).unwrap();
+ assert!(styles_of(&s, a).contains(&("stroke".into(), true)));
+ // Remove one, then everything.
+ s.execute("layer.style.remove", json!({"layer": a, "style": "bevelEmboss"})).unwrap();
+ assert_eq!(styles_of(&s, a).len(), 2);
+ s.execute("layer.style.removeAll", json!({})).unwrap();
+ assert!(styles_of(&s, a).is_empty());
+ let layer = s.active_comp().unwrap().layer(effectcraft_project::LayerId(a)).unwrap().clone();
+ assert!(layer.layer_styles().is_none());
+ s.execute("edit.undo", json!({})).unwrap();
+ assert_eq!(styles_of(&s, a).len(), 2);
+ s.execute("edit.redo", json!({})).unwrap();
+ assert!(styles_of(&s, a).is_empty());
+ // Show All adds every style switched off; choosing one switches it on.
+ s.execute("layer.style.showAll", json!({})).unwrap();
+ let all = styles_of(&s, a);
+ assert_eq!(all.len(), 9);
+ assert!(all.iter().all(|(_, on)| !on));
+ s.execute("layer.style.satin", json!({})).unwrap();
+ assert!(styles_of(&s, a).contains(&("satin".into(), true)));
+ // Removing the last style removes the group.
+ s.execute("layer.style.removeAll", json!({})).unwrap();
+ s.execute("layer.style.colorOverlay", json!({})).unwrap();
+ s.execute("layer.style.remove", json!({"layer": a, "style": "Color Overlay"})).unwrap();
+ assert!(s.active_comp().unwrap().layer(effectcraft_project::LayerId(a)).unwrap().layer_styles().is_none());
+ // Convert to Editable Styles is unavailable without PSD styles.
+ assert!(!s.is_enabled("layer.style.convertToEditable"));
+}
+
+#[test]
+fn global_light_is_shared_by_the_comp() {
+ let (mut s, a, b) = session();
+ s.execute("layer.style.dropShadow", json!({"layers": [a]})).unwrap();
+ s.execute("layer.style.bevelEmboss", json!({"layers": [b]})).unwrap();
+ // Editing one layer's Global Light Angle updates the other layer and the comp.
+ s.execute("prop.set", json!({"layer": a, "path": "layerStyles/blendingOptions/globalLightAngle", "value": 45})).unwrap();
+ let bv = s.execute("prop.get", json!({"layer": b, "path": "layerStyles/blendingOptions/globalLightAngle"})).unwrap();
+ assert!(bv.to_string().contains("45"), "{bv}");
+ let gl = s.execute("layer.style.globalLight", json!({})).unwrap();
+ assert_eq!(gl["angle"].as_f64(), Some(45.0));
+ // The command sets both and new style groups pick it up.
+ s.execute("layer.style.globalLight", json!({"angle": 10, "altitude": 60})).unwrap();
+ let c = s.execute("layer.newSolid", json!({"color": "#ff0000", "width": 10, "height": 10})).unwrap()["layer"].as_u64().unwrap();
+ s.execute("layer.style.innerShadow", json!({"layers": [c]})).unwrap();
+ for l in [a, b, c] {
+ let v = s.execute("prop.get", json!({"layer": l, "path": "layerStyles/blendingOptions/globalLightAltitude"})).unwrap();
+ assert!(v.to_string().contains("60"), "{l}: {v}");
+ }
+ // Undo restores the previous shared value on every layer.
+ s.execute("edit.undo", json!({})).unwrap();
+ s.execute("edit.undo", json!({})).unwrap();
+ s.execute("edit.undo", json!({})).unwrap();
+ let v = s.execute("prop.get", json!({"layer": b, "path": "layerStyles/blendingOptions/globalLightAngle"})).unwrap();
+ assert!(v.to_string().contains("45"), "{v}");
+}
+
+#[test]
+fn styles_render_and_round_trip() {
+ let (mut s, a, _) = session();
+ s.execute("layer.style.stroke", json!({"layers": [a]})).unwrap();
+ s.execute("prop.set", json!({"layer": a, "path": "layerStyles/stroke/size", "value": 6})).unwrap();
+ let cid = s.active_comp_id().unwrap();
+ // Cached session render == uncached render, and the stroke shows outside the 40×40 square.
+ let img = s.render(cid, s.time(), Default::default());
+ let r = effectcraft_render::render_frame(&s.project, cid, s.time(), 1.0);
+ assert_eq!(img.data, r.data);
+ assert!(img.get(123, 50)[0] > 0.98 && img.get(123, 50)[1] < 0.02, "{:?}", img.get(123, 50));
+ // Change the colour through a command: the cache must not serve stale pixels.
+ s.execute("prop.set", json!({"layer": a, "path": "layerStyles/stroke/color", "value": [0, 0, 1, 1]})).unwrap();
+ let img2 = s.render(cid, s.time(), Default::default());
+ assert!(img2.get(123, 50)[2] > 0.98 && img2.get(123, 50)[0] < 0.02);
+ // Serde round trip keeps styles and the comp's Global Light.
+ s.execute("layer.style.globalLight", json!({"angle": 33})).unwrap();
+ let json = serde_json::to_string(&*s.project).unwrap();
+ let back: effectcraft_project::Project = serde_json::from_str(&json).unwrap();
+ assert_eq!(back, *s.project);
+ assert_eq!(back.comp(cid).unwrap().global_light.angle.value.as_f64(), 33.0);
+}
diff --git a/crates/project/src/build.rs b/crates/project/src/build.rs
index 9f78aa500..0e582de92 100644
--- a/crates/project/src/build.rs
+++ b/crates/project/src/build.rs
@@ -535,6 +535,7 @@ pub fn layer(project: &mut Project, comp: &Comp, name: &str, source: LayerSource
track_matte: None,
parent: None,
markers: vec![],
+ markers_locked: false,
auto_orient,
props: root,
}
diff --git a/crates/project/src/lib.rs b/crates/project/src/lib.rs
index 800a4808f..9e8cf9492 100644
--- a/crates/project/src/lib.rs
+++ b/crates/project/src/lib.rs
@@ -7,6 +7,7 @@
pub mod build;
pub mod props;
pub mod render_queue;
+pub mod styles;
use std::collections::BTreeMap;
use std::sync::Arc;
@@ -150,6 +151,19 @@ pub struct Comp {
pub draft_3d: bool,
#[serde(default)]
pub poster_time: Tick,
+ /// Global Light for layer styles (Layer ▸ Layer Styles ▸ Blending Options).
+ #[serde(default)]
+ pub global_light: styles::GlobalLight,
+ /// Viewer guides (View ▸ Add Guide…), in comp pixels.
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub guides: Vec,
+}
+
+/// A viewer guide line: vertical guides sit at an x position, horizontal ones at a y position.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Guide {
+ pub vertical: bool,
+ pub position: f64,
}
fn yes() -> bool {
@@ -178,6 +192,8 @@ impl Comp {
enable_frame_blending: true,
draft_3d: false,
poster_time: Tick::ZERO,
+ guides: vec![],
+ global_light: styles::GlobalLight::default(),
}
}
pub fn layer(&self, id: LayerId) -> Option<&Layer> {
@@ -411,6 +427,9 @@ pub struct Layer {
pub parent: Option,
#[serde(default)]
pub markers: Vec,
+ /// Layer ▸ Markers ▸ Lock Markers.
+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+ pub markers_locked: bool,
#[serde(default)]
pub auto_orient: AutoOrient,
/// The property tree (Masks, Effects, Transform, Text, Contents, Camera/Light options…).
diff --git a/crates/project/src/styles.rs b/crates/project/src/styles.rs
new file mode 100644
index 000000000..83db5e581
--- /dev/null
+++ b/crates/project/src/styles.rs
@@ -0,0 +1,485 @@
+//! Layer Styles (Layer ▸ Layer Styles): the `layerStyles` property group and its styles.
+//!
+//! After Effects' layer styles are Photoshop's: Blending Options (Global Light, Advanced
+//! Blending), Drop Shadow, Inner Shadow, Outer Glow, Inner Glow, Bevel and Emboss, Satin, Color
+//! Overlay, Gradient Overlay and Stroke. Every style is a group under the layer's `layerStyles`
+//! group (which sits after Transform, as in the AE timeline), with AE's property names, order,
+//! defaults and ranges; every property animates. A style group's `enabled` flag is its eye
+//! switch. Styles appear in the group in menu order whatever order they were added in.
+//!
+//! Global Light (angle/altitude) is one setting per composition: [`Comp::global_light`] holds it,
+//! each layer's Blending Options shows it, and [`sync_global_light`] keeps every layer of a comp
+//! in step after any edit.
+
+use effectcraft_color::BlendMode;
+use effectcraft_keyframe::{Gradient, Value};
+use serde::{Deserialize, Serialize};
+
+use crate::build::Ids;
+use crate::props::{GroupKind, ParamUi, PropGroup, Property};
+use crate::{Comp, Layer, Project};
+
+/// Match id of the layer's Layer Styles group.
+pub const GROUP: &str = "layerStyles";
+/// Match id of the Blending Options group.
+pub const BLENDING: &str = "blendingOptions";
+
+/// The styles in menu / timeline order: (match id, display name).
+pub const STYLES: &[(&str, &str)] = &[
+ ("dropShadow", "Drop Shadow"),
+ ("innerShadow", "Inner Shadow"),
+ ("outerGlow", "Outer Glow"),
+ ("innerGlow", "Inner Glow"),
+ ("bevelEmboss", "Bevel and Emboss"),
+ ("satin", "Satin"),
+ ("colorOverlay", "Color Overlay"),
+ ("gradientOverlay", "Gradient Overlay"),
+ ("stroke", "Stroke"),
+];
+
+/// Look a style up by match id or display name (case-insensitive).
+pub fn style_id(s: &str) -> Option<&'static str> {
+ STYLES.iter().find(|(id, name)| id.eq_ignore_ascii_case(s) || name.eq_ignore_ascii_case(s)).map(|(id, _)| *id)
+}
+
+/// The Blend Mode popup of layer styles (Photoshop's list) and the compositor mode for each.
+pub const STYLE_BLEND_MODES: &[(&str, BlendMode)] = &[
+ ("Normal", BlendMode::Normal),
+ ("Dissolve", BlendMode::Dissolve),
+ ("Darken", BlendMode::Darken),
+ ("Multiply", BlendMode::Multiply),
+ ("Color Burn", BlendMode::ColorBurn),
+ ("Linear Burn", BlendMode::LinearBurn),
+ ("Darker Color", BlendMode::DarkerColor),
+ ("Lighten", BlendMode::Lighten),
+ ("Screen", BlendMode::Screen),
+ ("Color Dodge", BlendMode::ColorDodge),
+ ("Linear Dodge (Add)", BlendMode::LinearDodge),
+ ("Lighter Color", BlendMode::LighterColor),
+ ("Overlay", BlendMode::Overlay),
+ ("Soft Light", BlendMode::SoftLight),
+ ("Hard Light", BlendMode::HardLight),
+ ("Vivid Light", BlendMode::VividLight),
+ ("Linear Light", BlendMode::LinearLight),
+ ("Pin Light", BlendMode::PinLight),
+ ("Hard Mix", BlendMode::HardMix),
+ ("Difference", BlendMode::Difference),
+ ("Exclusion", BlendMode::Exclusion),
+ ("Subtract", BlendMode::Subtract),
+ ("Divide", BlendMode::Divide),
+ ("Hue", BlendMode::Hue),
+ ("Saturation", BlendMode::Saturation),
+ ("Color", BlendMode::Color),
+ ("Luminosity", BlendMode::Luminosity),
+];
+
+/// Compositor blend mode for a style Blend Mode popup index.
+pub fn style_blend_mode(i: u32) -> BlendMode {
+ STYLE_BLEND_MODES.get(i as usize).map(|m| m.1).unwrap_or(BlendMode::Normal)
+}
+
+fn mode_index(m: BlendMode) -> u32 {
+ STYLE_BLEND_MODES.iter().position(|x| x.1 == m).unwrap_or(0) as u32
+}
+
+pub const KNOCKOUT: &[&str] = &["None", "Shallow", "Deep"];
+pub const COLOR_TYPE: &[&str] = &["Color", "Gradient"];
+pub const GLOW_TECHNIQUE: &[&str] = &["Softer", "Precise"];
+pub const GLOW_SOURCE: &[&str] = &["Center", "Edge"];
+pub const BEVEL_STYLE: &[&str] = &["Outer Bevel", "Inner Bevel", "Emboss", "Pillow Emboss", "Stroke Emboss"];
+pub const BEVEL_TECHNIQUE: &[&str] = &["Smooth", "Chisel Hard", "Chisel Soft"];
+pub const BEVEL_DIRECTION: &[&str] = &["Up", "Down"];
+pub const GRADIENT_STYLE: &[&str] = &["Linear", "Radial", "Angle", "Reflected", "Diamond"];
+pub const STROKE_POSITION: &[&str] = &["Outside", "Inside", "Center"];
+
+/// Default Global Light (Photoshop / After Effects defaults).
+pub const DEFAULT_ANGLE: f64 = 120.0;
+pub const DEFAULT_ALTITUDE: f64 = 30.0;
+
+/// A composition's Global Light, mirrored into every layer's Blending Options.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct GlobalLight {
+ pub angle: Property,
+ pub altitude: Property,
+}
+
+impl Default for GlobalLight {
+ fn default() -> Self {
+ GlobalLight {
+ angle: Property::new(0, "globalLightAngle", "Global Light Angle", Value::Scalar(DEFAULT_ANGLE)).with_ui(ParamUi::Angle),
+ altitude: Property::new(0, "globalLightAltitude", "Global Light Altitude", Value::Scalar(DEFAULT_ALTITUDE)).with_ui(ParamUi::Angle),
+ }
+ }
+}
+
+fn slider(min: f64, max: f64, decimals: u8) -> ParamUi {
+ ParamUi::Slider { min, max, slider_min: min, slider_max: max, decimals }
+}
+fn slider2(min: f64, max: f64, smin: f64, smax: f64, decimals: u8) -> ParamUi {
+ ParamUi::Slider { min, max, slider_min: smin, slider_max: smax, decimals }
+}
+fn popup(opts: &[&str]) -> ParamUi {
+ ParamUi::Popup { options: opts.iter().map(|s| s.to_string()).collect() }
+}
+fn style_modes() -> ParamUi {
+ ParamUi::Popup { options: STYLE_BLEND_MODES.iter().map(|m| m.0.to_string()).collect() }
+}
+fn rgb(r: u8, g: u8, b: u8) -> Value {
+ Value::Color([r as f64 / 255.0, g as f64 / 255.0, b as f64 / 255.0, 1.0])
+}
+
+fn mode(ids: &mut Ids, m: &str, name: &str, d: BlendMode) -> Property {
+ ids.prop(m, name, Value::Enum(mode_index(d))).with_ui(style_modes())
+}
+fn color(ids: &mut Ids, m: &str, name: &str, v: Value) -> Property {
+ ids.prop(m, name, v).with_ui(ParamUi::Color)
+}
+fn pct(ids: &mut Ids, m: &str, name: &str, v: f64) -> Property {
+ ids.prop(m, name, Value::Scalar(v)).with_ui(slider(0.0, 100.0, 0))
+}
+fn px(ids: &mut Ids, m: &str, name: &str, v: f64, max: f64) -> Property {
+ ids.prop(m, name, Value::Scalar(v)).with_ui(slider(0.0, max, 1))
+}
+fn check(ids: &mut Ids, m: &str, name: &str, v: bool) -> Property {
+ ids.prop(m, name, Value::Bool(v)).with_ui(ParamUi::Checkbox)
+}
+fn pop(ids: &mut Ids, m: &str, name: &str, v: u32, opts: &[&str]) -> Property {
+ ids.prop(m, name, Value::Enum(v)).with_ui(popup(opts))
+}
+fn angle(ids: &mut Ids, m: &str, name: &str, v: f64) -> Property {
+ ids.prop(m, name, Value::Scalar(v)).with_ui(ParamUi::Angle)
+}
+fn gradient(ids: &mut Ids, g: Gradient) -> Property {
+ ids.prop("colors", "Colors", Value::Gradient(g)).with_ui(ParamUi::Gradient)
+}
+
+/// The default glow gradient: the glow colour fading to transparent.
+fn glow_gradient() -> Gradient {
+ let c = [1.0, 1.0, 190.0 / 255.0, 1.0];
+ Gradient { colors: vec![(0.0, c), (1.0, c)], opacities: vec![(0.0, 1.0), (1.0, 0.0)] }
+}
+
+/// Global Light properties as they appear on a layer (copied from the comp's setting).
+fn global_props(ids: &mut Ids, gl: &GlobalLight) -> (Property, Property) {
+ let mut a = gl.angle.clone();
+ a.uid = ids.alloc();
+ let mut b = gl.altitude.clone();
+ b.uid = ids.alloc();
+ (a, b)
+}
+
+/// The Blending Options group.
+pub fn blending_options(ids: &mut Ids, gl: &GlobalLight) -> PropGroup {
+ let (a, b) = global_props(ids, gl);
+ let adv = ids
+ .group("advancedBlending", "Advanced Blending")
+ .with(pct(ids, "fillOpacity", "Fill Opacity", 100.0))
+ .with(check(ids, "red", "Red", true))
+ .with(check(ids, "green", "Green", true))
+ .with(check(ids, "blue", "Blue", true))
+ .with(pop(ids, "knockout", "Knockout", 0, KNOCKOUT))
+ .with(check(ids, "blendInteriorAsGroup", "Blend Interior Styles as Group", false))
+ .with(check(ids, "useBlendRanges", "Use Blend Ranges from Source", true));
+ ids.group(BLENDING, "Blending Options").with(a).with(b).with(adv)
+}
+
+/// An empty Layer Styles group (Blending Options only).
+pub fn layer_styles(ids: &mut Ids, gl: &GlobalLight) -> PropGroup {
+ let bo = blending_options(ids, gl);
+ ids.group(GROUP, "Layer Styles").with(bo)
+}
+
+/// A style group with AE's defaults (`id` from [`STYLES`]).
+pub fn style(ids: &mut Ids, id: &str) -> Option {
+ let (_, name) = STYLES.iter().find(|s| s.0 == id)?;
+ let mut g = ids.group(id, name);
+ g.kind = GroupKind::Plain;
+ let props: Vec = match id {
+ "dropShadow" => vec![
+ mode(ids, "blendMode", "Blend Mode", BlendMode::Multiply),
+ color(ids, "color", "Color", rgb(0, 0, 0)),
+ pct(ids, "opacity", "Opacity", 75.0),
+ check(ids, "useGlobalLight", "Use Global Light", true),
+ angle(ids, "angle", "Angle", DEFAULT_ANGLE),
+ ids.prop("distance", "Distance", Value::Scalar(5.0)).with_ui(slider2(0.0, 30000.0, 0.0, 100.0, 1)),
+ pct(ids, "spread", "Spread", 0.0),
+ px(ids, "size", "Size", 5.0, 250.0),
+ pct(ids, "noise", "Noise", 0.0),
+ check(ids, "knocksOut", "Layer Knocks Out Drop Shadow", true),
+ ],
+ "innerShadow" => vec![
+ mode(ids, "blendMode", "Blend Mode", BlendMode::Multiply),
+ color(ids, "color", "Color", rgb(0, 0, 0)),
+ pct(ids, "opacity", "Opacity", 75.0),
+ check(ids, "useGlobalLight", "Use Global Light", true),
+ angle(ids, "angle", "Angle", DEFAULT_ANGLE),
+ ids.prop("distance", "Distance", Value::Scalar(5.0)).with_ui(slider2(0.0, 30000.0, 0.0, 100.0, 1)),
+ pct(ids, "choke", "Choke", 0.0),
+ px(ids, "size", "Size", 5.0, 250.0),
+ pct(ids, "noise", "Noise", 0.0),
+ ],
+ "outerGlow" => vec![
+ mode(ids, "blendMode", "Blend Mode", BlendMode::Screen),
+ pct(ids, "opacity", "Opacity", 75.0),
+ pct(ids, "noise", "Noise", 0.0),
+ pop(ids, "colorType", "Color Type", 0, COLOR_TYPE),
+ color(ids, "color", "Color", rgb(255, 255, 190)),
+ gradient(ids, glow_gradient()),
+ pct(ids, "gradientSmoothness", "Gradient Smoothness", 100.0),
+ pop(ids, "technique", "Technique", 0, GLOW_TECHNIQUE),
+ pct(ids, "spread", "Spread", 0.0),
+ px(ids, "size", "Size", 5.0, 250.0),
+ ids.prop("range", "Range", Value::Scalar(50.0)).with_ui(slider(1.0, 100.0, 0)),
+ pct(ids, "jitter", "Jitter", 0.0),
+ ],
+ "innerGlow" => vec![
+ mode(ids, "blendMode", "Blend Mode", BlendMode::Screen),
+ pct(ids, "opacity", "Opacity", 75.0),
+ pct(ids, "noise", "Noise", 0.0),
+ pop(ids, "colorType", "Color Type", 0, COLOR_TYPE),
+ color(ids, "color", "Color", rgb(255, 255, 190)),
+ gradient(ids, glow_gradient()),
+ pct(ids, "gradientSmoothness", "Gradient Smoothness", 100.0),
+ pop(ids, "technique", "Technique", 0, GLOW_TECHNIQUE),
+ pop(ids, "source", "Source", 1, GLOW_SOURCE),
+ pct(ids, "choke", "Choke", 0.0),
+ px(ids, "size", "Size", 5.0, 250.0),
+ ids.prop("range", "Range", Value::Scalar(50.0)).with_ui(slider(1.0, 100.0, 0)),
+ pct(ids, "jitter", "Jitter", 0.0),
+ ],
+ "bevelEmboss" => vec![
+ pop(ids, "style", "Style", 1, BEVEL_STYLE),
+ pop(ids, "technique", "Technique", 0, BEVEL_TECHNIQUE),
+ ids.prop("depth", "Depth", Value::Scalar(100.0)).with_ui(slider2(1.0, 1000.0, 1.0, 1000.0, 0)),
+ pop(ids, "direction", "Direction", 0, BEVEL_DIRECTION),
+ px(ids, "size", "Size", 5.0, 250.0),
+ px(ids, "soften", "Soften", 0.0, 16.0),
+ check(ids, "useGlobalLight", "Use Global Light", true),
+ angle(ids, "angle", "Angle", DEFAULT_ANGLE),
+ ids.prop("altitude", "Altitude", Value::Scalar(DEFAULT_ALTITUDE)).with_ui(ParamUi::Angle),
+ mode(ids, "highlightMode", "Highlight Mode", BlendMode::Screen),
+ color(ids, "highlightColor", "Highlight Color", rgb(255, 255, 255)),
+ pct(ids, "highlightOpacity", "Highlight Opacity", 75.0),
+ mode(ids, "shadowMode", "Shadow Mode", BlendMode::Multiply),
+ color(ids, "shadowColor", "Shadow Color", rgb(0, 0, 0)),
+ pct(ids, "shadowOpacity", "Shadow Opacity", 75.0),
+ ],
+ "satin" => vec![
+ mode(ids, "blendMode", "Blend Mode", BlendMode::Multiply),
+ color(ids, "color", "Color", rgb(0, 0, 0)),
+ pct(ids, "opacity", "Opacity", 50.0),
+ angle(ids, "angle", "Angle", 19.0),
+ px(ids, "distance", "Distance", 11.0, 250.0),
+ px(ids, "size", "Size", 14.0, 250.0),
+ check(ids, "invert", "Invert", true),
+ ],
+ "colorOverlay" => {
+ vec![mode(ids, "blendMode", "Blend Mode", BlendMode::Normal), color(ids, "color", "Color", rgb(255, 0, 0)), pct(ids, "opacity", "Opacity", 100.0)]
+ }
+ "gradientOverlay" => vec![
+ mode(ids, "blendMode", "Blend Mode", BlendMode::Normal),
+ pct(ids, "opacity", "Opacity", 100.0),
+ gradient(ids, Gradient { colors: vec![(0.0, [0.0, 0.0, 0.0, 1.0]), (1.0, [1.0, 1.0, 1.0, 1.0])], opacities: vec![(0.0, 1.0), (1.0, 1.0)] }),
+ pct(ids, "gradientSmoothness", "Gradient Smoothness", 100.0),
+ angle(ids, "angle", "Angle", 90.0),
+ pop(ids, "style", "Style", 0, GRADIENT_STYLE),
+ check(ids, "reverse", "Reverse", false),
+ check(ids, "alignWithLayer", "Align with Layer", true),
+ ids.prop("scale", "Scale", Value::Scalar(100.0)).with_ui(slider(10.0, 150.0, 0)),
+ ids.prop("offset", "Offset", Value::Vec2([0.0, 0.0])).with_ui(ParamUi::Point),
+ ],
+ "stroke" => vec![
+ color(ids, "color", "Color", rgb(255, 0, 0)),
+ mode(ids, "blendMode", "Blend Mode", BlendMode::Normal),
+ ids.prop("size", "Size", Value::Scalar(3.0)).with_ui(slider(1.0, 250.0, 1)),
+ pct(ids, "opacity", "Opacity", 100.0),
+ pop(ids, "position", "Position", 0, STROKE_POSITION),
+ ],
+ _ => return None,
+ };
+ for p in props {
+ g.children.push(p.into());
+ }
+ Some(g)
+}
+
+impl Layer {
+ /// The Layer Styles group (present once a style was added).
+ pub fn layer_styles(&self) -> Option<&PropGroup> {
+ self.props.sub(GROUP)
+ }
+ /// Layer types that take layer styles (AV layers: footage, solids, precomps, text, shapes).
+ pub fn can_have_styles(&self) -> bool {
+ self.source.is_av() && !self.switches.adjustment
+ }
+}
+
+/// Add style `id` to `layer` (creating the Layer Styles group after Transform when missing).
+/// Returns the style group's uid; an existing style of that kind is kept and returned.
+pub fn add_style(layer: &mut Layer, ids: &mut Ids, id: &str, gl: &GlobalLight, enabled: bool) -> Option {
+ let order = STYLES.iter().position(|s| s.0 == id)?;
+ if layer.props.sub(GROUP).is_none() {
+ let g = layer_styles(ids, gl);
+ let at = layer.props.children.iter().position(|c| c.match_id() == "transform").map(|i| i + 1).unwrap_or(layer.props.children.len());
+ layer.props.children.insert(at, g.into());
+ }
+ let ls = layer.props.sub_mut(GROUP)?;
+ if let Some(g) = ls.sub(id) {
+ return Some(g.uid);
+ }
+ let mut g = style(ids, id)?;
+ g.enabled = enabled;
+ let uid = g.uid;
+ // Keep menu order: after Blending Options and every style that comes earlier.
+ let at = ls.children.iter().position(|c| STYLES.iter().position(|s| s.0 == c.match_id()).is_some_and(|o| o > order)).unwrap_or(ls.children.len());
+ ls.children.insert(at, g.into());
+ Some(uid)
+}
+
+fn same_anim(a: &Property, b: &Property) -> bool {
+ a.value == b.value && a.keys == b.keys && a.expr == b.expr
+}
+
+fn copy_anim(dst: &mut Property, src: &Property) {
+ dst.value = src.value.clone();
+ dst.keys = src.keys.clone();
+ dst.expr = src.expr.clone();
+}
+
+/// After an edit: if a layer's Global Light Angle/Altitude differs from its comp's setting, that
+/// layer was edited — adopt its value for the comp and copy it to every other layer (`before` is
+/// the project before the edit; comps that did not change are skipped).
+pub fn sync_global_light(before: &Project, after: &mut Project) {
+ let ids: Vec<_> = after
+ .items
+ .iter()
+ .filter_map(|(id, it)| match (&it.kind, before.items.get(id).map(|b| &b.kind)) {
+ (crate::ItemKind::Comp(a), Some(crate::ItemKind::Comp(b))) if std::sync::Arc::ptr_eq(a, b) => None,
+ (crate::ItemKind::Comp(_), _) => Some(*id),
+ _ => None,
+ })
+ .collect();
+ for id in ids {
+ let Some(comp) = after.comp(id) else { continue };
+ if !needs_sync(comp) {
+ continue;
+ }
+ if let Some(c) = after.comp_mut(id) {
+ sync_comp(c);
+ }
+ }
+}
+
+fn needs_sync(comp: &Comp) -> bool {
+ comp.layers.iter().filter_map(|l| l.layer_styles()?.sub(BLENDING)).any(|bo| {
+ bo.get("globalLightAngle").is_some_and(|p| !same_anim(p, &comp.global_light.angle))
+ || bo.get("globalLightAltitude").is_some_and(|p| !same_anim(p, &comp.global_light.altitude))
+ })
+}
+
+/// Make every layer of `comp` share one Global Light (the first layer that differs wins).
+pub fn sync_comp(comp: &mut Comp) {
+ for (m, which) in [("globalLightAngle", 0), ("globalLightAltitude", 1)] {
+ let cur = if which == 0 { &comp.global_light.angle } else { &comp.global_light.altitude };
+ let changed = comp.layers.iter().filter_map(|l| l.layer_styles()?.sub(BLENDING)?.get(m)).find(|p| !same_anim(p, cur)).cloned();
+ let Some(src) = changed else { continue };
+ let target = if which == 0 { &mut comp.global_light.angle } else { &mut comp.global_light.altitude };
+ copy_anim(target, &src);
+ for l in &mut comp.layers {
+ if let Some(p) = l.props.sub_mut(GROUP).and_then(|g| g.sub_mut(BLENDING)).and_then(|g| g.get_mut(m)) {
+ copy_anim(p, &src);
+ }
+ }
+ }
+}
+
+/// Set the comp's Global Light statically (`None` keeps a value) and mirror it to all layers.
+pub fn set_global_light(comp: &mut Comp, angle: Option, altitude: Option, t: effectcraft_time::Tick) {
+ if let Some(a) = angle {
+ comp.global_light.angle.set_value_at(t, Value::Scalar(a));
+ }
+ if let Some(a) = altitude {
+ comp.global_light.altitude.set_value_at(t, Value::Scalar(a.clamp(0.0, 90.0)));
+ }
+ let (a, b) = (comp.global_light.angle.clone(), comp.global_light.altitude.clone());
+ for l in &mut comp.layers {
+ if let Some(bo) = l.props.sub_mut(GROUP).and_then(|g| g.sub_mut(BLENDING)) {
+ if let Some(p) = bo.get_mut("globalLightAngle") {
+ copy_anim(p, &a);
+ }
+ if let Some(p) = bo.get_mut("globalLightAltitude") {
+ copy_anim(p, &b);
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::{LayerSource, build};
+ use effectcraft_time::{FrameRate, Tick};
+
+ fn setup() -> (Project, Comp, Layer) {
+ let mut p = Project::default();
+ let comp = Comp::new(100, 100, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
+ let l = build::layer(&mut p, &comp, "Shape", LayerSource::Shape, (0, 0), None);
+ (p, comp, l)
+ }
+
+ #[test]
+ fn styles_keep_menu_order_and_follow_transform() {
+ let (mut p, comp, mut l) = setup();
+ let gl = comp.global_light.clone();
+ let mut ids = Ids(&mut p.next_id);
+ add_style(&mut l, &mut ids, "stroke", &gl, true).unwrap();
+ add_style(&mut l, &mut ids, "dropShadow", &gl, true).unwrap();
+ let again = add_style(&mut l, &mut ids, "stroke", &gl, true).unwrap();
+ add_style(&mut l, &mut ids, "bevelEmboss", &gl, true).unwrap();
+ let ls = l.layer_styles().unwrap();
+ let order: Vec<&str> = ls.children.iter().map(|c| c.match_id()).collect();
+ assert_eq!(order, ["blendingOptions", "dropShadow", "bevelEmboss", "stroke"]);
+ assert_eq!(ls.sub("stroke").unwrap().uid, again);
+ let top: Vec<&str> = l.props.children.iter().map(|c| c.match_id()).collect();
+ let t = top.iter().position(|m| *m == "transform").unwrap();
+ assert_eq!(top[t + 1], GROUP);
+ // Defaults from AE.
+ let ds = ls.sub("dropShadow").unwrap();
+ assert_eq!(ds.get("opacity").unwrap().value, Value::Scalar(75.0));
+ assert_eq!(style_blend_mode(ds.get("blendMode").unwrap().value.as_enum()), BlendMode::Multiply);
+ assert_eq!(ls.sub(BLENDING).unwrap().get("globalLightAngle").unwrap().value, Value::Scalar(120.0));
+ }
+
+ #[test]
+ fn every_style_builds() {
+ let mut next = 1;
+ let mut ids = Ids(&mut next);
+ for (id, name) in STYLES {
+ let g = style(&mut ids, id).unwrap();
+ assert_eq!(g.name, *name);
+ assert!(!g.children.is_empty());
+ }
+ assert_eq!(style_id("Bevel and Emboss"), Some("bevelEmboss"));
+ }
+
+ #[test]
+ fn global_light_syncs_across_layers() {
+ let (mut p, mut comp, mut a) = setup();
+ let mut b = build::layer(&mut p, &comp, "B", LayerSource::Shape, (0, 0), None);
+ let gl = comp.global_light.clone();
+ let mut ids = Ids(&mut p.next_id);
+ add_style(&mut a, &mut ids, "dropShadow", &gl, true);
+ add_style(&mut b, &mut ids, "bevelEmboss", &gl, true);
+ comp.layers = vec![a, b];
+ comp.layers[1].props.sub_mut(GROUP).unwrap().sub_mut(BLENDING).unwrap().get_mut("globalLightAngle").unwrap().value = Value::Scalar(45.0);
+ assert!(needs_sync(&comp));
+ sync_comp(&mut comp);
+ assert!(!needs_sync(&comp));
+ assert_eq!(comp.global_light.angle.value, Value::Scalar(45.0));
+ let la = comp.layers[0].layer_styles().unwrap().sub(BLENDING).unwrap().get("globalLightAngle").unwrap();
+ assert_eq!(la.value, Value::Scalar(45.0));
+ set_global_light(&mut comp, None, Some(60.0), Tick::ZERO);
+ let lb = comp.layers[1].layer_styles().unwrap().sub(BLENDING).unwrap().get("globalLightAltitude").unwrap();
+ assert_eq!(lb.value, Value::Scalar(60.0));
+ }
+}
diff --git a/crates/render/src/cache.rs b/crates/render/src/cache.rs
index 0f80927b3..e1cdd73e4 100644
--- a/crates/render/src/cache.rs
+++ b/crates/render/src/cache.rs
@@ -266,8 +266,9 @@ fn key_with(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, footage: bool
hash_debug(&mut h, &layer.source);
hash_debug(&mut h, &layer.switches);
for c in &layer.props.children {
+ // Transform is applied later; Layer Styles are keyed separately (see [`styles_key`]).
if let Node::Group(g) = c
- && g.match_id == "transform"
+ && (g.match_id == "transform" || g.match_id == effectcraft_project::styles::GROUP)
{
continue;
}
@@ -285,3 +286,22 @@ fn key_with(ctx: &EvalCtx, layer: &Layer, scale: f64, draft: bool, footage: bool
}
Some(h.finish())
}
+
+/// Cache key for the styled layer (content key + the Layer Styles group: structure, eye
+/// switches, values, keyframes, expressions and their values at the context time — Global Light
+/// included, as every layer mirrors it in its Blending Options).
+pub fn styles_key(ctx: &EvalCtx, layer: &Layer, content_key: u64) -> u64 {
+ let mut h = KeyHasher(content_key ^ 0x9e37_79b9_7f4a_7c15);
+ if let Some(g) = layer.layer_styles() {
+ hash_debug(&mut h, g);
+ hash_values(&mut h, ctx, layer, g);
+ }
+ h.finish()
+}
+
+/// A sub-key of `key` (styled layer passes, flattened buffer).
+pub fn derive(key: u64, i: u64) -> u64 {
+ let mut h = KeyHasher(key);
+ i.hash(&mut h);
+ h.finish()
+}
diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs
index 62f9ed44e..1e5e2f3f2 100644
--- a/crates/render/src/lib.rs
+++ b/crates/render/src/lib.rs
@@ -11,6 +11,7 @@ pub mod cache;
pub mod eval;
pub mod masks;
pub mod shapes;
+pub mod styles;
pub mod text;
pub mod three_d;
@@ -58,7 +59,7 @@ impl EffectHost for FxHost<'_, '_, '_> {
}
let sub = Renderer { depth: self.r.depth + 1, ..*self.r };
// The cached layer buffer is shared; effects get their own copy.
- let buf = if masks_and_effects { (*sub.layer_buf(self.ctx, other)?).clone() } else { sub.source(self.ctx, other)? };
+ let buf = if masks_and_effects { (*sub.content_buf(self.ctx, other)?).clone() } else { sub.source(self.ctx, other)? };
let size = source_size(self.r.project, other);
let size = if size.0 == 0 { [self.ctx.comp.width as f64, self.ctx.comp.height as f64] } else { [size.0 as f64, size.1 as f64] };
Some(LayerPixels { buf, size })
@@ -92,7 +93,7 @@ impl EffectHost for FxHost<'_, '_, '_> {
}
let ctx = self.ctx.at(Tick::from_seconds_f64(comp_time));
let sub = Renderer { depth: self.r.depth + 1, ..*self.r };
- let buf = if masks_and_effects { (*sub.layer_buf(&ctx, other)?).clone() } else { (*sub.layer_input(&ctx, other, 0)?).clone() };
+ let buf = if masks_and_effects { (*sub.content_buf(&ctx, other)?).clone() } else { (*sub.layer_input(&ctx, other, 0)?).clone() };
let size = source_size(self.r.project, other);
let size = if size.0 == 0 { [self.ctx.comp.width as f64, self.ctx.comp.height as f64] } else { [size.0 as f64, size.1 as f64] };
Some(LayerPixels { buf, size })
@@ -308,13 +309,32 @@ impl<'a> Renderer<'a> {
}
}
- /// Fully processed layer buffer (source → masks → effects).
+ /// Fully processed layer buffer (source → masks → effects → layer styles, flattened).
/// Served from the layer cache when the layer's content key matches.
pub fn layer_buf(&self, ctx: &EvalCtx, layer: &Layer) -> Option> {
- self.layer_buf_timed(ctx, layer, None)
+ let st = self.styled(ctx, layer, None)?;
+ if st.passes.is_empty() {
+ return Some(st.body);
+ }
+ let key = st.key.map(|k| cache::derive(k, 0xf1a7));
+ if let (Some(c), Some(k)) = (self.cache, key)
+ && let Some(b) = c.get(k)
+ {
+ return Some(b);
+ }
+ let flat = Arc::new(styles::Styled { passes: st.passes.iter().map(|(b, m)| ((**b).clone(), *m)).collect(), body: (*st.body).clone() }.flatten());
+ if let (Some(c), Some(k)) = (self.cache, key) {
+ c.insert(k, flat.clone());
+ }
+ Some(flat)
}
- fn layer_buf_timed(&self, ctx: &EvalCtx, layer: &Layer, mut timing: Option<&mut LayerTiming>) -> Option> {
+ /// Layer pixels after source → masks → effects (no layer styles).
+ pub fn content_buf(&self, ctx: &EvalCtx, layer: &Layer) -> Option> {
+ self.content_buf_timed(ctx, layer, None).map(|(b, _)| b)
+ }
+
+ fn content_buf_timed(&self, ctx: &EvalCtx, layer: &Layer, mut timing: Option<&mut LayerTiming>) -> Option<(Arc, Option)> {
let key = self.cache.and_then(|_| cache::layer_key(ctx, layer, self.opts.scale, self.opts.draft));
if let (Some(c), Some(k)) = (self.cache, key)
&& let Some(b) = c.get(k)
@@ -322,7 +342,7 @@ impl<'a> Renderer<'a> {
if let Some(t) = timing.as_deref_mut() {
t.cached = true;
}
- return Some(b);
+ return Some((b, key));
}
let mut buf = self.source(ctx, layer)?;
masks::apply(ctx, layer, &mut buf);
@@ -330,7 +350,7 @@ impl<'a> Renderer<'a> {
if let (Some(c), Some(k)) = (self.cache, key) {
c.insert(k, buf.clone());
}
- Some(buf)
+ Some((buf, key))
}
/// A layer's input at the context time: source → masks → its first `effects` effects
@@ -355,6 +375,41 @@ impl<'a> Renderer<'a> {
Some(buf)
}
+ /// The layer with its styles: exterior passes and body (cached per pass).
+ fn styled(&self, ctx: &EvalCtx, layer: &Layer, mut timing: Option<&mut LayerTiming>) -> Option {
+ let (content, ckey) = self.content_buf_timed(ctx, layer, timing.as_deref_mut())?;
+ if !styles::active(ctx, layer) {
+ return Some(StyledLayer { passes: vec![], body: content.clone(), content, key: None, plain: true });
+ }
+ let modes = styles::pass_modes(ctx, layer);
+ let key = ckey.map(|k| cache::styles_key(ctx, layer, k));
+ if let (Some(c), Some(k)) = (self.cache, key)
+ && let Some(body) = c.get(k)
+ {
+ let passes: Option> = modes.iter().enumerate().map(|(i, m)| c.get(cache::derive(k, i as u64 + 1)).map(|b| (b, *m))).collect();
+ if let Some(passes) = passes {
+ return Some(StyledLayer { passes, body, content, key, plain: false });
+ }
+ }
+ let t0 = std::time::Instant::now();
+ let size = source_size(self.project, layer);
+ let layer_size = if size.0 == 0 { [ctx.comp.width as f64, ctx.comp.height as f64] } else { [size.0 as f64, size.1 as f64] };
+ let st = styles::render(ctx, layer, &content, layer_size);
+ if let Some(t) = timing {
+ t.cached = false;
+ t.effects.push(("layerStyles".into(), t0.elapsed().as_secs_f64() * 1e3));
+ }
+ let body = Arc::new(st.body);
+ let passes: Vec<_> = st.passes.into_iter().map(|(b, m)| (Arc::new(b), m)).collect();
+ if let (Some(c), Some(k)) = (self.cache, key) {
+ c.insert(k, body.clone());
+ for (i, (b, _)) in passes.iter().enumerate() {
+ c.insert(cache::derive(k, i as u64 + 1), b.clone());
+ }
+ }
+ Some(StyledLayer { passes, body, content, key, plain: false })
+ }
+
fn sampling(&self, layer: &Layer) -> effectcraft_raster::Sampling {
if self.opts.draft || layer.switches.quality == Quality::Draft {
effectcraft_raster::Sampling::Bilinear
@@ -409,34 +464,79 @@ impl<'a> Renderer<'a> {
self.draw_adjustment(ctx, layer, canvas, opacity);
return;
}
- let Some(prof) = self.profile else {
- if let Some(buf) = self.layer_buf(ctx, layer) {
- self.composite_layer(ctx, layer, &buf, canvas, opacity);
- }
- return;
- };
- let mut timing = LayerTiming { depth: self.depth, layer: layer.name.clone(), ..Default::default() };
+ let mut timing = self.profile.map(|_| LayerTiming { depth: self.depth, layer: layer.name.clone(), ..Default::default() });
let t0 = std::time::Instant::now();
- let Some(buf) = self.layer_buf_timed(ctx, layer, Some(&mut timing)) else { return };
+ let Some(st) = self.styled(ctx, layer, timing.as_mut()) else { return };
let t1 = std::time::Instant::now();
- self.composite_layer(ctx, layer, &buf, canvas, opacity);
- timing.process_ms = (t1 - t0).as_secs_f64() * 1e3;
- timing.composite_ms = t1.elapsed().as_secs_f64() * 1e3;
- if let Ok(mut v) = prof.lock() {
- v.push(timing);
+ if st.plain {
+ self.composite_layer(ctx, layer, &st.body, canvas, opacity);
+ } else {
+ self.composite_styled(ctx, layer, &st, canvas, opacity);
+ }
+ if let (Some(prof), Some(mut timing)) = (self.profile, timing) {
+ timing.process_ms = (t1 - t0).as_secs_f64() * 1e3;
+ timing.composite_ms = t1.elapsed().as_secs_f64() * 1e3;
+ if let Ok(mut v) = prof.lock() {
+ v.push(timing);
+ }
}
}
+ /// Composite a styled layer: exterior passes with their own modes, then the body with the
+ /// layer's mode; the layer's opacity fades the whole stack. Knockout clears what is below the
+ /// layer's content; switched-off R/G/B channels keep the values below.
+ fn composite_styled(&self, ctx: &EvalCtx, layer: &Layer, st: &StyledLayer, canvas: &mut Image, opacity: f32) {
+ let bl = styles::blending(ctx, layer);
+ let matte = layer.track_matte.is_some_and(|tm| tm.layer != layer.id && ctx.comp.layer(tm.layer).is_some());
+ if matte || layer.preserve_transparency {
+ let mut iso = Image::new(canvas.width, canvas.height);
+ for (b, m) in &st.passes {
+ self.place(ctx, layer, b, &mut iso, *m, 1.0);
+ }
+ self.place(ctx, layer, &st.body, &mut iso, BlendMode::Normal, 1.0);
+ self.composite_iso(ctx, layer, iso, canvas, opacity);
+ return;
+ }
+ let mut tmp = canvas.clone();
+ if bl.knockout > 0 {
+ let mut k = Image::new(canvas.width, canvas.height);
+ self.place(ctx, layer, &st.content, &mut k, BlendMode::Normal, 1.0);
+ tmp.data.par_iter_mut().zip(k.data.par_iter()).for_each(|(p, q)| {
+ let keep = 1.0 - q[3].clamp(0.0, 1.0);
+ for c in p.iter_mut() {
+ *c *= keep;
+ }
+ });
+ }
+ for (b, m) in &st.passes {
+ self.place(ctx, layer, b, &mut tmp, *m, 1.0);
+ }
+ self.place(ctx, layer, &st.body, &mut tmp, layer.blend_mode, 1.0);
+ let ch = bl.channels;
+ canvas.data.par_iter_mut().zip(tmp.data.par_iter()).for_each(|(c, t)| {
+ for i in 0..4 {
+ let v = if i < 3 && !ch[i] { c[i] } else { t[i] };
+ c[i] += (v - c[i]) * opacity;
+ }
+ });
+ }
+
fn composite_layer(&self, ctx: &EvalCtx, layer: &Layer, buf: &Buf, canvas: &mut Image, opacity: f32) {
- let matte = layer.track_matte.and_then(|tm| ctx.comp.layer(tm.layer).filter(|m| m.id != layer.id).map(|m| (m, tm.kind)));
- let preserve = layer.preserve_transparency;
- if matte.is_none() && !preserve {
+ let matte = layer.track_matte.is_some_and(|tm| tm.layer != layer.id && ctx.comp.layer(tm.layer).is_some());
+ if !matte && !layer.preserve_transparency {
self.place(ctx, layer, buf, canvas, layer.blend_mode, opacity);
return;
}
// Render in isolation, then matte / preserve transparency, then blend.
let mut iso = Image::new(canvas.width, canvas.height);
self.place(ctx, layer, buf, &mut iso, BlendMode::Normal, 1.0);
+ self.composite_iso(ctx, layer, iso, canvas, opacity);
+ }
+
+ /// Apply the track matte / preserve transparency to an isolated layer render, then blend.
+ fn composite_iso(&self, ctx: &EvalCtx, layer: &Layer, mut iso: Image, canvas: &mut Image, opacity: f32) {
+ let matte = layer.track_matte.and_then(|tm| ctx.comp.layer(tm.layer).filter(|m| m.id != layer.id).map(|m| (m, tm.kind)));
+ let preserve = layer.preserve_transparency;
if let Some((m, kind)) = matte {
let mut mimg = Image::new(canvas.width, canvas.height);
if m.is_active_at(ctx.time)
@@ -488,6 +588,18 @@ impl<'a> Renderer<'a> {
}
}
+/// A layer ready to composite (see [`Renderer::styled`]).
+struct StyledLayer {
+ passes: Vec<(Arc, BlendMode)>,
+ body: Arc,
+ /// Pre-style pixels (knockout shape).
+ content: Arc,
+ /// Styled cache key.
+ key: Option,
+ /// No layer styles: composite `body` the usual way.
+ plain: bool,
+}
+
/// Convenience: render one frame of a comp with no footage source.
pub fn render_frame(project: &Project, comp: ItemId, t: Tick, scale: f64) -> Image {
Renderer::new(project, &NoFootage, RenderOpts { scale, ..Default::default() }).comp_frame(comp, t)
@@ -497,6 +609,8 @@ pub fn render_frame(project: &Project, comp: ItemId, t: Tick, scale: f64) -> Ima
mod tests;
#[cfg(test)]
mod tests_remap;
+#[cfg(test)]
+mod tests_styles;
/// Layer-space bounds `[x0, y0, x1, y1]` of a layer's content at the context time (source size
/// for solids/footage/precomps, glyph bounds for text, painted bounds for shapes). Used for viewer
diff --git a/crates/render/src/styles.rs b/crates/render/src/styles.rs
new file mode 100644
index 000000000..8bc244985
--- /dev/null
+++ b/crates/render/src/styles.rs
@@ -0,0 +1,741 @@
+//! Layer Styles rendering (Photoshop-style layer effects, as After Effects renders them).
+//!
+//! Styles run in layer space after masks and effects and before the transform. The layer's
+//! processed pixels (the *content*) become:
+//!
+//! * **exterior passes** — Drop Shadow, then Outer Glow — separate buffers composited onto the
+//! comp *below* the layer, each with its own blend mode (so a Multiply shadow multiplies the
+//! layers underneath, as in AE);
+//! * the **body** — the content scaled by Fill Opacity, then the interior styles in Photoshop's
+//! stacking order (Gradient Overlay, Color Overlay, Satin, Inner Glow, Inner Shadow), each
+//! clipped to the content's alpha and blended with its mode, then Stroke and Bevel and Emboss.
+//! With *Blend Interior Styles as Group* the interior styles are faded by Fill Opacity too.
+//!
+//! The compositor applies the layer's opacity to the whole stack, and Advanced Blending's
+//! Knockout and R/G/B channel switches at composite time (see `Renderer::composite_styled`).
+//! Every distance is in layer pixels and scales with the render resolution (Half, Quarter…).
+//!
+//! Shapes come from a signed distance field of the content alpha (exact Euclidean distance
+//! transform, Felzenszwalb–Huttenlocher) for spread/choke, strokes, precise glows and bevel
+//! profiles, and from the shared separable Gaussian (`effects::util::gauss_plane`) for soft
+//! shadows and glows. All per-pixel work is parallel (rayon).
+
+use effectcraft_color::{BlendMode, blend_pixel};
+use effectcraft_effects::Buf;
+use effectcraft_effects::util::{Plane, gauss_plane};
+use effectcraft_keyframe::{Gradient, Value};
+use effectcraft_project::styles::{self as st, style_blend_mode};
+use effectcraft_project::{Layer, PropGroup};
+use effectcraft_raster::{Image, hash_noise};
+use rayon::prelude::*;
+
+use crate::eval::EvalCtx;
+
+/// Largest padding (buffer pixels) styles may add on each side.
+const MAX_PAD: f64 = 2048.0;
+
+/// A styled layer: exterior passes (bottom first, each with its blend mode) and the body.
+#[derive(Clone, Debug)]
+pub struct Styled {
+ pub passes: Vec<(Buf, BlendMode)>,
+ pub body: Buf,
+}
+
+impl Styled {
+ /// Everything composited into one buffer (for 3D layers, track mattes and layer references).
+ pub fn flatten(&self) -> Buf {
+ if self.passes.is_empty() {
+ return self.body.clone();
+ }
+ let mut img = Image::new(self.body.img.width, self.body.img.height);
+ for (p, m) in &self.passes {
+ img.blend_from(&p.img, *m, 1.0, 0);
+ }
+ img.blend_from(&self.body.img, BlendMode::Normal, 1.0, 0);
+ Buf { img, offset: self.body.offset, scale: self.body.scale }
+ }
+}
+
+/// Advanced Blending options evaluated at a time.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Blending {
+ pub fill: f32,
+ /// Red, green, blue channel switches.
+ pub channels: [bool; 3],
+ /// 0 None, 1 Shallow, 2 Deep.
+ pub knockout: u32,
+ pub interior_group: bool,
+}
+
+impl Default for Blending {
+ fn default() -> Self {
+ Blending { fill: 1.0, channels: [true; 3], knockout: 0, interior_group: false }
+ }
+}
+
+/// The layer's Layer Styles group when styles are switched on.
+pub fn group(layer: &Layer) -> Option<&PropGroup> {
+ layer.layer_styles().filter(|g| g.enabled && layer.can_have_styles())
+}
+
+/// Evaluated Advanced Blending (defaults when the layer has no styles).
+pub fn blending(ctx: &EvalCtx, layer: &Layer) -> Blending {
+ let Some(adv) = group(layer).and_then(|g| g.sub(st::BLENDING)).and_then(|b| b.sub("advancedBlending")) else { return Blending::default() };
+ Blending {
+ fill: (ctx.f(layer, adv, "fillOpacity", 100.0) / 100.0).clamp(0.0, 1.0) as f32,
+ channels: [ctx.b(layer, adv, "red"), ctx.b(layer, adv, "green"), ctx.b(layer, adv, "blue")],
+ knockout: ctx.e(layer, adv, "knockout"),
+ interior_group: ctx.b(layer, adv, "blendInteriorAsGroup"),
+ }
+}
+
+/// Global light (angle, altitude) in degrees for the layer.
+fn global_light(ctx: &EvalCtx, layer: &Layer, g: &PropGroup) -> (f64, f64) {
+ match g.sub(st::BLENDING) {
+ Some(bo) => (ctx.f(layer, bo, "globalLightAngle", st::DEFAULT_ANGLE), ctx.f(layer, bo, "globalLightAltitude", st::DEFAULT_ALTITUDE)),
+ None => (st::DEFAULT_ANGLE, st::DEFAULT_ALTITUDE),
+ }
+}
+
+/// Does the layer need the styled path (any style on, or non-default blending)?
+pub fn active(ctx: &EvalCtx, layer: &Layer) -> bool {
+ let Some(g) = group(layer) else { return false };
+ g.groups().any(|s| s.enabled && s.match_id != st::BLENDING) || blending(ctx, layer) != Blending::default()
+}
+
+/// Blend modes of the exterior passes [`render`] produces (Drop Shadow, then Outer Glow).
+pub fn pass_modes(ctx: &EvalCtx, layer: &Layer) -> Vec {
+ let Some(g) = group(layer) else { return vec![] };
+ ["dropShadow", "outerGlow"].iter().filter_map(|id| g.sub(id).filter(|s| s.enabled)).map(|s| style_blend_mode(ctx.e(layer, s, "blendMode"))).collect()
+}
+
+// ------------------------------------------------------------------------------------------
+// Evaluated styles
+
+struct Shadow {
+ mode: BlendMode,
+ color: [f32; 3],
+ opacity: f32,
+ offset: [f64; 2],
+ spread: f64,
+ size: f64,
+ noise: f32,
+ knocks_out: bool,
+}
+
+struct Glow {
+ mode: BlendMode,
+ opacity: f32,
+ noise: f32,
+ gradient: Option,
+ color: [f32; 3],
+ precise: bool,
+ center: bool,
+ spread: f64,
+ size: f64,
+ range: f64,
+ jitter: f32,
+}
+
+struct Bevel {
+ style: u32,
+ technique: u32,
+ depth: f64,
+ down: bool,
+ size: f64,
+ soften: f64,
+ angle: f64,
+ altitude: f64,
+ hl: (BlendMode, [f32; 3], f32),
+ sh: (BlendMode, [f32; 3], f32),
+}
+
+struct Satin {
+ mode: BlendMode,
+ color: [f32; 3],
+ opacity: f32,
+ offset: [f64; 2],
+ size: f64,
+ invert: bool,
+}
+
+struct Overlay {
+ mode: BlendMode,
+ color: [f32; 3],
+ opacity: f32,
+}
+
+struct GradOverlay {
+ mode: BlendMode,
+ opacity: f32,
+ gradient: Gradient,
+ angle: f64,
+ style: u32,
+ reverse: bool,
+ align: bool,
+ scale: f64,
+ offset: [f64; 2],
+}
+
+struct Stroke {
+ mode: BlendMode,
+ color: [f32; 3],
+ size: f64,
+ opacity: f32,
+ position: u32,
+}
+
+#[derive(Default)]
+struct Styles {
+ drop: Option,
+ inner_shadow: Option,
+ outer_glow: Option,
+ inner_glow: Option,
+ bevel: Option,
+ satin: Option,
+ color: Option,
+ gradient: Option,
+ stroke: Option,
+}
+
+fn rgb(c: [f32; 4]) -> [f32; 3] {
+ [c[0], c[1], c[2]]
+}
+
+/// Light direction → shadow offset (the shadow falls away from the light).
+fn offset(angle: f64, distance: f64) -> [f64; 2] {
+ let a = angle.to_radians();
+ [-distance * a.cos(), distance * a.sin()]
+}
+
+fn evaluate(ctx: &EvalCtx, layer: &Layer, g: &PropGroup) -> Styles {
+ let (ga, galt) = global_light(ctx, layer, g);
+ let mut s = Styles::default();
+ for sg in g.groups().filter(|x| x.enabled) {
+ let f = |m: &str, d: f64| ctx.f(layer, sg, m, d);
+ let pct = |m: &str, d: f64| (ctx.f(layer, sg, m, d) / 100.0).clamp(0.0, 1.0);
+ let mode = |m: &str| style_blend_mode(ctx.e(layer, sg, m));
+ let col = |m: &str| rgb(ctx.color(layer, sg, m));
+ let ang = || if ctx.b(layer, sg, "useGlobalLight") { ga } else { f("angle", st::DEFAULT_ANGLE) };
+ let grad = || match ctx.group_value(layer, sg, "colors") {
+ Some(Value::Gradient(g)) => g,
+ _ => Gradient::default(),
+ };
+ match sg.match_id.as_str() {
+ "dropShadow" | "innerShadow" => {
+ let inner = sg.match_id == "innerShadow";
+ let sh = Shadow {
+ mode: mode("blendMode"),
+ color: col("color"),
+ opacity: pct("opacity", 75.0) as f32,
+ offset: offset(ang(), f("distance", 5.0).max(0.0)),
+ spread: pct(if inner { "choke" } else { "spread" }, 0.0),
+ size: f("size", 5.0).clamp(0.0, 250.0),
+ noise: pct("noise", 0.0) as f32,
+ knocks_out: !inner && ctx.b(layer, sg, "knocksOut"),
+ };
+ if inner {
+ s.inner_shadow = Some(sh);
+ } else {
+ s.drop = Some(sh);
+ }
+ }
+ "outerGlow" | "innerGlow" => {
+ let inner = sg.match_id == "innerGlow";
+ let gl = Glow {
+ mode: mode("blendMode"),
+ opacity: pct("opacity", 75.0) as f32,
+ noise: pct("noise", 0.0) as f32,
+ gradient: (ctx.e(layer, sg, "colorType") == 1).then(grad),
+ color: col("color"),
+ precise: ctx.e(layer, sg, "technique") == 1,
+ center: inner && ctx.e(layer, sg, "source") == 0,
+ spread: pct(if inner { "choke" } else { "spread" }, 0.0),
+ size: f("size", 5.0).clamp(0.0, 250.0),
+ range: pct("range", 50.0).max(0.01),
+ jitter: pct("jitter", 0.0) as f32,
+ };
+ if inner {
+ s.inner_glow = Some(gl);
+ } else {
+ s.outer_glow = Some(gl);
+ }
+ }
+ "bevelEmboss" => {
+ let gl = ctx.b(layer, sg, "useGlobalLight");
+ s.bevel = Some(Bevel {
+ style: ctx.e(layer, sg, "style"),
+ technique: ctx.e(layer, sg, "technique"),
+ depth: f("depth", 100.0).clamp(1.0, 1000.0) / 100.0,
+ down: ctx.e(layer, sg, "direction") == 1,
+ size: f("size", 5.0).clamp(0.0, 250.0),
+ soften: f("soften", 0.0).clamp(0.0, 16.0),
+ angle: if gl { ga } else { f("angle", st::DEFAULT_ANGLE) },
+ altitude: if gl { galt } else { f("altitude", st::DEFAULT_ALTITUDE) }.clamp(0.0, 90.0),
+ hl: (mode("highlightMode"), col("highlightColor"), pct("highlightOpacity", 75.0) as f32),
+ sh: (mode("shadowMode"), col("shadowColor"), pct("shadowOpacity", 75.0) as f32),
+ });
+ }
+ "satin" => {
+ s.satin = Some(Satin {
+ mode: mode("blendMode"),
+ color: col("color"),
+ opacity: pct("opacity", 50.0) as f32,
+ offset: offset(f("angle", 19.0), f("distance", 11.0).clamp(0.0, 250.0)),
+ size: f("size", 14.0).clamp(0.0, 250.0),
+ invert: ctx.b(layer, sg, "invert"),
+ });
+ }
+ "colorOverlay" => s.color = Some(Overlay { mode: mode("blendMode"), color: col("color"), opacity: pct("opacity", 100.0) as f32 }),
+ "gradientOverlay" => {
+ s.gradient = Some(GradOverlay {
+ mode: mode("blendMode"),
+ opacity: pct("opacity", 100.0) as f32,
+ gradient: grad(),
+ angle: f("angle", 90.0),
+ style: ctx.e(layer, sg, "style"),
+ reverse: ctx.b(layer, sg, "reverse"),
+ align: ctx.b(layer, sg, "alignWithLayer"),
+ scale: f("scale", 100.0).clamp(10.0, 150.0) / 100.0,
+ offset: ctx.v2(layer, sg, "offset", [0.0; 2]),
+ });
+ }
+ "stroke" => {
+ s.stroke = Some(Stroke {
+ mode: mode("blendMode"),
+ color: col("color"),
+ size: f("size", 3.0).clamp(0.0, 250.0),
+ opacity: pct("opacity", 100.0) as f32,
+ position: ctx.e(layer, sg, "position"),
+ });
+ }
+ _ => {}
+ }
+ }
+ s
+}
+
+/// Layer-space margin the styles reach beyond the content.
+fn reach(s: &Styles) -> f64 {
+ let soft = |size: f64| size * 1.6;
+ let mut r: f64 = 0.0;
+ if let Some(d) = &s.drop {
+ r = r.max(d.offset[0].abs().max(d.offset[1].abs()) + soft(d.size));
+ }
+ if let Some(d) = &s.inner_shadow {
+ r = r.max(d.offset[0].abs().max(d.offset[1].abs()) + soft(d.size));
+ }
+ if let Some(g) = &s.outer_glow {
+ r = r.max(soft(g.size));
+ }
+ if let Some(g) = &s.inner_glow {
+ r = r.max(soft(g.size));
+ }
+ if let Some(b) = &s.bevel {
+ r = r.max(b.size + b.soften * 2.0);
+ }
+ if let Some(st) = &s.stroke {
+ r = r.max(st.size);
+ }
+ if let Some(sa) = &s.satin {
+ r = r.max(sa.offset[0].abs().max(sa.offset[1].abs()) + soft(sa.size));
+ }
+ r
+}
+
+// ------------------------------------------------------------------------------------------
+// Distance fields
+
+/// "Infinite" squared distance (finite so parabola intersections stay exact in f64).
+const FAR: f64 = 1e10;
+
+/// 1D squared Euclidean distance transform (Felzenszwalb & Huttenlocher) of `f` into `d`.
+fn dt1d(f: &[f32], d: &mut [f32]) {
+ let n = f.len();
+ if n == 0 {
+ return;
+ }
+ let fv = |i: usize| (f[i] as f64).min(FAR);
+ let mut v = vec![0usize; n];
+ let mut z = vec![0f64; n + 1];
+ let mut k = 0usize;
+ z[0] = f64::NEG_INFINITY;
+ z[1] = f64::INFINITY;
+ let cross = |q: usize, p: usize| ((fv(q) + (q * q) as f64) - (fv(p) + (p * p) as f64)) / (2.0 * (q as f64 - p as f64));
+ for q in 1..n {
+ let mut s = cross(q, v[k]);
+ while k > 0 && s <= z[k] {
+ k -= 1;
+ s = cross(q, v[k]);
+ }
+ k += 1;
+ v[k] = q;
+ z[k] = s;
+ z[k + 1] = f64::INFINITY;
+ }
+ k = 0;
+ for (q, dq) in d.iter_mut().enumerate() {
+ while z[k + 1] < q as f64 {
+ k += 1;
+ }
+ let dx = q as f64 - v[k] as f64;
+ *dq = (dx * dx + fv(v[k])) as f32;
+ }
+}
+
+/// Euclidean distance (pixels) from every pixel to the nearest pixel where `seed` is true.
+fn edt(w: usize, h: usize, seed: impl Fn(usize) -> bool + Sync) -> Plane {
+ let f = Plane { w, h, data: (0..w * h).into_par_iter().map(|i| if seed(i) { 0.0 } else { FAR as f32 }).collect() };
+ let rows = f.map_rows(dt1d);
+ let cols = rows.transpose().map_rows(dt1d).transpose();
+ cols.map(|v| v.sqrt())
+}
+
+/// Signed distance to the content edge in pixels (negative inside), anti-aliased at the edge:
+/// a partially covered pixel with alpha `a` sits at `0.5 - a`.
+fn sdf(alpha: &Plane) -> Plane {
+ let (w, h) = (alpha.w, alpha.h);
+ let to_in = edt(w, h, |i| alpha.data[i] >= 0.5);
+ let to_out = edt(w, h, |i| alpha.data[i] < 0.5);
+ Plane {
+ w,
+ h,
+ data: (0..w * h)
+ .into_par_iter()
+ .map(|i| {
+ let a = alpha.data[i];
+ if a > 0.0 && a < 1.0 {
+ 0.5 - a
+ } else if a >= 0.5 {
+ -(to_out.data[i] - 0.5)
+ } else {
+ to_in.data[i] - 0.5
+ }
+ })
+ .collect(),
+ }
+}
+
+/// Coverage of the content grown by `r` pixels (negative `r` shrinks).
+#[inline]
+fn grown(sdf: f32, r: f32) -> f32 {
+ (r + 0.5 - sdf).clamp(0.0, 1.0)
+}
+
+// ------------------------------------------------------------------------------------------
+// Helpers
+
+/// Soft shape: content grown by `spread` of `size`, blurred by the rest (`inverse` = the
+/// outside of the content, for inner shadows/glows).
+fn soft_shape(alpha: &Plane, d: &Lazy, size: f64, spread: f64, inverse: bool) -> Plane {
+ let hard = size * spread;
+ let base = if hard > 0.01 {
+ let sd = d.get(alpha);
+ let r = hard as f32;
+ if inverse { sd.map(|v| grown(-v, r)) } else { sd.map(|v| grown(v, r)) }
+ } else if inverse {
+ alpha.map(|a| 1.0 - a)
+ } else {
+ alpha.clone()
+ };
+ let sigma = (size - hard).max(0.0) / 2.0;
+ if sigma > 0.05 { gauss_plane(&base, sigma, sigma) } else { base }
+}
+
+/// Bilinear read of `p` displaced by `off` pixels (the plane moves by `off`).
+#[inline]
+fn shifted(p: &Plane, x: usize, y: usize, off: [f64; 2]) -> f32 {
+ p.sample(x as f64 + 0.5 - off[0], y as f64 + 0.5 - off[1])
+}
+
+struct Lazy(std::sync::OnceLock);
+impl Lazy {
+ fn get(&self, alpha: &Plane) -> &Plane {
+ self.0.get_or_init(|| sdf(alpha))
+ }
+}
+
+#[inline]
+fn noisy(a: f32, noise: f32, x: usize, y: usize, seed: u32) -> f32 {
+ if noise <= 0.0 { a } else { a * (1.0 - noise * hash_noise(x as u32, y as u32, seed)) }
+}
+
+/// Blend a straight colour with coverage `a` onto every pixel of `img` (`f(x, y)` → (colour, a)).
+fn blend_into(img: &mut Image, mode: BlendMode, seed: u32, f: impl Fn(usize, usize) -> ([f32; 3], f32) + Sync) {
+ let w = img.width as usize;
+ img.data.par_chunks_mut(w.max(1)).enumerate().for_each(|(y, row)| {
+ for (x, d) in row.iter_mut().enumerate() {
+ let (c, a) = f(x, y);
+ if a <= 0.0 {
+ continue;
+ }
+ let src = [c[0] * a, c[1] * a, c[2] * a, a];
+ let n = if mode == BlendMode::Dissolve { hash_noise(x as u32, y as u32, seed) } else { 0.5 };
+ *d = blend_pixel(mode, *d, src, n);
+ }
+ });
+}
+
+/// A pass image filled with a straight colour at coverage `f(x, y)`.
+fn pass_image(w: usize, h: usize, f: impl Fn(usize, usize) -> ([f32; 3], f32) + Sync) -> Image {
+ let mut img = Image::new(w as u32, h as u32);
+ img.data.par_chunks_mut(w.max(1)).enumerate().for_each(|(y, row)| {
+ for (x, d) in row.iter_mut().enumerate() {
+ let (c, a) = f(x, y);
+ let a = a.clamp(0.0, 1.0);
+ *d = [c[0] * a, c[1] * a, c[2] * a, a];
+ }
+ });
+ img
+}
+
+/// Glow intensity → (colour, alpha) for colour or gradient glows.
+fn glow_color(g: &Glow, v: f32, x: usize, y: usize) -> ([f32; 3], f32) {
+ let v = v.clamp(0.0, 1.0).powf((0.5 / g.range) as f32);
+ match &g.gradient {
+ None => (g.color, v),
+ Some(gr) => {
+ let j = if g.jitter > 0.0 { (hash_noise(x as u32, y as u32, 77) - 0.5) * g.jitter } else { 0.0 };
+ let c = gr.sample((1.0 - v + j) as f64);
+ ([c[0], c[1], c[2]], c[3] * (v * 8.0).min(1.0))
+ }
+ }
+}
+
+/// Glow intensity (0..1) from the content (`inner` glows read the inverse).
+fn glow_intensity(alpha: &Plane, d: &Lazy, g: &Glow, s: f64, inner: bool) -> Plane {
+ let size = g.size * s;
+ if g.precise {
+ let sd = d.get(alpha);
+ let hard = (size * g.spread) as f32;
+ let soft = (size as f32 - hard).max(0.5);
+ return sd.map(|v| {
+ let v = if inner { -v } else { v };
+ (1.0 - (v - hard).max(0.0) / soft).clamp(0.0, 1.0)
+ });
+ }
+ soft_shape(alpha, d, size, g.spread, inner).map(|v| (v * 2.0).min(1.0))
+}
+
+// ------------------------------------------------------------------------------------------
+// Rendering
+
+/// Render the layer's styles around its processed `content` (layer size `layer_size` in layer
+/// pixels, for Gradient Overlay without Align with Layer).
+pub fn render(ctx: &EvalCtx, layer: &Layer, content: &Buf, layer_size: [f64; 2]) -> Styled {
+ let Some(g) = group(layer) else { return Styled { passes: vec![], body: content.clone() } };
+ let styles = evaluate(ctx, layer, g);
+ let bl = blending(ctx, layer);
+ let s = content.scale.max(1e-6);
+ let pad = ((reach(&styles) * s).ceil() + 2.0).min(MAX_PAD) as u32;
+ let mut buf = content.clone();
+ if content.img.is_empty() {
+ return Styled { passes: vec![], body: buf };
+ }
+ buf.pad(pad);
+ let (w, h) = (buf.img.width as usize, buf.img.height as usize);
+ let alpha = Plane::alpha(&buf.img);
+ let d = Lazy(std::sync::OnceLock::new());
+ let seed = layer.id.0 as u32;
+
+ // ---- exterior passes
+ let mut passes = vec![];
+ if let Some(ds) = &styles.drop {
+ let shape = soft_shape(&alpha, &d, ds.size * s, ds.spread, false);
+ let off = [ds.offset[0] * s, ds.offset[1] * s];
+ let img = pass_image(w, h, |x, y| {
+ let mut a = shifted(&shape, x, y, off) * ds.opacity;
+ if ds.knocks_out {
+ a *= 1.0 - alpha.data[y * w + x];
+ }
+ (ds.color, noisy(a, ds.noise, x, y, seed))
+ });
+ passes.push((Buf { img, offset: buf.offset, scale: buf.scale }, ds.mode));
+ }
+ if let Some(gl) = &styles.outer_glow {
+ let v = glow_intensity(&alpha, &d, gl, s, false);
+ let img = pass_image(w, h, |x, y| {
+ let i = y * w + x;
+ let (c, a) = glow_color(gl, v.data[i], x, y);
+ // The glow sits outside the content (knocked out under it).
+ (c, noisy(a * gl.opacity * (1.0 - alpha.data[i]), gl.noise, x, y, seed ^ 0x5a5a))
+ });
+ passes.push((Buf { img, offset: buf.offset, scale: buf.scale }, gl.mode));
+ }
+
+ // ---- body
+ let mut body = buf.img.clone();
+ if !bl.interior_group && bl.fill < 1.0 {
+ body.scale_alpha(bl.fill);
+ }
+ let cov = |i: usize| alpha.data[i];
+ if let Some(go) = &styles.gradient {
+ let (cx, cy, hw, hh) = gradient_frame(go, &buf, &alpha, layer_size);
+ let (ux, uy) = (go.angle.to_radians().cos(), -go.angle.to_radians().sin());
+ let ext = ((hw * ux).abs() + (hh * uy).abs()).max(1e-3) * go.scale;
+ let radius = hw.max(hh).max(1e-3) * go.scale;
+ blend_into(&mut body, go.mode, seed, |x, y| {
+ let (px, py) = (x as f64 + 0.5 - cx, y as f64 + 0.5 - cy);
+ let along = px * ux + py * uy;
+ let across = -px * uy + py * ux;
+ let mut t = match go.style {
+ 1 => (px * px + py * py).sqrt() / radius,
+ 2 => {
+ let a = (-py).atan2(px) - go.angle.to_radians();
+ (a / std::f64::consts::TAU).rem_euclid(1.0)
+ }
+ 3 => along.abs() / ext,
+ 4 => (along.abs() + across.abs()) / ext,
+ _ => 0.5 + along / (2.0 * ext),
+ };
+ if go.reverse {
+ t = 1.0 - t;
+ }
+ let c = go.gradient.sample(t.clamp(0.0, 1.0));
+ ([c[0], c[1], c[2]], c[3] * go.opacity * cov(y * w + x))
+ });
+ }
+ if let Some(co) = &styles.color {
+ blend_into(&mut body, co.mode, seed, |x, y| (co.color, co.opacity * cov(y * w + x)));
+ }
+ if let Some(sa) = &styles.satin {
+ let b = gauss_plane(&alpha, sa.size * s / 2.0, sa.size * s / 2.0);
+ let off = [sa.offset[0] * s, sa.offset[1] * s];
+ blend_into(&mut body, sa.mode, seed, |x, y| {
+ let v = (shifted(&b, x, y, off) - shifted(&b, x, y, [-off[0], -off[1]])).abs().min(1.0);
+ let v = if sa.invert { 1.0 - v } else { v };
+ (sa.color, v * sa.opacity * cov(y * w + x))
+ });
+ }
+ if let Some(gl) = &styles.inner_glow {
+ let v = glow_intensity(&alpha, &d, gl, s, true);
+ blend_into(&mut body, gl.mode, seed, |x, y| {
+ let i = y * w + x;
+ let e = if gl.center { 1.0 - v.data[i] } else { v.data[i] };
+ let (c, a) = glow_color(gl, e, x, y);
+ (c, noisy(a * gl.opacity * cov(i), gl.noise, x, y, seed ^ 0x3c3c))
+ });
+ }
+ if let Some(is) = &styles.inner_shadow {
+ let shape = soft_shape(&alpha, &d, is.size * s, is.spread, true);
+ let off = [is.offset[0] * s, is.offset[1] * s];
+ blend_into(&mut body, is.mode, seed, |x, y| {
+ let a = shifted(&shape, x, y, off).min(1.0) * is.opacity * cov(y * w + x);
+ (is.color, noisy(a, is.noise, x, y, seed ^ 0x1234))
+ });
+ }
+ if bl.interior_group && bl.fill < 1.0 {
+ body.scale_alpha(bl.fill);
+ }
+ if let Some(sk) = &styles.stroke {
+ let sd = d.get(&alpha);
+ let size = (sk.size * s) as f32;
+ let (r_out, r_in) = match sk.position {
+ 1 => (0.0, size),
+ 2 => (size / 2.0, size / 2.0),
+ _ => (size, 0.0),
+ };
+ // Inside part: blended over the body within the content.
+ if r_in > 0.0 {
+ blend_into(&mut body, sk.mode, seed, |x, y| {
+ let i = y * w + x;
+ let ring = (alpha.data[i] - grown(sd.data[i], -r_in)).max(0.0);
+ (sk.color, ring * sk.opacity)
+ });
+ }
+ // Outside part: covers exactly what the content leaves uncovered.
+ if r_out > 0.0 {
+ body.data.par_iter_mut().enumerate().for_each(|(i, p)| {
+ let ring = (grown(sd.data[i], r_out) - alpha.data[i]).max(0.0) * sk.opacity;
+ if ring > 0.0 {
+ let src = [sk.color[0] * ring, sk.color[1] * ring, sk.color[2] * ring, ring];
+ for c in 0..4 {
+ p[c] += src[c];
+ }
+ }
+ });
+ }
+ }
+ if let Some(bv) = &styles.bevel {
+ bevel(&mut body, &alpha, &d, bv, s, seed);
+ }
+ Styled { passes, body: Buf { img: body, offset: buf.offset, scale: buf.scale } }
+}
+
+/// Gradient Overlay frame in buffer pixels: centre and half extents.
+fn gradient_frame(go: &GradOverlay, buf: &Buf, alpha: &Plane, layer_size: [f64; 2]) -> (f64, f64, f64, f64) {
+ let s = buf.scale;
+ let (x0, y0, x1, y1) = if go.align {
+ let img = Image { width: alpha.w as u32, height: alpha.h as u32, data: alpha.data.iter().map(|&a| [0.0, 0.0, 0.0, a]).collect() };
+ match img.alpha_bounds() {
+ Some((a, b, c, d)) => (a as f64, b as f64, c as f64, d as f64),
+ None => (0.0, 0.0, 1.0, 1.0),
+ }
+ } else {
+ let (a, b) = buf.to_px([0.0, 0.0]);
+ let (c, d) = buf.to_px(layer_size);
+ (a, b, c, d)
+ };
+ ((x0 + x1) / 2.0 + go.offset[0] * s, (y0 + y1) / 2.0 + go.offset[1] * s, (x1 - x0) / 2.0, (y1 - y0) / 2.0)
+}
+
+/// Bevel and Emboss: a height field from the content edge, lit by a directional light.
+fn bevel(body: &mut Image, alpha: &Plane, d: &Lazy, bv: &Bevel, s: f64, seed: u32) {
+ let size = (bv.size * s).max(0.5) as f32;
+ let sd = d.get(alpha);
+ let w = alpha.w;
+ // Height profile 0..1 and the region the bevel paints.
+ let style = bv.style;
+ let mut height = sd.map(|v| match style {
+ 0 => (1.0 - v.max(0.0) / size).clamp(0.0, 1.0),
+ 2 | 4 => (0.5 - v / (2.0 * size)).clamp(0.0, 1.0),
+ 3 => (v.abs() / size).clamp(0.0, 1.0),
+ _ => (-v / size + 0.5 / size).clamp(0.0, 1.0),
+ });
+ // The distance field is exact at pixel centres only; smoothing the profile removes the
+ // stair-steps on diagonal edges that lighting would otherwise amplify. Smooth rounds the
+ // profile over the bevel size; Chisel Hard keeps it crisp, Chisel Soft slightly softer.
+ let sigma = match bv.technique {
+ 0 => (size as f64 / 4.0).max(1.0),
+ 2 => 1.5,
+ _ => 0.75,
+ };
+ height = gauss_plane(&height, sigma, sigma);
+ if bv.soften > 0.0 {
+ let sg = bv.soften * s / 2.0;
+ height = gauss_plane(&height, sg, sg);
+ }
+ let sign = if bv.down { -1.0 } else { 1.0 };
+ let k = (size as f64 * bv.depth) as f32 * sign;
+ let (th, al) = (bv.angle.to_radians(), bv.altitude.to_radians());
+ let light = [(al.cos() * th.cos()) as f32, (-al.cos() * th.sin()) as f32, al.sin() as f32];
+ let flat = light[2];
+ let region = |i: usize| -> f32 {
+ let a = alpha.data[i];
+ match style {
+ 0 => (grown(sd.data[i], size) - a).max(0.0),
+ 1 => a,
+ _ => grown(sd.data[i], size),
+ }
+ };
+ let shade = |x: usize, y: usize| -> (f32, f32) {
+ let hx = |xx: i64| height.get_clamped(xx, y as i64);
+ let hy = |yy: i64| height.get_clamped(x as i64, yy);
+ let gx = (hx(x as i64 + 1) - hx(x as i64 - 1)) * 0.5 * k;
+ let gy = (hy(y as i64 + 1) - hy(y as i64 - 1)) * 0.5 * k;
+ let n = [-gx, -gy, 1.0];
+ let len = (n[0] * n[0] + n[1] * n[1] + 1.0).sqrt();
+ let dot = (n[0] * light[0] + n[1] * light[1] + n[2] * light[2]) / len;
+ let hl = ((dot - flat) / (1.0 - flat).max(1e-4)).clamp(0.0, 1.0);
+ let shd = ((flat - dot) / flat.max(1e-4)).clamp(0.0, 1.0);
+ (hl, shd)
+ };
+ blend_into(body, bv.sh.0, seed, |x, y| {
+ let (_, shd) = shade(x, y);
+ (bv.sh.1, shd * bv.sh.2 * region(y * w + x))
+ });
+ blend_into(body, bv.hl.0, seed, |x, y| {
+ let (hl, _) = shade(x, y);
+ (bv.hl.1, hl * bv.hl.2 * region(y * w + x))
+ });
+}
diff --git a/crates/render/src/tests_styles.rs b/crates/render/src/tests_styles.rs
new file mode 100644
index 000000000..34bfe30c1
--- /dev/null
+++ b/crates/render/src/tests_styles.rs
@@ -0,0 +1,416 @@
+//! Layer Styles pixel tests.
+
+use effectcraft_color::Label;
+use effectcraft_keyframe::{Gradient, Keyframe, Value};
+use effectcraft_project::build::{self, Ids};
+use effectcraft_project::styles::{self as st, GROUP};
+use effectcraft_project::{Comp, ItemId, ItemKind, Layer, LayerSource, Project, Solid};
+use effectcraft_time::{FrameRate, Tick};
+
+use crate::{Image, NoFootage, RenderOpts, Renderer, render_frame};
+
+const NORMAL: u32 = 0;
+const MULTIPLY: u32 = 3;
+
+fn setup() -> (Project, ItemId, Comp) {
+ let mut p = Project::default();
+ let comp = Comp::new(200, 100, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
+ let cid = p.add_item("Comp", Label::Sandstone, None, ItemKind::Comp(comp.clone().into()));
+ (p, cid, comp)
+}
+
+fn solid(p: &mut Project, comp: &Comp, color: [f32; 3], w: u32, h: u32) -> Layer {
+ let sid = p.add_item("Solid", Label::Red, None, ItemKind::Solid(Solid { color, width: w, height: h, pixel_aspect: 1.0 }));
+ build::layer(p, comp, "Solid", LayerSource::Solid { item: sid }, (w, h), None)
+}
+
+fn add(p: &mut Project, comp: &Comp, l: &mut Layer, style: &str) {
+ let mut next = p.next_id;
+ st::add_style(l, &mut Ids(&mut next), style, &comp.global_light, true).unwrap();
+ p.next_id = next;
+}
+
+fn set(l: &mut Layer, path: &str, v: Value) {
+ l.props.prop_mut(&format!("{GROUP}/{path}")).unwrap_or_else(|| panic!("no {path}")).value = v;
+}
+
+/// A 40×40 square of `color` centred in a 200×100 comp (x 80..120, y 30..70) over an optional
+/// full-frame background.
+fn scene(color: [f32; 3], bg: Option<[f32; 3]>, f: impl FnOnce(&mut Project, &Comp, &mut Layer)) -> (Project, ItemId) {
+ let (mut p, cid, comp) = setup();
+ let mut l = solid(&mut p, &comp, color, 40, 40);
+ f(&mut p, &comp, &mut l);
+ let mut layers = vec![l];
+ if let Some(bg) = bg {
+ layers.push(solid(&mut p, &comp, bg, 200, 100));
+ }
+ p.comp_mut(cid).unwrap().layers = layers;
+ (p, cid)
+}
+
+fn render(p: &Project, cid: ItemId) -> Image {
+ render_frame(p, cid, Tick::ZERO, 1.0)
+}
+
+fn near(a: f32, b: f32, tol: f32) -> bool {
+ (a - b).abs() <= tol
+}
+
+#[test]
+fn drop_shadow_offset_colour_and_opacity() {
+ let (p, cid) = scene([1.0; 3], Some([0.5; 3]), |p, c, l| {
+ add(p, c, l, "dropShadow");
+ set(l, "dropShadow/size", Value::Scalar(0.0));
+ set(l, "dropShadow/distance", Value::Scalar(10.0));
+ set(l, "dropShadow/opacity", Value::Scalar(100.0));
+ set(l, "dropShadow/blendMode", Value::Enum(NORMAL));
+ });
+ let img = render(&p, cid);
+ // Global light 120° → the shadow falls down-right by (5, 8.66).
+ assert!(near(img.get(123, 75)[0], 0.0, 0.02), "shadow: {:?}", img.get(123, 75));
+ assert!(near(img.get(82, 75)[0], 0.5, 0.01), "left of the shadow stays grey");
+ assert!(near(img.get(100, 50)[0], 1.0, 0.01), "layer on top");
+ assert!(near(img.get(100, 20)[0], 0.5, 0.01), "above the layer");
+
+ // 75 % Multiply (the default mode) over grey: 0.5 × (1 − 0.75).
+ let (p, cid) = scene([1.0; 3], Some([0.5; 3]), |p, c, l| {
+ add(p, c, l, "dropShadow");
+ set(l, "dropShadow/size", Value::Scalar(0.0));
+ set(l, "dropShadow/distance", Value::Scalar(10.0));
+ set(l, "dropShadow/color", Value::Color([0.0, 0.0, 0.0, 1.0]));
+ });
+ let img = render(&p, cid);
+ assert!(near(img.get(123, 75)[0], 0.125, 0.02), "{:?}", img.get(123, 75));
+
+ // Coloured shadow on a transparent comp extends the layer's bounds.
+ let (p, cid) = scene([1.0; 3], None, |p, c, l| {
+ add(p, c, l, "dropShadow");
+ set(l, "dropShadow/size", Value::Scalar(0.0));
+ set(l, "dropShadow/distance", Value::Scalar(10.0));
+ set(l, "dropShadow/opacity", Value::Scalar(50.0));
+ set(l, "dropShadow/blendMode", Value::Enum(NORMAL));
+ set(l, "dropShadow/color", Value::Color([0.0, 0.0, 1.0, 1.0]));
+ });
+ let img = render(&p, cid);
+ let px = img.straight(123, 75);
+ assert!(near(px[3], 0.5, 0.02) && near(px[2], 1.0, 0.01) && px[0] < 0.01, "{px:?}");
+}
+
+#[test]
+fn soft_shadow_falls_off() {
+ let (p, cid) = scene([1.0; 3], None, |p, c, l| {
+ add(p, c, l, "dropShadow");
+ set(l, "dropShadow/size", Value::Scalar(10.0));
+ set(l, "dropShadow/distance", Value::Scalar(0.0));
+ set(l, "dropShadow/opacity", Value::Scalar(100.0));
+ });
+ let img = render(&p, cid);
+ let a1 = img.get(121, 50)[3];
+ let a5 = img.get(125, 50)[3];
+ let a20 = img.get(140, 50)[3];
+ assert!(a1 > a5 && a5 > a20, "{a1} {a5} {a20}");
+ assert!(a20 < 0.01);
+}
+
+#[test]
+fn stroke_positions() {
+ let render_stroke = |pos: u32| {
+ let (p, cid) = scene([1.0; 3], None, |p, c, l| {
+ add(p, c, l, "stroke");
+ set(l, "stroke/size", Value::Scalar(4.0));
+ set(l, "stroke/position", Value::Enum(pos));
+ });
+ render(&p, cid)
+ };
+ let red = |px: [f32; 4]| px[0] > 0.98 && px[1] < 0.02 && px[3] > 0.98;
+ let white = |px: [f32; 4]| px[0] > 0.98 && px[1] > 0.98 && px[3] > 0.98;
+ // Outside: 4 px ring beyond the right edge (x = 120).
+ let o = render_stroke(0);
+ assert!(red(o.get(122, 50)) && red(o.get(123, 50)), "{:?}", o.get(122, 50));
+ assert!(o.get(126, 50)[3] < 0.01);
+ assert!(white(o.get(118, 50)));
+ // Inside: the ring is within the layer.
+ let i = render_stroke(1);
+ assert!(red(i.get(118, 50)) && red(i.get(117, 50)));
+ assert!(white(i.get(110, 50)));
+ assert!(i.get(122, 50)[3] < 0.01);
+ // Centre: 2 px on each side.
+ let c = render_stroke(2);
+ assert!(red(c.get(119, 50)) && red(c.get(120, 50)) && red(c.get(121, 50)));
+ assert!(white(c.get(116, 50)));
+ assert!(c.get(124, 50)[3] < 0.01);
+}
+
+#[test]
+fn colour_overlay_blend_modes() {
+ let (p, cid) = scene([1.0; 3], None, |p, c, l| {
+ add(p, c, l, "colorOverlay");
+ set(l, "colorOverlay/color", Value::Color([0.0, 0.0, 1.0, 1.0]));
+ set(l, "colorOverlay/opacity", Value::Scalar(50.0));
+ });
+ let px = render(&p, cid).get(100, 50);
+ assert!(near(px[0], 0.5, 0.01) && near(px[2], 1.0, 0.01), "{px:?}");
+
+ let (p, cid) = scene([0.5, 1.0, 1.0], None, |p, c, l| {
+ add(p, c, l, "colorOverlay");
+ set(l, "colorOverlay/color", Value::Color([1.0, 0.5, 0.0, 1.0]));
+ set(l, "colorOverlay/blendMode", Value::Enum(MULTIPLY));
+ });
+ let img = render(&p, cid);
+ let px = img.get(100, 50);
+ assert!(near(px[0], 0.5, 0.01) && near(px[1], 0.5, 0.01) && near(px[2], 0.0, 0.01), "{px:?}");
+ // Overlays stay inside the layer.
+ assert!(img.get(130, 50)[3] < 0.01);
+}
+
+#[test]
+fn gradient_overlay_follows_angle() {
+ let (p, cid) = scene([1.0; 3], None, |p, c, l| {
+ add(p, c, l, "gradientOverlay");
+ });
+ let img = render(&p, cid);
+ // 90°: black at the bottom, white at the top.
+ let top = img.get(100, 31)[0];
+ let bottom = img.get(100, 68)[0];
+ assert!(top > 0.9 && bottom < 0.1, "{top} {bottom}");
+ let (p, cid) = scene([1.0; 3], None, |p, c, l| {
+ add(p, c, l, "gradientOverlay");
+ set(l, "gradientOverlay/angle", Value::Scalar(0.0));
+ set(l, "gradientOverlay/reverse", Value::Bool(true));
+ });
+ let img = render(&p, cid);
+ assert!(img.get(81, 50)[0] > 0.9 && img.get(118, 50)[0] < 0.1);
+}
+
+fn bevel_scene(angle: f64) -> Image {
+ let (p, cid) = scene([0.5; 3], None, |p, c, l| {
+ add(p, c, l, "bevelEmboss");
+ set(l, "bevelEmboss/size", Value::Scalar(6.0));
+ set(l, "blendingOptions/globalLightAngle", Value::Scalar(angle));
+ });
+ render(&p, cid)
+}
+
+#[test]
+fn bevel_lights_the_side_facing_the_light() {
+ // Light from the upper left (120°): left and top edges brighten, right and bottom darken.
+ let img = bevel_scene(120.0);
+ let (l, r, t, b, mid) = (img.get(82, 50)[0], img.get(117, 50)[0], img.get(100, 32)[0], img.get(100, 67)[0], img.get(100, 50)[0]);
+ assert!(l > 0.6 && t > 0.6, "highlights {l} {t}");
+ assert!(r < 0.4 && b < 0.4, "shadows {r} {b}");
+ assert!(near(mid, 0.5, 0.02), "flat centre {mid}");
+ // Light from the lower right (−60°) swaps them.
+ let img = bevel_scene(-60.0);
+ assert!(img.get(82, 50)[0] < 0.4 && img.get(117, 50)[0] > 0.6);
+}
+
+#[test]
+fn global_light_drives_linked_styles() {
+ let shadow_at = |use_global: bool| {
+ let (p, cid) = scene([1.0; 3], None, |p, c, l| {
+ add(p, c, l, "dropShadow");
+ set(l, "dropShadow/size", Value::Scalar(0.0));
+ set(l, "dropShadow/distance", Value::Scalar(10.0));
+ set(l, "dropShadow/opacity", Value::Scalar(100.0));
+ set(l, "dropShadow/useGlobalLight", Value::Bool(use_global));
+ set(l, "dropShadow/angle", Value::Scalar(90.0));
+ set(l, "blendingOptions/globalLightAngle", Value::Scalar(0.0));
+ });
+ render(&p, cid)
+ };
+ // Global light at 0° (from the right): shadow to the left.
+ let g = shadow_at(true);
+ assert!(g.get(75, 50)[3] > 0.98 && g.get(100, 75)[3] < 0.01);
+ // Own angle 90° (from above): shadow below.
+ let o = shadow_at(false);
+ assert!(o.get(100, 75)[3] > 0.98 && o.get(75, 50)[3] < 0.01);
+}
+
+#[test]
+fn glows_and_inner_shadow() {
+ let (p, cid) = scene([0.0, 0.0, 0.0], None, |p, c, l| {
+ add(p, c, l, "outerGlow");
+ add(p, c, l, "innerGlow");
+ set(l, "outerGlow/opacity", Value::Scalar(100.0));
+ set(l, "outerGlow/size", Value::Scalar(8.0));
+ set(l, "innerGlow/opacity", Value::Scalar(100.0));
+ set(l, "innerGlow/size", Value::Scalar(8.0));
+ });
+ let img = render(&p, cid);
+ let out_near = img.straight(121, 50);
+ assert!(out_near[3] > 0.6 && out_near[0] > 0.9 && out_near[2] < 0.9, "glow colour {out_near:?}");
+ assert!(img.get(140, 50)[3] < 0.02, "glow fades");
+ let edge = img.get(119, 50);
+ let centre = img.get(100, 50);
+ assert!(edge[0] > 0.6 && centre[0] < 0.05, "inner glow from the edge {edge:?} {centre:?}");
+
+ // Inner glow from the centre instead.
+ let (p, cid) = scene([0.0; 3], None, |p, c, l| {
+ add(p, c, l, "innerGlow");
+ set(l, "innerGlow/source", Value::Enum(0));
+ set(l, "innerGlow/opacity", Value::Scalar(100.0));
+ });
+ let img = render(&p, cid);
+ assert!(img.get(100, 50)[0] > 0.9 && img.get(119, 50)[0] < 0.6);
+
+ let (p, cid) = scene([1.0; 3], None, |p, c, l| {
+ add(p, c, l, "innerShadow");
+ set(l, "innerShadow/size", Value::Scalar(0.0));
+ set(l, "innerShadow/opacity", Value::Scalar(100.0));
+ set(l, "innerShadow/blendMode", Value::Enum(NORMAL));
+ });
+ let img = render(&p, cid);
+ // Light from the upper left: the shadow lines the top-left inside edges.
+ assert!(img.get(81, 50)[0] < 0.05 && img.get(100, 32)[0] < 0.05, "{:?}", img.get(81, 50));
+ assert!(img.get(117, 50)[0] > 0.95 && img.get(100, 66)[0] > 0.95);
+ assert!(img.get(76, 50)[3] < 0.01, "inner shadow stays inside");
+}
+
+#[test]
+fn satin_shades_inside() {
+ let (p, cid) = scene([1.0; 3], None, |p, c, l| add(p, c, l, "satin"));
+ let img = render(&p, cid);
+ let vals: Vec = (82..118).map(|x| img.get(x, 50)[0]).collect();
+ let min = vals.iter().cloned().fold(1.0, f32::min);
+ assert!(min < 0.9, "satin darkens somewhere: {min}");
+ assert!(img.get(130, 50)[3] < 0.01);
+}
+
+#[test]
+fn fill_opacity_knockout_and_channels() {
+ // Fill 0: the content disappears but the stroke stays.
+ let (p, cid) = scene([1.0; 3], None, |p, c, l| {
+ add(p, c, l, "stroke");
+ set(l, "blendingOptions/advancedBlending/fillOpacity", Value::Scalar(0.0));
+ });
+ let img = render(&p, cid);
+ assert!(img.get(100, 50)[3] < 0.01 && img.get(122, 50)[0] > 0.98);
+
+ // Interior styles ignore Fill Opacity unless blended as a group.
+ let overlay = |group: bool| {
+ let (p, cid) = scene([1.0; 3], None, |p, c, l| {
+ add(p, c, l, "colorOverlay");
+ set(l, "blendingOptions/advancedBlending/fillOpacity", Value::Scalar(0.0));
+ set(l, "blendingOptions/advancedBlending/blendInteriorAsGroup", Value::Bool(group));
+ });
+ render(&p, cid).get(100, 50)
+ };
+ assert!(overlay(false)[3] > 0.98 && overlay(true)[3] < 0.01);
+
+ // Knockout with Fill 0 punches through the background.
+ let (p, cid) = scene([1.0; 3], Some([0.5; 3]), |p, c, l| {
+ add(p, c, l, "stroke");
+ set(l, "blendingOptions/advancedBlending/fillOpacity", Value::Scalar(0.0));
+ set(l, "blendingOptions/advancedBlending/knockout", Value::Enum(2));
+ });
+ let img = render(&p, cid);
+ assert!(img.get(100, 50)[3] < 0.01 && img.get(150, 50)[3] > 0.99);
+
+ // Red channel off: the white layer leaves red from below.
+ let (p, cid) = scene([1.0; 3], Some([0.0; 3]), |p, c, l| {
+ add(p, c, l, "stroke");
+ set(l, "blendingOptions/advancedBlending/red", Value::Bool(false));
+ });
+ let px = render(&p, cid).get(100, 50);
+ assert!(px[0] < 0.01 && px[1] > 0.99 && px[2] > 0.99, "{px:?}");
+}
+
+#[test]
+fn eye_switch_and_group_switch() {
+ let (mut p, cid) = scene([1.0; 3], None, |p, c, l| {
+ add(p, c, l, "stroke");
+ });
+ assert!(render(&p, cid).get(122, 50)[3] > 0.98);
+ p.comp_mut(cid).unwrap().layers[0].props.group_mut(&format!("{GROUP}/stroke")).unwrap().enabled = false;
+ assert!(render(&p, cid).get(122, 50)[3] < 0.01);
+ p.comp_mut(cid).unwrap().layers[0].props.group_mut(&format!("{GROUP}/stroke")).unwrap().enabled = true;
+ p.comp_mut(cid).unwrap().layers[0].props.group_mut(GROUP).unwrap().enabled = false;
+ assert!(render(&p, cid).get(122, 50)[3] < 0.01);
+}
+
+#[test]
+fn styles_respect_render_scale() {
+ let (p, cid) = scene([1.0; 3], None, |p, c, l| {
+ add(p, c, l, "dropShadow");
+ add(p, c, l, "stroke");
+ set(l, "dropShadow/size", Value::Scalar(0.0));
+ set(l, "dropShadow/distance", Value::Scalar(20.0));
+ set(l, "dropShadow/opacity", Value::Scalar(100.0));
+ set(l, "stroke/size", Value::Scalar(4.0));
+ });
+ let full = render_frame(&p, cid, Tick::ZERO, 1.0);
+ let half = render_frame(&p, cid, Tick::ZERO, 0.5);
+ // Shadow offset (10, 17.3): at half resolution the shadow sits at half the distance.
+ assert!(full.get(125, 85)[3] > 0.98);
+ assert!(half.get(62, 42)[3] > 0.98 && half.get(55, 25)[3] > 0.98);
+ // Stroke 4 px → 2 px at half.
+ assert!(half.get(61, 25)[0] > 0.98 && half.get(61, 25)[1] < 0.05);
+ assert!(half.get(64, 25)[3] < 0.01 || half.get(64, 25)[1] < 0.05);
+}
+
+#[test]
+fn animated_style_properties() {
+ let (mut p, cid) = scene([1.0; 3], None, |p, c, l| add(p, c, l, "stroke"));
+ let l = &mut p.comp_mut(cid).unwrap().layers[0];
+ l.props.prop_mut(&format!("{GROUP}/stroke/size")).unwrap().keys =
+ vec![Keyframe::new(Tick::ZERO, Value::Scalar(2.0)), Keyframe::new(Tick::from_seconds_f64(1.0), Value::Scalar(10.0))];
+ let a = render_frame(&p, cid, Tick::ZERO, 1.0);
+ let b = render_frame(&p, cid, Tick::from_seconds_f64(1.0), 1.0);
+ assert!(a.get(126, 50)[3] < 0.01 && b.get(126, 50)[3] > 0.98);
+}
+
+fn render_cached(p: &Project, cid: ItemId, cache: &crate::LayerCache) -> Image {
+ let mut r = Renderer::new(p, &NoFootage, RenderOpts::default());
+ r.cache = Some(cache);
+ r.comp_frame(cid, Tick::ZERO)
+}
+
+#[test]
+fn style_edits_invalidate_the_cache() {
+ let (mut p, cid) = scene([1.0; 3], Some([0.5; 3]), |p, c, l| {
+ add(p, c, l, "dropShadow");
+ add(p, c, l, "stroke");
+ });
+ let cache = crate::LayerCache::default();
+ let a = render_cached(&p, cid, &cache);
+ assert_eq!(a.data, render(&p, cid).data);
+ let again = render_cached(&p, cid, &cache);
+ assert_eq!(a.data, again.data);
+ // Change a style value: the styled layer re-renders, its content (and the background) come
+ // from the cache.
+ let hits0 = cache.stats().hits;
+ let l = &mut p.comp_mut(cid).unwrap().layers[0];
+ l.props.prop_mut(&format!("{GROUP}/stroke/color")).unwrap().value = Value::Color([0.0, 1.0, 0.0, 1.0]);
+ let b = render_cached(&p, cid, &cache);
+ assert_eq!(b.data, render(&p, cid).data);
+ assert_ne!(a.data, b.data);
+ assert!(cache.stats().hits >= hits0 + 2, "content + background reused");
+ // Global light change (linked) also invalidates.
+ let l = &mut p.comp_mut(cid).unwrap().layers[0];
+ l.props.prop_mut(&format!("{GROUP}/blendingOptions/globalLightAngle")).unwrap().value = Value::Scalar(0.0);
+ let c = render_cached(&p, cid, &cache);
+ assert_eq!(c.data, render(&p, cid).data);
+ assert_ne!(b.data, c.data);
+ // Eye switch off.
+ p.comp_mut(cid).unwrap().layers[0].props.group_mut(&format!("{GROUP}/dropShadow")).unwrap().enabled = false;
+ let d = render_cached(&p, cid, &cache);
+ assert_eq!(d.data, render(&p, cid).data);
+ assert_ne!(c.data, d.data);
+}
+
+#[test]
+fn gradient_glow_uses_gradient() {
+ let (p, cid) = scene([0.0; 3], None, |p, c, l| {
+ add(p, c, l, "outerGlow");
+ set(l, "outerGlow/colorType", Value::Enum(1));
+ set(l, "outerGlow/opacity", Value::Scalar(100.0));
+ set(
+ l,
+ "outerGlow/colors",
+ Value::Gradient(Gradient { colors: vec![(0.0, [1.0, 0.0, 0.0, 1.0]), (1.0, [0.0, 0.0, 1.0, 1.0])], opacities: vec![(0.0, 1.0), (1.0, 0.0)] }),
+ );
+ });
+ let img = render(&p, cid);
+ let px = img.straight(121, 50);
+ assert!(px[0] > px[2], "near the edge the glow takes the gradient's start colour {px:?}");
+}
diff --git a/crates/ui-egui/examples/snapshot.rs b/crates/ui-egui/examples/snapshot.rs
index e98acbdaf..e15c135bd 100644
--- a/crates/ui-egui/examples/snapshot.rs
+++ b/crates/ui-egui/examples/snapshot.rs
@@ -114,6 +114,25 @@ fn main() {
}
continue;
}
+ // Pointer input straight into the harness (menus and popups need real input events):
+ // {"method":"pointer","params":{"x":237,"y":12,"click":true}}
+ if method == "pointer" {
+ let pos = egui::pos2(params["x"].as_f64().unwrap_or(0.0) as f32, params["y"].as_f64().unwrap_or(0.0) as f32);
+ harness.input_mut().events.push(egui::Event::PointerMoved(pos));
+ if params["click"].as_bool() == Some(true) {
+ for pressed in [true, false] {
+ harness.input_mut().events.push(egui::Event::PointerButton {
+ pos,
+ button: egui::PointerButton::Primary,
+ pressed,
+ modifiers: Default::default(),
+ });
+ }
+ }
+ settle(&mut harness, 0.3);
+ println!("{}", json!({"method": method, "reply": {"ok": true}}));
+ continue;
+ }
let (reply_tx, reply_rx) = mpsc::channel();
let _ = tx.send(ControlRequest { method: method.clone(), params, reply: reply_tx });
// Requests are answered on a later frame (some wait for input to be processed).
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 743e79c0c..9084b7d28 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -42,6 +42,16 @@ pub enum Dialog {
CompSettings,
SolidSettings,
CommandPalette,
+ /// Settings (Preferences) on `dialog_state.settings_page`.
+ Settings,
+ /// Edit ▸ Keyboard Shortcuts.
+ Shortcuts,
+ /// A generic parameter form for a command (`dialog_state.form`).
+ Form,
+ /// A message (`dialog_state.info`).
+ Info,
+ /// View ▸ View Options.
+ ViewOptions,
CameraSettings,
LightSettings,
KeyVelocity,
@@ -504,6 +514,12 @@ impl EffectcraftApp {
effectcraft_engine::Event::Toast { message, .. } => self.toast = Some((message, ctx.input(|i| i.time))),
effectcraft_engine::Event::OpenUrl(url) => ctx.open_url(egui::OpenUrl::new_tab(url)),
effectcraft_engine::Event::ProjectChanged { .. } => {}
+ effectcraft_engine::Event::Frontend { command, params } => {
+ if let Err(e) = crate::menus::frontend(self, ctx, &command, params) {
+ self.ui.status = e;
+ }
+ }
+ effectcraft_engine::Event::PurgeCaches => self.frames.clear(),
}
}
}
diff --git a/crates/ui-egui/src/menus.rs b/crates/ui-egui/src/menus.rs
index 0f5ec7f62..a81ac54a1 100644
--- a/crates/ui-egui/src/menus.rs
+++ b/crates/ui-egui/src/menus.rs
@@ -1,13 +1,16 @@
-//! Menus, keyboard shortcuts and UI-level commands. The menu bar is generated from the engine
-//! registry plus the UI command table (commands that only affect the frontend: tools, playback,
-//! viewer zoom, panels, reveal shortcuts). `invoke` is the single entry point used by menus,
-//! shortcuts and the control channel.
+//! Menus, keyboard shortcuts and UI-level commands. The menu bar is the engine's After Effects
+//! menu tree (`effectcraft_engine::menus`): every entry is an engine command, and frontend-only
+//! commands (viewer zoom, panels, dialogs…) come back as `Event::Frontend` and are performed by
+//! [`frontend`]. [`UI_COMMANDS`] holds the remaining UI-only shortcuts (tools, timeline
+//! navigation, reveal keys). `invoke` is the single entry point used by menus, shortcuts and the
+//! control channel.
use serde_json::{Value, json};
use crate::EffectcraftApp;
use crate::dock::PanelKind;
use crate::state::{Resolution, Tool};
+use effectcraft_engine::menus::{MenuEntry, MenuNode};
pub struct UiCommand {
pub id: &'static str,
@@ -22,32 +25,23 @@ macro_rules! uic {
};
}
+/// UI-only commands (not in the AE menus; shortcuts and the command palette).
pub const UI_COMMANDS: &[UiCommand] = &[
- uic!("playback.toggle", "Play/Stop", ["Composition", "Preview"], Some("Space")),
- uic!("playback.ramPreview", "Play Current Preview", ["Composition", "Preview"], Some("Num0")),
+ uic!("playback.ramPreview", "Play Current Preview", [], Some("Num0")),
uic!("playback.stop", "Stop", [], None),
- uic!("view.zoomIn", "Zoom In", ["View"], Some(".")),
- uic!("view.zoomOut", "Zoom Out", ["View"], Some(",")),
- uic!("view.fit", "Fit", ["View"], Some("Shift+/")),
- uic!("view.actualSize", "100%", ["View"], Some("/")),
- uic!("view.res.full", "Full", ["View", "Resolution"], Some("Cmd+J")),
- uic!("view.res.half", "Half", ["View", "Resolution"], Some("Cmd+Shift+J")),
- uic!("view.res.third", "Third", ["View", "Resolution"], None),
- uic!("view.res.quarter", "Quarter", ["View", "Resolution"], Some("Cmd+Alt+Shift+J")),
- uic!("view.res.auto", "Auto", ["View", "Resolution"], None),
- uic!("view.rulers", "Show Rulers", ["View"], Some("Cmd+R")),
- uic!("view.grid", "Show Grid", ["View"], Some("Cmd+'")),
- uic!("view.safeMargins", "Title/Action Safe", ["View"], None),
- uic!("view.transparencyGrid", "Transparency Grid", ["View"], None),
- uic!("view.layerControls", "Show Layer Controls", ["View"], Some("Cmd+Shift+H")),
- uic!("view.fastPreviews", "Fast Previews", ["View"], None),
- uic!("view.theme.dark", "Dark", ["View", "Appearance"], None),
- uic!("view.theme.darker", "Darker", ["View", "Appearance"], None),
- uic!("view.theme.light", "Light", ["View", "Appearance"], None),
+ uic!("view.fit", "Fit", [], Some("Shift+/")),
+ uic!("view.actualSize", "100%", [], Some("/")),
+ uic!("view.res.auto", "Resolution: Auto", [], None),
+ uic!("view.safeMargins", "Title/Action Safe", [], None),
+ uic!("view.transparencyGrid", "Transparency Grid", [], None),
+ uic!("view.fastPreviews", "Fast Previews", [], None),
+ uic!("view.theme.dark", "Theme: Dark", [], None),
+ uic!("view.theme.darker", "Theme: Darker", [], None),
+ uic!("view.theme.light", "Theme: Light", [], None),
uic!("timeline.zoomIn", "Zoom In Time", [], Some("=")),
uic!("timeline.zoomOut", "Zoom Out Time", [], Some("-")),
uic!("timeline.zoomFit", "Zoom to Fit Comp", [], Some(";")),
- uic!("timeline.graphEditor", "Graph Editor", ["Window"], Some("Shift+F3")),
+ uic!("timeline.graphEditor", "Graph Editor", [], Some("Shift+F3")),
uic!("timeline.switchesModes", "Toggle Switches / Modes", [], Some("F4")),
uic!("timeline.workAreaBegin", "Set Work Area Begin", [], Some("B")),
uic!("timeline.workAreaEnd", "Set Work Area End", [], Some("N")),
@@ -60,25 +54,12 @@ pub const UI_COMMANDS: &[UiCommand] = &[
uic!("timeline.reveal.rotation", "Reveal Rotation", [], Some("R")),
uic!("timeline.reveal.opacity", "Reveal Opacity", [], Some("T")),
uic!("timeline.reveal.anchor", "Reveal Anchor Point", [], Some("A")),
- uic!("timeline.reveal.animated", "Reveal Animated Properties", ["Animation"], Some("U")),
uic!("timeline.reveal.effects", "Reveal Effects", [], Some("E")),
uic!("timeline.reveal.masks", "Reveal Masks", [], Some("M")),
uic!("timeline.reveal.feather", "Reveal Mask Feather", [], Some("F")),
uic!("timeline.reveal.levels", "Reveal Audio Levels (press twice: Waveform)", [], Some("L")),
uic!("timeline.reveal.waveform", "Reveal Audio Waveform", [], None),
- uic!("playback.muteAudio", "Mute Audio", ["Composition", "Preview"], None),
uic!("timeline.collapseAll", "Collapse All", [], Some("Cmd+`")),
- uic!("window.workspace.default", "Default", ["Window", "Workspace"], Some("Shift+F10")),
- uic!("window.workspace.standard", "Standard", ["Window", "Workspace"], Some("Shift+F11")),
- uic!("window.workspace.smallscreen", "Small Screen", ["Window", "Workspace"], Some("Shift+F12")),
- uic!("window.workspace.animation", "Animation", ["Window", "Workspace"], None),
- uic!("window.workspace.effects", "Effects", ["Window", "Workspace"], None),
- uic!("window.workspace.motiontracking", "Motion Tracking", ["Window", "Workspace"], None),
- uic!("window.workspace.paint", "Paint", ["Window", "Workspace"], None),
- uic!("window.workspace.text", "Text", ["Window", "Workspace"], None),
- uic!("window.workspace.minimal", "Minimal", ["Window", "Workspace"], None),
- uic!("window.workspace.allpanels", "All Panels", ["Window", "Workspace"], None),
- uic!("window.workspace.reset", "Reset to Saved Layout", ["Window", "Workspace"], None),
uic!("tool.selection", "Selection Tool", [], Some("V")),
uic!("tool.hand", "Hand Tool", [], Some("H")),
uic!("tool.zoom", "Zoom Tool", [], Some("Z")),
@@ -93,12 +74,10 @@ pub const UI_COMMANDS: &[UiCommand] = &[
uic!("tool.brush", "Brush Tools", [], Some("Cmd+B")),
uic!("tool.rotoBrush", "Roto Brush Tool", [], Some("Alt+W")),
uic!("tool.puppet", "Puppet Tools", [], Some("Cmd+P")),
- uic!("app.newComp", "New Composition…", [], None),
- uic!("app.compSettings", "Composition Settings…", [], None),
- uic!("app.solidSettings", "New Solid…", [], None),
- uic!("app.commandPalette", "Command Palette…", ["Window"], Some("Cmd+Shift+P")),
- uic!("app.about", "About EffectCraft", ["Help"], None),
- uic!("app.home", "Home", ["Window"], None),
+ uic!("app.newComp", "New Composition...", [], None),
+ uic!("app.compSettings", "Composition Settings...", [], None),
+ uic!("app.solidSettings", "New Solid...", [], None),
+ uic!("app.home", "Home", [], None),
];
pub fn panel_command_id(p: PanelKind) -> String {
@@ -127,6 +106,10 @@ fn reveal(app: &mut EffectcraftApp, kind: &str, now: f64) {
app.ui.timeline.open_layers = sel.iter().map(|l| l.0).collect();
}
+fn no_params(p: &Value) -> bool {
+ p.as_object().is_none_or(|m| m.is_empty())
+}
+
/// Execute a UI or engine command by id.
pub fn invoke(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: Value) -> Result {
let now = ctx.input(|i| i.time);
@@ -134,20 +117,15 @@ pub fn invoke(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: V
if crate::panels::dialogs_3d::route(app, id, ¶ms)? {
return Ok(Value::Null);
}
+ // Legacy per-panel / per-workspace ids (`window.panel.Project`, `window.workspace.default`).
if let Some(rest) = id.strip_prefix("window.panel.") {
- let p = PanelKind::from_name(rest).ok_or_else(|| format!("unknown panel `{rest}`"))?;
- app.show_panel(p);
- return Ok(Value::Null);
+ return frontend(app, ctx, "window.panel", json!({"panel": rest}));
}
if let Some(ws) = id.strip_prefix("window.workspace.") {
if ws == "reset" {
- let name = app.ui.workspace.clone();
- app.set_workspace(&name);
- return Ok(Value::Null);
+ return frontend(app, ctx, "window.resetWorkspace", json!({}));
}
- let name = crate::dock::WORKSPACES.iter().find(|w| w.to_ascii_lowercase().replace(' ', "") == ws).ok_or_else(|| format!("unknown workspace `{ws}`"))?;
- app.set_workspace(name);
- return Ok(json!({"workspace": name}));
+ return frontend(app, ctx, "window.workspace", json!({"name": ws}));
}
if let Some(t) = id.strip_prefix("tool.") {
// Slot shortcuts cycle through the slot's tools.
@@ -178,11 +156,14 @@ pub fn invoke(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: V
return Ok(json!({"tool": tool}));
}
if let Some(k) = id.strip_prefix("timeline.reveal.") {
+ if k == "animated" {
+ return run_engine(app, ctx, "anim.reveal", json!({"kind": "keyframes"}));
+ }
reveal(app, k, now);
return Ok(Value::Null);
}
- if let Some(r) = id.strip_prefix("view.res.") {
- app.ui.viewer.res = Resolution::ALL.into_iter().find(|x| x.label().eq_ignore_ascii_case(r)).ok_or("unknown resolution")?;
+ if id == "view.res.auto" {
+ app.ui.viewer.res = Resolution::Auto;
return Ok(Value::Null);
}
if let Some(th) = id.strip_prefix("view.theme.") {
@@ -192,7 +173,7 @@ pub fn invoke(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: V
}
let timing = |app: &mut EffectcraftApp, op: &str| app.session.execute("layer.timing", json!({"op": op})).map_err(|e| e.to_string());
match id {
- "playback.toggle" | "playback.ramPreview" => {
+ "playback.ramPreview" => {
app.toggle_play(now);
return Ok(json!({"playing": app.playback.playing}));
}
@@ -200,24 +181,6 @@ pub fn invoke(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: V
app.stop();
return Ok(Value::Null);
}
- "playback.muteAudio" => {
- app.ui.preview_audio = !app.ui.preview_audio;
- if !app.ui.preview_audio {
- app.audio = None;
- }
- return Ok(json!({"muted": !app.ui.preview_audio}));
- }
- "view.zoomIn" | "view.zoomOut" => {
- let cur = app.ui.viewer.zoom.unwrap_or_else(|| crate::panels::viewer::last_fit(ctx));
- const STEPS: [f32; 16] = [0.015, 0.03, 0.0625, 0.125, 0.25, 0.333, 0.5, 0.66, 1.0, 1.5, 2.0, 3.0, 4.0, 8.0, 16.0, 32.0];
- let next = if id == "view.zoomIn" {
- STEPS.iter().copied().find(|s| *s > cur + 1e-3).unwrap_or(32.0)
- } else {
- STEPS.iter().rev().copied().find(|s| *s < cur - 1e-3).unwrap_or(0.015)
- };
- app.ui.viewer.zoom = Some(next);
- return Ok(json!({"zoom": next}));
- }
"view.fit" => {
app.ui.viewer.zoom = None;
app.ui.viewer.pan = [0.0, 0.0];
@@ -228,11 +191,8 @@ pub fn invoke(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: V
app.ui.viewer.pan = [0.0, 0.0];
return Ok(Value::Null);
}
- "view.rulers" => app.ui.viewer.rulers = !app.ui.viewer.rulers,
- "view.grid" => app.ui.viewer.grid = !app.ui.viewer.grid,
"view.safeMargins" => app.ui.viewer.safe_margins = !app.ui.viewer.safe_margins,
"view.transparencyGrid" => app.ui.viewer.transparency_grid = !app.ui.viewer.transparency_grid,
- "view.layerControls" => app.ui.viewer.show_layer_controls = !app.ui.viewer.show_layer_controls,
"view.fastPreviews" => app.ui.viewer.fast_preview = !app.ui.viewer.fast_preview,
"timeline.zoomIn" | "timeline.zoomOut" => {
let k = if id == "timeline.zoomIn" { 1.5 } else { 1.0 / 1.5 };
@@ -253,31 +213,38 @@ pub fn invoke(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: V
"timeline.moveOutToTime" => return timing(app, "moveOutToTime"),
"timeline.trimInToTime" => return timing(app, "trimInToTime"),
"timeline.trimOutToTime" => return timing(app, "trimOutToTime"),
- "app.about" => app.dialog = Some(crate::Dialog::About),
"app.home" => app.ui.start_screen = !app.ui.start_screen,
- "app.commandPalette" => {
- app.dialog_state.palette_query.clear();
- app.dialog = Some(crate::Dialog::CommandPalette);
- }
- "app.newComp" | "comp.new" if params.as_object().is_none_or(|m| m.is_empty()) => {
- crate::panels::dialogs::open_new_comp(app);
- }
- "app.compSettings" | "comp.settings" if params.as_object().is_none_or(|m| m.is_empty()) => {
- crate::panels::dialogs::open_comp_settings(app)?;
- }
- "keys.velocity" if params.as_object().is_none_or(|m| m.is_empty()) => crate::panels::key_dialogs::open_velocity(app)?,
- "keys.interpolation" if params.as_object().is_none_or(|m| m.is_empty()) => crate::panels::key_dialogs::open_interpolation(app)?,
- "layer.timeStretch" if params.as_object().is_none_or(|m| m.is_empty()) => crate::panels::key_dialogs::open_time_stretch(app)?,
- "app.solidSettings" | "layer.newSolid" if params.as_object().is_none_or(|m| m.is_empty()) => {
- crate::panels::dialogs::open_new_solid(app)?;
- }
+ "app.newComp" | "comp.new" if no_params(¶ms) => crate::panels::dialogs::open_new_comp(app),
+ "app.compSettings" | "comp.settings" if no_params(¶ms) => crate::panels::dialogs::open_comp_settings(app)?,
+ "app.solidSettings" | "layer.newSolid" if no_params(¶ms) => crate::panels::dialogs::open_new_solid(app)?,
+ "keys.velocity" if no_params(¶ms) => crate::panels::key_dialogs::open_velocity(app)?,
+ "keys.interpolation" if no_params(¶ms) => crate::panels::key_dialogs::open_interpolation(app)?,
+ "layer.timeStretch" if no_params(¶ms) => crate::panels::key_dialogs::open_time_stretch(app)?,
_ => {
- if (id == "file.import" && params.get("paths").is_none() && params.get("path").is_none())
- || (id == "file.saveAs" && params.get("path").is_none())
- || (id == "file.open" && params.get("path").is_none())
- || (id == "file.save" && params.get("path").is_none() && app.session.path.is_none())
- {
- return file_dialog(app, id);
+ if id == "renderQueue.render" && params.get("wait").is_none() {
+ // The UI renders in the background; the panel shows progress.
+ let mut p = params.clone();
+ if let Some(m) = p.as_object_mut() {
+ m.insert("wait".into(), json!(false));
+ } else {
+ p = json!({"wait": false});
+ }
+ app.show_panel(PanelKind::RenderQueue);
+ return app.session.execute(id, p).map_err(|e| e.to_string());
+ }
+ if id == "renderQueue.add" {
+ let r = app.session.execute(id, params).map_err(|e| e.to_string());
+ match &r {
+ Ok(_) => app.show_panel(PanelKind::RenderQueue),
+ Err(e) => app.ui.status = e.clone(),
+ }
+ return r;
+ }
+ if let Some(r) = file_dialog(app, id, ¶ms) {
+ return r;
+ }
+ if crate::panels::dialogs::open_form(app, id, ¶ms) {
+ return Ok(json!({"dialog": id}));
}
if id == "renderQueue.render" && params.get("wait").is_none() {
// The UI renders in the background; the panel shows progress.
@@ -302,44 +269,270 @@ pub fn invoke(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: V
crate::panels::timeline::begin_rename(app, ctx);
return Ok(Value::Null);
}
- let r = app.session.execute(id, params).map_err(|e| e.to_string());
- if let Err(e) = &r {
- app.ui.status = e.clone();
- }
- return r;
+ return run_engine(app, ctx, id, params);
}
}
Ok(Value::Null)
}
-fn file_dialog(app: &mut EffectcraftApp, id: &str) -> Result {
- match id {
- "file.import" => {
- let f = app.hooks.pick_files.as_ref().ok_or("no file dialog available (pass `paths`)")?;
+/// Run an engine command and perform the frontend events it emitted right away.
+fn run_engine(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, params: Value) -> Result {
+ let r = app.session.execute(id, params).map_err(|e| e.to_string());
+ if let Err(e) = &r {
+ app.ui.status = e.clone();
+ }
+ let events = app.session.drain_events();
+ for ev in events {
+ match ev {
+ effectcraft_engine::Event::Frontend { command, params } => {
+ if let Err(e) = frontend(app, ctx, &command, params) {
+ app.ui.status = e;
+ }
+ }
+ other => app.session.events.push(other),
+ }
+ }
+ r
+}
+
+fn toggle(slot: &mut bool, p: &Value) -> Value {
+ *slot = p.get("value").and_then(Value::as_bool).unwrap_or(!*slot);
+ json!(*slot)
+}
+
+/// Perform a frontend command (from `Event::Frontend`).
+pub fn frontend(app: &mut EffectcraftApp, ctx: &egui::Context, id: &str, p: Value) -> Result {
+ let now = ctx.input(|i| i.time);
+ let v = &mut app.ui.viewer;
+ Ok(match id {
+ "app.about" => {
+ app.dialog = Some(crate::Dialog::About);
+ Value::Null
+ }
+ "app.settings" => {
+ app.dialog_state.settings_page = p.get("page").and_then(Value::as_str).unwrap_or("general").to_string();
+ app.dialog = Some(crate::Dialog::Settings);
+ Value::Null
+ }
+ "app.hide" => {
+ ctx.send_viewport_cmd(egui::ViewportCommand::Minimized(true));
+ Value::Null
+ }
+ "app.quit" => {
+ ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+ Value::Null
+ }
+ "app.commandPalette" => {
+ app.dialog_state.palette_query = p.get("query").and_then(Value::as_str).unwrap_or_default().to_string();
+ app.dialog_state.palette_sel = 0;
+ app.dialog = Some(crate::Dialog::CommandPalette);
+ Value::Null
+ }
+ "app.keyboardShortcuts" => {
+ app.dialog = Some(crate::Dialog::Shortcuts);
+ Value::Null
+ }
+ "app.templates" => {
+ let kind = p.get("kind").and_then(Value::as_str).unwrap_or("renderSettings");
+ let title = if kind == "outputModule" { "Output Module Templates" } else { "Render Settings Templates" };
+ crate::panels::dialogs::info(app, title, "Render and output templates are managed from the Render Queue panel (Window ▸ Render Queue).");
+ Value::Null
+ }
+ "app.find" => {
+ if let Some(q) = p.get("query").and_then(Value::as_str) {
+ app.ui.project_search = q.to_string();
+ }
+ app.show_panel(PanelKind::Project);
+ Value::Null
+ }
+ "playback.toggle" => {
+ app.toggle_play(now);
+ json!({"playing": app.playback.playing})
+ }
+ "playback.cacheWhenIdle" => toggle(&mut app.ui.cache_when_idle, &p),
+ "playback.audio" => {
+ let r = toggle(&mut app.ui.preview_audio, &p);
+ if !app.ui.preview_audio {
+ app.audio = None;
+ }
+ r
+ }
+ "view.zoomIn" | "view.zoomOut" => {
+ let cur = v.zoom.unwrap_or_else(|| crate::panels::viewer::last_fit(ctx));
+ const STEPS: [f32; 16] = [0.015, 0.03, 0.0625, 0.125, 0.25, 0.333, 0.5, 0.66, 1.0, 1.5, 2.0, 3.0, 4.0, 8.0, 16.0, 32.0];
+ let next = if id == "view.zoomIn" {
+ STEPS.iter().copied().find(|s| *s > cur + 1e-3).unwrap_or(32.0)
+ } else {
+ STEPS.iter().rev().copied().find(|s| *s < cur - 1e-3).unwrap_or(0.015)
+ };
+ v.zoom = Some(next);
+ json!({"zoom": next})
+ }
+ "view.res.full" | "view.res.half" | "view.res.third" | "view.res.quarter" => {
+ let r = id.trim_start_matches("view.res.");
+ v.res = Resolution::ALL.into_iter().find(|x| x.label().eq_ignore_ascii_case(r)).ok_or("unknown resolution")?;
+ Value::Null
+ }
+ "view.rulers" => toggle(&mut v.rulers, &p),
+ "view.guides" => toggle(&mut v.guides, &p),
+ "view.snapToGuides" => toggle(&mut v.snap_guides, &p),
+ "view.lockGuides" => toggle(&mut v.lock_guides, &p),
+ "view.grid" => toggle(&mut v.grid, &p),
+ "view.snapToGrid" => toggle(&mut v.snap_grid, &p),
+ "view.layerControls" => toggle(&mut v.show_layer_controls, &p),
+ "view.options" => {
+ app.dialog = Some(crate::Dialog::ViewOptions);
+ Value::Null
+ }
+ "view.panelBackground" => {
+ if p.get("pick").and_then(Value::as_bool) == Some(true) {
+ let [r, g, b] = v.custom_pasteboard;
+ crate::panels::dialogs::form(
+ app,
+ "Panel Background Color",
+ "view.panelBackground",
+ json!({}),
+ vec![crate::panels::dialogs::Field::text("color", "Color (#rrggbb)", &format!("#{r:02x}{g:02x}{b:02x}"))],
+ );
+ return Ok(Value::Null);
+ }
+ let c = p.get("color").and_then(Value::as_str).unwrap_or("mediumGray");
+ v.pasteboard = match c {
+ "black" => Some([0, 0, 0]),
+ "darkGray" => Some([0x2a, 0x2a, 0x2a]),
+ "mediumGray" => None,
+ "lightGray" => Some([0xb4, 0xb4, 0xb4]),
+ "white" => Some([0xff, 0xff, 0xff]),
+ "custom" => Some(v.custom_pasteboard),
+ hex => {
+ let c = effectcraft_engine::color::Rgba::from_hex(hex).ok_or_else(|| format!("unknown colour `{hex}`"))?;
+ let rgb = [(c.r * 255.0).round() as u8, (c.g * 255.0).round() as u8, (c.b * 255.0).round() as u8];
+ v.custom_pasteboard = rgb;
+ Some(rgb)
+ }
+ };
+ Value::Null
+ }
+ "view.fullScreen" => {
+ let full = ctx.input(|i| i.viewport().fullscreen.unwrap_or(false));
+ ctx.send_viewport_cmd(egui::ViewportCommand::Fullscreen(!full));
+ json!(!full)
+ }
+ "window.panel" => {
+ let name = p.get("panel").and_then(Value::as_str).unwrap_or_default();
+ if name.eq_ignore_ascii_case("tools") {
+ app.ui.status = "The Tools panel is the toolbar in the header".into();
+ return Ok(Value::Null);
+ }
+ let panel = PanelKind::from_name(name).ok_or_else(|| format!("unknown panel `{name}`"))?;
+ app.show_panel(panel);
+ Value::Null
+ }
+ "window.workspace" => {
+ let want = p.get("name").and_then(Value::as_str).unwrap_or("Default").to_ascii_lowercase().replace(' ', "");
+ let name = crate::dock::WORKSPACES
+ .iter()
+ .find(|w| w.to_ascii_lowercase().replace(' ', "") == want)
+ .ok_or_else(|| format!("unknown workspace `{want}`"))?;
+ app.set_workspace(name);
+ json!({"workspace": name})
+ }
+ "window.resetWorkspace" => {
+ let name = app.ui.workspace.clone();
+ app.set_workspace(&name);
+ Value::Null
+ }
+ "comp.flowchart" | "comp.miniFlowchart" => {
+ app.show_panel(PanelKind::Flowchart);
+ Value::Null
+ }
+ "layer.openLayer" => {
+ app.show_panel(PanelKind::Layer);
+ Value::Null
+ }
+ "effect.manage" | "anim.browsePresets" => {
+ app.show_panel(PanelKind::EffectsPresets);
+ Value::Null
+ }
+ "timeline.revealProps" => {
+ let props = p.get("props").and_then(Value::as_array).cloned().unwrap_or_default();
+ let tl = &mut app.ui.timeline;
+ tl.reveal_props = props.iter().filter_map(|x| x.get("prop").and_then(Value::as_u64)).collect();
+ tl.open_layers = props.iter().filter_map(|x| x.get("layer").and_then(Value::as_u64)).collect();
+ tl.reveal = if tl.reveal_props.is_empty() { vec![] } else { vec!["props".into()] };
+ json!({"revealed": tl.reveal_props.len()})
+ }
+ _ => return Err(format!("`{id}` is not a frontend command")),
+ })
+}
+
+/// Commands that need a file or folder path: ask the host's file dialog when `params` lacks one.
+fn file_dialog(app: &mut EffectcraftApp, id: &str, params: &Value) -> Option> {
+ enum Ask {
+ Import,
+ OpenProject,
+ Save(&'static str),
+ Open(&'static [&'static str]),
+ }
+ let (key, ask) = match id {
+ "file.import" | "file.importMultiple" => ("paths", Ask::Import),
+ "file.open" => ("path", Ask::OpenProject),
+ "file.save" if app.session.path.is_none() => ("path", Ask::Save("Untitled Project.ecproj")),
+ "file.saveAs" | "file.saveCopy" => ("path", Ask::Save("Untitled Project.ecproj")),
+ "comp.saveFrameAs" => ("path", Ask::Save("Frame.png")),
+ "anim.savePreset" => ("path", Ask::Save("Preset.ecpreset")),
+ "anim.applyPreset" => ("path", Ask::Open(&["ecpreset", "json"])),
+ "view.exportGuides" => ("path", Ask::Save("Guides.json")),
+ "view.importGuides" => ("path", Ask::Open(&["json"])),
+ "file.runScript" => ("path", Ask::Open(&["jsonl", "json", "txt"])),
+ "file.replaceFootage" => ("path", Ask::Import),
+ "file.collectFiles" => ("folder", Ask::Save("Collected Files")),
+ _ => return None,
+ };
+ if params.get(key).is_some()
+ || params.get("path").is_some()
+ || params.get("paths").is_some()
+ || params.get("steps").is_some()
+ || params.get("preset").is_some()
+ {
+ return None;
+ }
+ let mut p = params.as_object().cloned().unwrap_or_default();
+ let picked: Option