Merge main (layer styles, engine menu tree) into time/audio branch

Resolve conflicts; register playback.audio (Composition > Preview > Audio)
as a real frontend command replacing its stub; layer_at uses content_buf.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Brandon Thomas
2026-10-02 00:19:34 -04:00
co-authored by Claude Opus 5.5
58 changed files with 7925 additions and 371 deletions
+12
View File
@@ -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`.
Generated
+1
View File
@@ -1197,6 +1197,7 @@ dependencies = [
"effectcraft-render",
"effectcraft-text",
"effectcraft-time",
"image",
"log",
"serde",
"serde_json",
+96 -66
View File
@@ -15,12 +15,12 @@
<p align="center">
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.
</p>
<p align="center">
<img alt="Status: early development" src="https://img.shields.io/badge/status-early%20development-e0368f?style=flat-square">
<img alt="Status: young and moving fast" src="https://img.shields.io/badge/status-young%20and%20moving%20fast-e0368f?style=flat-square">
<img alt="Written in Rust" src="https://img.shields.io/badge/rust-1.95%2B-b0206c?style=flat-square&logo=rust&logoColor=white">
<img alt="License: MIT or Apache-2.0" src="https://img.shields.io/badge/license-MIT%20%2F%20Apache--2.0-555?style=flat-square">
</p>
@@ -35,6 +35,12 @@
<a href="https://getartcraft.com/apps">All Crafting Apps</a>
</p>
<br>
<p align="center">
<img src="docs/images/effectcraft-hero.png" alt="EffectCraft's main window: the animated demo composition in the Composition panel, the Project panel, a Timeline with text, shape and solid layers, and the Properties panel showing the selected text layer's transform, font and paragraph settings" width="100%">
</p>
> [!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 @@
<p align="center">
<a href="#what-effectcraft-is">What it is</a> ·
<a href="#where-it-stands">Where it stands</a> ·
<a href="#the-plan">The plan</a> ·
<a href="#building-from-source">Building</a> ·
<a href="#animate">Animate</a> ·
<a href="#effects">Effects</a> ·
<a href="#3d">3D</a> ·
<a href="#export">Export</a> ·
<a href="#built-for-agents">Agents</a> ·
<a href="#get-started">Get started</a> ·
<a href="#where-it-stands">Status</a> ·
<a href="#how-its-made">How it's made</a> ·
<a href="#the-crafting-apps">The Crafting Apps</a> ·
<a href="#license-and-credits">License</a>
@@ -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).
<p align="center">
<img src="docs/images/effectcraft-graph-editor.png" alt="The Graph Editor showing an eased value curve for a text animator's Range Start, with the graph editor's button bar for hold, linear, auto Bezier and Easy Ease" width="100%">
</p>
### 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.
<p align="center">
<img src="docs/images/effectcraft-effects.png" alt="A CC Particle World burst with Glow, and the Effect Controls panel listing the particle system's parameters" width="100%">
</p>
## 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 |
<p align="center">
<img src="docs/images/effectcraft-3d.png" alt="The 3D Showcase demo in Custom View 1: intersecting cards lit by a spot light with soft shadows on a gridded floor, with the camera frustum and light drawn as wireframes" width="100%">
</p>
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:
<p align="center">
<img src="docs/images/effectcraft-render-queue.png" alt="The Render Queue panel with two compositions queued" width="100%">
</p>
## 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
+1
View File
@@ -24,3 +24,4 @@ serde = { workspace = true }
serde_json = { workspace = true }
thiserror = { workspace = true }
log = { workspace = true }
image = { workspace = true }
+1 -1
View File
@@ -386,7 +386,7 @@ pub fn specs() -> Vec<CommandSpec> {
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}))),
+399
View File
@@ -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<Value> {
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<Uid> = 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<Value> = 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<Value> = 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<Value> {
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<PropGroup> =
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<Keyframe> = 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<Value> {
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<Tick>> {
let mut m: BTreeMap<(LayerId, Uid), Vec<Tick>> = 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<Value> {
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(&times[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<Value> {
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<Uid> = 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<Value> {
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<Value> {
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<LayerId> = 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<CommandSpec> {
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),
]
}
+3 -3
View File
@@ -241,7 +241,7 @@ pub fn specs() -> Vec<CommandSpec> {
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<CommandSpec> {
),
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<CommandSpec> {
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),
+130
View File
@@ -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<Value> {
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<Value> {
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<Value> {
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<Vec<u8>, 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<Value> {
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<Value> {
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<CommandSpec> {
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),
]
}
+339 -6
View File
@@ -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<Value> {
@@ -100,18 +119,187 @@ fn delete(s: &mut Session, p: &Value) -> Result<Value> {
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<Value> {
// 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<Layer> = 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<String> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
}
fn paste(s: &mut Session, p: &Value) -> Result<Value> {
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<Value> {
Ok(Value::Null)
}
fn paste_reversed(s: &mut Session, _: &Value) -> Result<Value> {
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<Value> {
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<LayerId> = 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<LayerId> = 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<Value> {
work_area_cut(s, p, false)
}
fn extract(s: &mut Session, p: &Value) -> Result<Value> {
work_area_cut(s, p, true)
}
fn select_label_group(s: &mut Session, _: &Value) -> Result<Value> {
let comp = s.active_comp().ok_or(EngineError::NoComp)?;
let labels: Vec<Label> = 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<Label> = 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<Value> {
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<String> {
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<Value> {
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<Value> {
s.history.undo.clear();
s.history.redo.clear();
@@ -209,14 +517,39 @@ pub fn specs() -> Vec<CommandSpec> {
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),
]
}
+5 -5
View File
@@ -141,16 +141,16 @@ fn cycle_depth(s: &mut Session, _: &Value) -> Result<Value> {
pub fn specs() -> Vec<CommandSpec> {
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}",
+681
View File
@@ -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<ItemId> {
let mut v: Vec<ItemId> =
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<ItemId> {
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<Value> {
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<Value> {
s.execute("comp.close", p.clone())
}
fn close_project(s: &mut Session, _: &Value) -> Result<Value> {
s.replace_project(Project::default(), None);
Ok(Value::Null)
}
fn save_copy(s: &mut Session, p: &Value) -> Result<Value> {
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<Value> {
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<Value> {
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<Value> {
let items: Vec<ItemId> = 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<ItemId> {
let mut seen = BTreeSet::new();
let mut stack: Vec<ItemId> = 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<ItemId> {
proj.comps().flat_map(|(_, c)| c.layers.iter().filter_map(|l| l.source.item())).collect()
}
fn remove_unused(s: &mut Session, _: &Value) -> Result<Value> {
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<Value> {
// Footage with the same file and interpretation collapses into the first such item.
let mut first: BTreeMap<String, ItemId> = BTreeMap::new();
let mut remap: BTreeMap<ItemId, ItemId> = 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<ItemId> = 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<Value> {
let roots: Vec<ItemId> = 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<Value> {
let what = str_p(p, "what").unwrap_or("footage");
match what {
"footage" => {
let ids: Vec<ItemId> = 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::<Vec<_>>()}))
}
"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<Value> {
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<String> = 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<Value> {
let steps: Vec<Value> = 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::<Value>(&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::<Result<Vec<Value>>>()?,
}
}
_ => 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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<ItemId> = 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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<CommandSpec> {
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),
]
}
+78
View File
@@ -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<CommandSpec> {
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),
]
}
+15 -2
View File
@@ -16,13 +16,26 @@ fn sibling(s: &mut Session, p: &Value) -> Result<Value> {
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<Value> {
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<CommandSpec> {
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",
+4 -4
View File
@@ -942,7 +942,7 @@ fn with_layer(p: &Value, lid: LayerId) -> Value {
pub fn specs() -> Vec<CommandSpec> {
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<CommandSpec> {
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<CommandSpec> {
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<CommandSpec> {
cmd!(
"layer.addTextAnimator",
"Animate Text",
["Animation"],
[],
None,
"{layer?, properties: [position|scale|rotation|opacity|fillColor|tracking|…]}",
has_layers,
+805
View File
@@ -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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<LayerId> = 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<Value> {
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<Value> {
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<Value> {
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<Value> {
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 &centers {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
let (cid, keep) = target_masks(s, p)?;
let layers: Vec<LayerId> = 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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<LayerId> = 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<ItemId> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Value> = 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<Value> {
let cid = comp_id(s, p)?;
// Selection order (AE sequences in the order layers were selected).
let ids: Vec<LayerId> = 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<Tick> = 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<CommandSpec> {
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
),
]
}
+3 -3
View File
@@ -136,7 +136,7 @@ fn freeze(s: &mut Session, p: &Value, last: bool) -> Result<Value> {
(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<CommandSpec> {
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<CommandSpec> {
}),
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)),
]
}
+2 -2
View File
@@ -254,7 +254,7 @@ pub fn specs() -> Vec<CommandSpec> {
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)),
]
}
+70
View File
@@ -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<Value> {
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<Value> {
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<String> {
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<String>) -> EngineError {
+2 -2
View File
@@ -590,7 +590,7 @@ pub fn specs() -> Vec<CommandSpec> {
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<CommandSpec> {
),
cmd!(
"keys.velocity",
"Keyframe Velocity…",
"Keyframe Velocity...",
["Animation"],
Some("Cmd+Shift+K"),
"{inSpeed?, inInfluence? %, outSpeed?, outInfluence? % (numbers or per-dimension arrays), continuous?}",
+3 -3
View File
@@ -393,7 +393,7 @@ pub fn specs() -> Vec<CommandSpec> {
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<CommandSpec> {
),
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<CommandSpec> {
),
cmd!(
"renderQueue.setOutput",
"Output To…",
"Output To...",
[],
None,
"{item?|index?, path: file path or template like [compName].[fileExtension]}",
+100
View File
@@ -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<CommandSpec> {
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}"),
]
}
+244
View File
@@ -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<LayerId>)> {
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<Value> {
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<Value> {
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::<Vec<_>>().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<Value> {
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<Value> {
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<Value> {
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<Uid> = 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<Value> {
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<Value> {
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<Value> {
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<Value> {
Err(EngineError::Other("no Photoshop layer styles to convert".into()))
}
fn list(s: &mut Session, p: &Value) -> Result<Value> {
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<Value> = 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::<Vec<_>>()}),
)
}
pub fn specs() -> Vec<CommandSpec> {
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),
]
}
+7 -7
View File
@@ -533,7 +533,7 @@ pub fn specs() -> Vec<CommandSpec> {
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<CommandSpec> {
),
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<CommandSpec> {
),
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<CommandSpec> {
),
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<CommandSpec> {
),
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,
+1 -1
View File
@@ -91,7 +91,7 @@ fn go(s: &mut Session, p: &Value) -> Result<Value> {
pub fn specs() -> Vec<CommandSpec> {
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}))),
+86
View File
@@ -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<Value> {
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<Value> {
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<Value> {
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<Value> {
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<Guide> = 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<Value> {
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<CommandSpec> {
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),
]
}
+41 -2
View File
@@ -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<String>,
/// 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<LinkClip>,
/// File ▸ Interpret Footage ▸ Remember Interpretation.
#[serde(skip)]
pub interpretation: Option<effectcraft_project::Footage>,
/// Viewer 3D view per comp (Active Camera / Front / … / Custom View 3 and edited view cameras).
#[serde(default)]
pub views3d: std::collections::BTreeMap<ItemId, effectcraft_render::three_d::Views3D>,
}
/// 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).
+925
View File
@@ -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<MenuNode> },
}
/// 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<String>,
}
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<Vec<MenuNode>> = 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<String>, &'static MenuEntry)> {
fn rec(nodes: &'static [MenuNode], path: &mut Vec<String>, out: &mut Vec<(Vec<String>, &'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<bool> {
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<Vec<MenuNode>, 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<usize> = 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<bool> {
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<Vec<MenuNode>, 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<MenuNode> {
let mut cats: Vec<(&str, Vec<MenuNode>)> = 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;
+157
View File
@@ -0,0 +1,157 @@
use std::collections::BTreeMap;
use super::*;
fn all_entries(nodes: &[MenuNode], path: &mut Vec<String>, out: &mut Vec<(Vec<String>, 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<String>, 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<String> =
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<String> =
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<String>, 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::<Vec<_>>()
);
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<String, (String, String)> = 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());
}
+492
View File
@@ -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::<Vec<_>>();
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::<usize>(), 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::<Vec<_>>());
// 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}");
}
}
+119
View File
@@ -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);
}
+1
View File
@@ -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,
}
+19
View File
@@ -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<Guide>,
}
/// 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<LayerId>,
#[serde(default)]
pub markers: Vec<Marker>,
/// 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…).
+485
View File
@@ -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<PropGroup> {
let (_, name) = STYLES.iter().find(|s| s.0 == id)?;
let mut g = ids.group(id, name);
g.kind = GroupKind::Plain;
let props: Vec<Property> = 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<u64> {
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<f64>, altitude: Option<f64>, 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));
}
}
+21 -1
View File
@@ -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()
}
+137 -23
View File
@@ -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<Arc<Buf>> {
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<Arc<Buf>> {
/// Layer pixels after source → masks → effects (no layer styles).
pub fn content_buf(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Arc<Buf>> {
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<Buf>, Option<u64>)> {
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<StyledLayer> {
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<Vec<_>> = 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<Buf>, BlendMode)>,
body: Arc<Buf>,
/// Pre-style pixels (knockout shape).
content: Arc<Buf>,
/// Styled cache key.
key: Option<u64>,
/// 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
+741
View File
@@ -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<BlendMode> {
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<Gradient>,
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<Shadow>,
inner_shadow: Option<Shadow>,
outer_glow: Option<Glow>,
inner_glow: Option<Glow>,
bevel: Option<Bevel>,
satin: Option<Satin>,
color: Option<Overlay>,
gradient: Option<GradOverlay>,
stroke: Option<Stroke>,
}
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<Plane>);
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))
});
}
+416
View File
@@ -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<f32> = (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:?}");
}
+19
View File
@@ -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).
+16
View File
@@ -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(),
}
}
}
+524 -231
View File
@@ -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<Value, String> {
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, &params)? {
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(&params) => crate::panels::dialogs::open_new_comp(app),
"app.compSettings" | "comp.settings" if no_params(&params) => crate::panels::dialogs::open_comp_settings(app)?,
"app.solidSettings" | "layer.newSolid" if no_params(&params) => crate::panels::dialogs::open_new_solid(app)?,
"keys.velocity" if no_params(&params) => crate::panels::key_dialogs::open_velocity(app)?,
"keys.interpolation" if no_params(&params) => crate::panels::key_dialogs::open_interpolation(app)?,
"layer.timeStretch" if no_params(&params) => 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, &params) {
return r;
}
if crate::panels::dialogs::open_form(app, id, &params) {
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<Value, String> {
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<Value, String> {
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<Value, String> {
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<Result<Value, String>> {
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<Value> = match ask {
Ask::Import => {
let Some(f) = app.hooks.pick_files.as_ref() else { return Some(Err("no file dialog available (pass `paths`)".into())) };
let paths = f(&[
"mp4", "mov", "m4v", "mkv", "webm", "png", "jpg", "jpeg", "gif", "webp", "tif", "tiff", "bmp", "exr", "wav", "aif", "aiff", "mp3", "flac",
"ogg", "opus", "svg",
]);
if paths.is_empty() {
return Ok(Value::Null);
}
app.session.execute("file.import", json!({"paths": paths})).map_err(|e| e.to_string())
}
"file.open" => {
let f = app.hooks.pick_open_project.as_ref().ok_or("no file dialog available (pass `path`)")?;
match f() {
Some(p) => app.session.execute("file.open", json!({"path": p})).map_err(|e| e.to_string()),
None => Ok(Value::Null),
match (paths.is_empty(), key) {
(true, _) => None,
(false, "paths") => Some(json!(paths)),
(false, _) => paths.first().map(|s| json!(s)),
}
}
_ => {
let f = app.hooks.pick_save.as_ref().ok_or("no file dialog available (pass `path`)")?;
match f("Untitled Project.ecproj") {
Some(p) => app.session.execute("file.saveAs", json!({"path": p})).map_err(|e| e.to_string()),
None => Ok(Value::Null),
}
Ask::OpenProject => {
let Some(f) = app.hooks.pick_open_project.as_ref() else { return Some(Err("no file dialog available (pass `path`)".into())) };
f().map(|s| json!(s))
}
Ask::Open(exts) => {
let Some(f) = app.hooks.pick_files.as_ref() else { return Some(Err("no file dialog available (pass `path`)".into())) };
f(exts).first().map(|s| json!(s))
}
Ask::Save(default) => {
let Some(f) = app.hooks.pick_save.as_ref() else { return Some(Err("no file dialog available (pass `path`)".into())) };
f(default).map(|s| json!(s))
}
};
let Some(v) = picked else { return Some(Ok(Value::Null)) };
p.insert(key.to_string(), v);
// Save (untitled) becomes Save As.
let id = if id == "file.save" { "file.saveAs" } else { id };
let r = app.session.execute(id, Value::Object(p)).map_err(|e| e.to_string());
if let Err(e) = &r {
app.ui.status = e.clone();
}
Some(r)
}
/// A menu entry for display / `ui.menu.list`.
@@ -350,70 +543,90 @@ pub struct MenuItem {
pub path: Vec<String>,
pub shortcut: Option<String>,
pub enabled: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub checked: Option<bool>,
/// Parameters bound to the entry (e.g. the effect for Effect menu items).
#[serde(skip_serializing_if = "Value::is_null")]
pub params: Value,
}
pub const MENUS: [&str; 9] = ["File", "Edit", "Composition", "Layer", "Effect", "Animation", "View", "Window", "Help"];
/// Top-level menus in order.
pub fn menus() -> Vec<&'static str> {
effectcraft_engine::menus::top_level()
}
fn entry_label(app: &EffectcraftApp, e: &MenuEntry) -> String {
match e.command.as_str() {
"edit.undo" => app.session.history.undo.last().map(|u| format!("Undo {}", u.0)).unwrap_or_else(|| "Can't Undo".into()),
"edit.redo" => app.session.history.redo.last().map(|u| format!("Redo {}", u.0)).unwrap_or_else(|| "Can't Redo".into()),
_ => e.label.clone(),
}
}
/// Check-mark state of frontend toggles (engine state is answered by the engine).
fn entry_checked(app: &EffectcraftApp, e: &MenuEntry) -> Option<bool> {
let v = &app.ui.viewer;
let pstr = |k: &str| e.params.get(k).and_then(Value::as_str);
match e.command.as_str() {
"view.rulers" => Some(v.rulers),
"view.guides" => Some(v.guides),
"view.snapToGuides" => Some(v.snap_guides),
"view.lockGuides" => Some(v.lock_guides),
"view.grid" => Some(v.grid),
"view.snapToGrid" => Some(v.snap_grid),
"view.layerControls" => Some(v.show_layer_controls),
"playback.cacheWhenIdle" => Some(app.ui.cache_when_idle),
"playback.audio" => Some(app.ui.preview_audio),
"view.res.full" | "view.res.half" | "view.res.third" | "view.res.quarter" => {
Some(v.res.label().eq_ignore_ascii_case(e.command.trim_start_matches("view.res.")))
}
"window.workspace" => Some(pstr("name").is_some_and(|n| n == app.ui.workspace)),
"view.panelBackground" if e.params.get("pick").is_none() => {
let cur = match v.pasteboard {
None => "mediumGray",
Some([0, 0, 0]) => "black",
Some([0x2a, 0x2a, 0x2a]) => "darkGray",
Some([0xb4, 0xb4, 0xb4]) => "lightGray",
Some([0xff, 0xff, 0xff]) => "white",
Some(_) => "custom",
};
Some(pstr("color") == Some(cur))
}
_ => effectcraft_engine::menus::checked(&app.session, &e.command, &e.params),
}
}
fn entry_enabled(app: &EffectcraftApp, e: &MenuEntry) -> bool {
if e.command == "window.panel" {
return true;
}
app.session.is_enabled(&e.command)
}
/// Every menu entry, flattened with its submenu path.
pub fn menu_items(app: &EffectcraftApp) -> Vec<MenuItem> {
let mut out = Vec::new();
for c in effectcraft_engine::command_specs() {
if c.menu.is_empty() {
continue;
}
out.push(MenuItem {
id: c.id.into(),
label: c.label.into(),
path: c.menu.iter().map(|s| s.to_string()).collect(),
shortcut: c.shortcut.map(str::to_string),
enabled: app.session.is_enabled(c.id),
params: Value::Null,
});
}
for c in UI_COMMANDS {
if c.menu.is_empty() {
continue;
}
out.push(MenuItem {
id: c.id.into(),
label: c.label.into(),
path: c.menu.iter().map(|s| s.to_string()).collect(),
shortcut: c.shortcut.map(str::to_string),
enabled: true,
params: Value::Null,
});
}
for p in PanelKind::ALL {
out.push(MenuItem {
id: panel_command_id(p),
label: p.title().into(),
path: vec!["Window".into()],
shortcut: p.window_shortcut().map(str::to_string),
enabled: true,
params: Value::Null,
});
}
let has_layer = !app.session.state.selected_layers.is_empty();
for e in effectcraft_engine::effects::registry() {
out.push(MenuItem {
id: "effect.apply".into(),
label: e.name.into(),
path: vec!["Effect".into(), e.category.into()],
shortcut: None,
enabled: has_layer,
params: json!({"effect": e.id}),
});
}
out
effectcraft_engine::menus::entries()
.into_iter()
.map(|(path, e)| MenuItem {
id: e.command.clone(),
label: entry_label(app, e),
path,
shortcut: e.shortcut.clone(),
enabled: entry_enabled(app, e),
checked: entry_checked(app, e),
params: e.params.clone(),
})
.collect()
}
/// Shortcut text in this OS's notation (`⇧⌘K` on macOS, `Ctrl+Shift+K` elsewhere).
pub fn shortcut_text(s: &str) -> String {
if cfg!(target_os = "macos") {
let mut out = String::new();
let parts: Vec<&str> = s.split('+').collect();
let parts: Vec<&str> = match s.strip_suffix("++") {
Some(head) => vec![head, "+"],
None => s.split('+').collect(),
};
let (mods, key) = parts.split_at(parts.len().saturating_sub(1));
for m in mods {
out.push_str(match *m {
@@ -424,7 +637,12 @@ pub fn shortcut_text(s: &str) -> String {
x => x,
});
}
out.push_str(key.first().copied().unwrap_or(""));
out.push_str(match key.first().copied().unwrap_or("") {
"Space" => "Space",
"Escape" => "Esc",
"Home" => "↖",
k => k,
});
out
} else {
s.replace("Cmd", "Ctrl")
@@ -471,22 +689,53 @@ pub fn parse_shortcut(s: &str) -> Option<(egui::Modifiers, egui::Key)> {
key.map(|k| (m, k))
}
/// The key some keyboards report for a shifted punctuation key (`Shift+=` arrives as `+`).
fn shifted_alias(k: egui::Key) -> Option<egui::Key> {
use egui::Key::*;
Some(match k {
Equals => Plus,
Semicolon => Colon,
OpenBracket => OpenCurlyBracket,
CloseBracket => CloseCurlyBracket,
Slash => Questionmark,
Backslash => Pipe,
_ => return None,
})
}
/// A key binding: modifiers, key, command id and bound params.
pub type Binding = (egui::Modifiers, egui::Key, String, Value);
/// All active bindings, most modifiers first.
pub fn bindings() -> Vec<(egui::Modifiers, egui::Key, String)> {
let mut v: Vec<(egui::Modifiers, egui::Key, String)> = Vec::new();
pub fn bindings() -> Vec<Binding> {
let mut v: Vec<Binding> = Vec::new();
let mut push = |sc: &str, id: &str, params: Value| {
if let Some((m, k)) = parse_shortcut(sc) {
if m.shift
&& let Some(alias) = shifted_alias(k)
{
v.push((m, alias, id.to_string(), params.clone()));
}
v.push((m, k, id.to_string(), params));
}
};
// Menu entries (their shortcuts may bind params), then command defaults not in the menus.
let entries = effectcraft_engine::menus::entries();
for (_, e) in &entries {
if let Some(sc) = &e.shortcut {
push(sc, &e.command, e.params.clone());
}
}
for c in effectcraft_engine::command_specs() {
if let Some((m, k)) = c.shortcut.and_then(parse_shortcut) {
v.push((m, k, c.id.to_string()));
if let Some(sc) = c.shortcut
&& !entries.iter().any(|(_, e)| e.command == c.id)
{
push(sc, c.id, Value::Null);
}
}
for c in UI_COMMANDS {
if let Some((m, k)) = c.shortcut.and_then(parse_shortcut) {
v.push((m, k, c.id.to_string()));
}
}
for p in PanelKind::ALL {
if let Some((m, k)) = p.window_shortcut().and_then(parse_shortcut) {
v.push((m, k, panel_command_id(p)));
if let Some(sc) = c.shortcut {
push(sc, c.id, Value::Null);
}
}
v.sort_by_key(|(m, ..)| std::cmp::Reverse(m.command as u8 + m.shift as u8 + m.alt as u8 + m.ctrl as u8));
@@ -533,57 +782,30 @@ pub fn handle_shortcuts(app: &mut EffectcraftApp, ctx: &egui::Context) {
let _ = invoke(app, ctx, "edit.clear", json!({}));
continue;
}
if let Some((_, _, id)) = binds.iter().find(|(m, k, _)| *k == key && mods_match(*m, mods)) {
let id = id.clone();
if let Err(e) = invoke(app, ctx, &id, json!({})) {
if let Some((_, _, id, params)) = binds.iter().find(|(m, k, ..)| *k == key && mods_match(*m, mods)) {
let (id, params) = (id.clone(), if params.is_null() { json!({}) } else { params.clone() });
if let Err(e) = invoke(app, ctx, &id, params) {
app.ui.status = e;
}
}
}
}
/// Draw the in-window menu bar.
/// Draw the in-window menu bar (the engine's AE menu tree).
pub fn menu_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui) {
let items = menu_items(app);
let ctx = ui.ctx().clone();
let mut clicked: Option<(String, Value)> = None;
ui.horizontal_centered(|ui| {
ui.add_space(6.0);
egui::MenuBar::new().ui(ui, |ui| {
for top in MENUS {
let mine: Vec<&MenuItem> = items.iter().filter(|i| i.path.first().map(String::as_str) == Some(top)).collect();
ui.menu_button(top, |ui| {
ui.set_min_width(260.0);
let mut subs: Vec<&str> = Vec::new();
let mut last_was_sub = false;
for it in &mine {
if it.path.len() > 1 {
let sub = it.path[1].as_str();
if !subs.contains(&sub) {
subs.push(sub);
ui.menu_button(sub, |ui| {
ui.set_min_width(220.0);
for s in mine.iter().filter(|x| x.path.get(1).map(String::as_str) == Some(sub)) {
if menu_entry(ui, s) {
clicked = Some((s.id.clone(), s.params.clone()));
ui.close();
}
}
});
last_was_sub = true;
}
} else {
if last_was_sub && top != "Effect" {
ui.separator();
last_was_sub = false;
}
if menu_entry(ui, it) {
clicked = Some((it.id.clone(), it.params.clone()));
ui.close();
}
}
}
});
for node in effectcraft_engine::menus::menu_bar() {
if let MenuNode::Submenu { label, children } = node {
let r = ui.menu_button(label, |ui| {
ui.set_min_width(if label == "Effect" { 200.0 } else { 280.0 });
menu_nodes(app, ui, children, &mut clicked);
});
app.auto.add(&format!("menu.{label}"), r.response.rect, label);
}
}
});
});
@@ -594,10 +816,81 @@ pub fn menu_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui) {
}
}
fn menu_entry(ui: &mut egui::Ui, it: &MenuItem) -> bool {
let mut b = egui::Button::new(&it.label);
if let Some(s) = &it.shortcut {
fn menu_nodes(app: &mut EffectcraftApp, ui: &mut egui::Ui, nodes: &[MenuNode], clicked: &mut Option<(String, Value)>) {
for n in nodes {
match n {
MenuNode::Separator => {
ui.separator();
}
MenuNode::Submenu { label, children } => {
ui.menu_button((gutter(false), label.as_str()), |ui| {
ui.set_min_width(if children.len() > 30 { 200.0 } else { 240.0 });
// Long submenus (Blending Mode, effect categories) scroll instead of running
// off the screen.
let max_h = ui.ctx().content_rect().height() - 40.0;
egui::ScrollArea::vertical().max_height(max_h).show(ui, |ui| menu_nodes(app, ui, children, clicked));
});
}
MenuNode::Item(e) => {
if menu_entry(app, ui, e) {
*clicked = Some((e.command.clone(), e.params.clone()));
ui.close();
}
}
}
}
}
/// The check-mark column every menu row reserves (like macOS / After Effects menus).
fn gutter(checked: bool) -> egui::Atom<'static> {
use egui::AtomExt;
(if checked { "✔" } else { "" }).atom_size(egui::vec2(14.0, 14.0))
}
fn menu_entry(app: &EffectcraftApp, ui: &mut egui::Ui, e: &MenuEntry) -> bool {
let label = entry_label(app, e);
let mut b = egui::Button::new((gutter(entry_checked(app, e) == Some(true)), label));
if let Some(s) = &e.shortcut {
b = b.shortcut_text(shortcut_text(s));
}
ui.add_enabled(it.enabled, b).clicked()
ui.add_enabled(entry_enabled(app, e), b).clicked()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn every_ui_shortcut_parses() {
for c in UI_COMMANDS {
if let Some(sc) = c.shortcut {
assert!(parse_shortcut(sc).is_some() || sc == "Num*", "{sc}");
}
}
for (_, e) in effectcraft_engine::menus::entries() {
if let Some(sc) = &e.shortcut {
assert!(parse_shortcut(sc).is_some() || sc == "Num*", "{} ({sc})", e.label);
}
}
}
#[test]
fn ui_and_menu_shortcuts_do_not_collide() {
let mut seen: std::collections::BTreeMap<(String, String), (String, String)> = Default::default();
for (m, k, id, params) in bindings() {
let key = (format!("{m:?}"), format!("{k:?}"));
let target = (id.clone(), params.to_string());
if let Some(prev) = seen.get(&key) {
assert_eq!(prev, &target, "{key:?} bound to {prev:?} and {target:?}");
} else {
seen.insert(key, target);
}
}
}
#[test]
fn menu_items_cover_the_tree() {
assert_eq!(menus().last(), Some(&"Help"));
assert!(effectcraft_engine::menus::entries().len() > 500);
}
}
+12
View File
@@ -4,6 +4,7 @@
use egui::{Align2, Color32, Rect, Sense, pos2, vec2};
use serde_json::json;
pub use super::forms::{Field, form, info, open_form};
use crate::icons::{self, Icon};
use crate::theme::Tokens;
use crate::{Dialog, EffectcraftApp};
@@ -19,6 +20,12 @@ pub struct DialogState {
pub solid_size: [u32; 2],
pub palette_query: String,
pub palette_sel: usize,
/// Settings dialog page id (`general`, `appearance`…).
pub settings_page: String,
/// The open parameter form.
pub form: super::forms::Form,
/// Message box (title, body).
pub info: (String, String),
pub camera: super::dialogs_3d::CameraDraft,
pub light: super::dialogs_3d::LightDraft,
pub velocity: super::key_dialogs::VelocityDraft,
@@ -91,6 +98,11 @@ pub fn show(app: &mut EffectcraftApp, ctx: &egui::Context) {
Dialog::NewComp | Dialog::CompSettings => comp_settings(app, ctx, &t, d == Dialog::CompSettings),
Dialog::SolidSettings => solid(app, ctx, &t),
Dialog::CommandPalette => palette(app, ctx, &t),
Dialog::Settings => super::forms::show_settings(app, ctx, &t),
Dialog::Shortcuts => super::forms::show_shortcuts(app, ctx, &t),
Dialog::Form => super::forms::show_form(app, ctx, &t),
Dialog::Info => super::forms::show_info(app, ctx, &t),
Dialog::ViewOptions => super::forms::show_view_options(app, ctx, &t),
Dialog::CameraSettings => super::dialogs_3d::camera(app, ctx, &t),
Dialog::LightSettings => super::dialogs_3d::light(app, ctx, &t),
Dialog::KeyVelocity => super::key_dialogs::velocity(app, ctx, &t),
+544
View File
@@ -0,0 +1,544 @@
//! Menu dialogs: a generic parameter form (numeric Transform dialogs, Mask Feather/Opacity/
//! Expansion, Auto-Orient, Go to Time, Add Guide, Sequence Layers, Interpret Footage, Project
//! Settings, placeholders…), Settings (Preferences), Keyboard Shortcuts, View Options and simple
//! message boxes. Every form runs an engine command with the collected parameters, so whatever a
//! dialog does an agent can do with one `engine.execute`.
use egui::{Color32, vec2};
use serde_json::{Map, Value, json};
use crate::theme::Tokens;
use crate::{Dialog, EffectcraftApp};
#[derive(Clone, Debug)]
pub enum FieldKind {
Number {
value: f64,
speed: f64,
},
Text(String),
Bool(bool),
/// Options as (label, value); `sel` is the chosen index.
Choice {
options: Vec<(String, Value)>,
sel: usize,
},
}
/// One form field. `key` may index into an array param (`value[1]`).
#[derive(Clone, Debug)]
pub struct Field {
pub key: String,
pub label: String,
pub kind: FieldKind,
}
impl Field {
pub fn num(key: &str, label: &str, value: f64) -> Field {
Field { key: key.into(), label: label.into(), kind: FieldKind::Number { value, speed: 1.0 } }
}
pub fn text(key: &str, label: &str, value: &str) -> Field {
Field { key: key.into(), label: label.into(), kind: FieldKind::Text(value.into()) }
}
pub fn bool(key: &str, label: &str, value: bool) -> Field {
Field { key: key.into(), label: label.into(), kind: FieldKind::Bool(value) }
}
pub fn choice(key: &str, label: &str, options: &[(&str, Value)], sel: usize) -> Field {
Field {
key: key.into(),
label: label.into(),
kind: FieldKind::Choice { options: options.iter().map(|(l, v)| (l.to_string(), v.clone())).collect(), sel },
}
}
}
#[derive(Clone, Debug, Default)]
pub struct Form {
pub title: String,
pub command: String,
pub base: Value,
pub fields: Vec<Field>,
}
impl Form {
/// The command parameters: `base` plus every field.
pub fn params(&self) -> Value {
let mut m: Map<String, Value> = self.base.as_object().cloned().unwrap_or_default();
for f in &self.fields {
let v = match &f.kind {
FieldKind::Number { value, .. } => json!(value),
FieldKind::Text(s) => json!(s),
FieldKind::Bool(b) => json!(b),
FieldKind::Choice { options, sel } => options.get(*sel).map(|o| o.1.clone()).unwrap_or(Value::Null),
};
match f.key.split_once('[') {
Some((name, idx)) => {
let i: usize = idx.trim_end_matches(']').parse().unwrap_or(0);
let arr = m.entry(name.to_string()).or_insert_with(|| json!([]));
if let Value::Array(a) = arr {
while a.len() <= i {
a.push(json!(0));
}
a[i] = v;
}
}
None => {
m.insert(f.key.clone(), v);
}
}
}
Value::Object(m)
}
}
/// Open a form dialog.
pub fn form(app: &mut EffectcraftApp, title: &str, command: &str, base: Value, fields: Vec<Field>) {
app.dialog_state.form = Form { title: title.into(), command: command.into(), base, fields };
app.dialog = Some(Dialog::Form);
}
/// Open a message box.
pub fn info(app: &mut EffectcraftApp, title: &str, body: &str) {
app.dialog_state.info = (title.into(), body.into());
app.dialog = Some(Dialog::Info);
}
fn has(p: &Value, keys: &[&str]) -> bool {
keys.iter().any(|k| p.get(*k).is_some())
}
/// If `id` is a dialog command invoked without its parameters, open its form and return true.
pub fn open_form(app: &mut EffectcraftApp, id: &str, p: &Value) -> bool {
let s = &app.session;
let comp = s.active_comp();
let layer = comp.and_then(|c| s.state.selected_layers.first().and_then(|l| c.layer(*l)));
let t = s.time();
let lt = layer.map(|l| l.layer_time(t)).unwrap_or(t);
let base = p.clone();
let (title, fields): (String, Vec<Field>) = match id {
"layer.setTransform" if !has(p, &["value"]) => {
let prop = p.get("prop").and_then(Value::as_str).unwrap_or("position");
let cur = layer.and_then(|l| l.transform()).and_then(|tr| tr.get(if prop == "anchorPoint" { "anchor" } else { prop })).map(|pr| pr.value_at(lt));
let v = cur.map(|c| c.as_vec3()).unwrap_or([0.0; 3]);
let three = layer.is_some_and(|l| l.is_3d());
let title = match prop {
"anchor" => "Anchor Point",
"position" => "Position",
"scale" => "Scale",
"orientation" => "Orientation",
"rotation" => "Rotation",
_ => "Opacity",
};
let fields = match prop {
"rotation" | "opacity" => vec![Field::num("value", if prop == "rotation" { "Degrees" } else { "Opacity (%)" }, v[0])],
"orientation" => vec![Field::num("value[0]", "X", v[0]), Field::num("value[1]", "Y", v[1]), Field::num("value[2]", "Z", v[2])],
_ if three => vec![Field::num("value[0]", "X", v[0]), Field::num("value[1]", "Y", v[1]), Field::num("value[2]", "Z", v[2])],
_ => vec![Field::num("value[0]", "X", v[0]), Field::num("value[1]", "Y", v[1])],
};
(title.into(), fields)
}
"layer.mask.set" if !has(p, &["value"]) => {
let field = p.get("field").and_then(Value::as_str).unwrap_or("feather");
let first = layer.and_then(|l| l.masks()).and_then(|m| m.groups().next()).and_then(|g| g.get(field)).map(|pr| pr.value_at(lt).as_f64());
let (title, label, d) = match field {
"feather" => ("Mask Feather", "Feather (pixels)", 0.0),
"opacity" => ("Mask Opacity", "Opacity (%)", 100.0),
_ => ("Mask Expansion", "Expansion (pixels)", 0.0),
};
(title.into(), vec![Field::num("value", label, first.unwrap_or(d))])
}
"layer.mask.shape" if !has(p, &["rect"]) => {
let (w, h) = layer.map(|l| effectcraft_engine::render::source_size(&s.project, l)).unwrap_or((100, 100));
(
"Mask Shape".into(),
vec![
Field::num("rect[0]", "Left", 0.0),
Field::num("rect[1]", "Top", 0.0),
Field::num("rect[2]", "Width", w as f64),
Field::num("rect[3]", "Height", h as f64),
Field::choice("shape", "Shape", &[("Rectangle", json!("rect")), ("Ellipse", json!("ellipse"))], 0),
],
)
}
"layer.autoOrient" if !has(p, &["mode"]) => {
let cur = layer.map(|l| l.auto_orient as usize).unwrap_or(0);
(
"Auto-Orientation".into(),
vec![Field::choice(
"mode",
"Mode",
&[
("Off", json!("off")),
("Orient Along Path", json!("alongPath")),
("Orient Towards Camera", json!("towardsCamera")),
("Orient Towards Point of Interest", json!("towardsPointOfInterest")),
],
cur.min(3),
)],
)
}
"time.set" if !has(p, &["time", "frame", "timecode"]) => {
let frame = comp.map(|c| c.frame_rate.frame_at(t)).unwrap_or(0);
("Go to Time".into(), vec![Field::num("frame", "Frame", frame as f64)])
}
"view.addGuide" if !has(p, &["position"]) => {
let (w, _) = comp.map(|c| (c.width, c.height)).unwrap_or((1920, 1080));
(
"Add Guide".into(),
vec![
Field::choice("orientation", "Orientation", &[("Vertical", json!("vertical")), ("Horizontal", json!("horizontal"))], 0),
Field::num("position", "Position (pixels)", w as f64 / 2.0),
],
)
}
"layer.sequence" if !has(p, &["overlap"]) => (
"Sequence Layers".into(),
vec![
Field::bool("overlap", "Overlap", false),
Field::num("duration", "Duration (seconds)", 1.0),
Field::choice(
"transition",
"Transition",
&[
("Off", json!("off")),
("Dissolve Front Layer", json!("dissolveFront")),
("Cross Dissolve Front and Back Layers", json!("crossDissolve")),
],
0,
),
],
),
"file.interpretFootage" if !has(p, &["frameRate", "alpha", "loop", "pixelAspect"]) => {
let f = s.state.project_selection.first().and_then(|i| s.project.item(*i)).and_then(|it| match &it.kind {
effectcraft_engine::project::ItemKind::Footage(f) => Some(f.clone()),
_ => None,
});
let Some(f) = f else { return false };
(
"Interpret Footage".into(),
vec![
Field::num("frameRate", "Frame rate", f.frame_rate.as_f64()),
Field::choice(
"alpha",
"Alpha",
&[("Straight", json!("straight")), ("Premultiplied", json!("premultiplied")), ("Ignore", json!("ignore"))],
f.alpha as usize,
),
Field::num("loop", "Loop (times)", f.loop_count as f64),
Field::num("pixelAspect", "Pixel aspect ratio", f.pixel_aspect),
],
)
}
"file.projectSettings" if p.as_object().is_none_or(|m| m.is_empty()) => {
let st = &s.project.settings;
let depth = match st.bit_depth.label() {
l if l.starts_with("16") => 1,
l if l.starts_with("32") => 2,
_ => 0,
};
(
"Project Settings".into(),
vec![
Field::choice(
"bitDepth",
"Depth",
&[("8 bits per channel", json!(8)), ("16 bits per channel", json!(16)), ("32 bits per channel (float)", json!(32))],
depth,
),
Field::choice(
"timeDisplay",
"Time display style",
&[("Timecode", json!("timecode")), ("Frames", json!("frames"))],
usize::from(matches!(st.time_display, effectcraft_engine::project::TimeDisplayStyle::Frames)),
),
Field::bool("linearize", "Linearize working space", st.linearize),
],
)
}
"layer.precompose" if !has(p, &["name"]) => {
let n = s.project.comps().count() + 1;
("Pre-compose".into(), vec![Field::text("name", "New composition name", &format!("Pre-comp {n}"))])
}
"file.importPlaceholder" | "file.replaceWithPlaceholder" if p.as_object().is_none_or(|m| m.is_empty()) => (
"New Placeholder".into(),
vec![
Field::text("name", "Name", "Placeholder"),
Field::num("width", "Width", 1920.0),
Field::num("height", "Height", 1080.0),
Field::num("frameRate", "Frame rate", 29.97),
Field::num("duration", "Duration (seconds)", 30.0),
],
),
"file.importSolid" | "file.replaceWithSolid" if p.as_object().is_none_or(|m| m.is_empty()) => {
let (w, h) = comp.map(|c| (c.width, c.height)).unwrap_or((1920, 1080));
(
"Solid Settings".into(),
vec![
Field::text("name", "Name", "Solid"),
Field::text("color", "Color (#rrggbb)", "#808080"),
Field::num("width", "Width", w as f64),
Field::num("height", "Height", h as f64),
],
)
}
_ => return false,
};
form(app, &title, id, base, fields);
true
}
pub fn show_form(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
let mut f = app.dialog_state.form.clone();
let (mut ok, mut close) = (false, false);
let h = 120.0 + f.fields.len() as f32 * 30.0;
super::dialogs::modal(ctx, &f.title.clone(), vec2(440.0, h), t, |ui| {
egui::Grid::new("form-grid").num_columns(2).spacing([14.0, 10.0]).show(ui, |ui| {
for fl in &mut f.fields {
ui.label(&fl.label);
match &mut fl.kind {
FieldKind::Number { value, speed } => {
ui.add(egui::DragValue::new(value).speed(*speed).max_decimals(3));
}
FieldKind::Text(s) => {
ui.add(egui::TextEdit::singleline(s).desired_width(220.0));
}
FieldKind::Bool(b) => {
ui.checkbox(b, "");
}
FieldKind::Choice { options, sel } => {
let cur = options.get(*sel).map(|o| o.0.clone()).unwrap_or_default();
egui::ComboBox::from_id_salt(("form", fl.key.as_str())).selected_text(cur).width(240.0).show_ui(ui, |ui| {
for (i, (l, _)) in options.iter().enumerate() {
ui.selectable_value(sel, i, l);
}
});
}
}
ui.end_row();
}
});
ui.add_space(14.0);
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.add(egui::Button::new(egui::RichText::new(" OK ").color(Color32::WHITE)).fill(t.accent)).clicked() {
ok = true;
}
if ui.button("Cancel").clicked() {
close = true;
}
});
});
let enter = !ctx.egui_wants_keyboard_input() && ctx.input(|i| i.key_pressed(egui::Key::Enter));
app.dialog_state.form = f.clone();
if ok || enter {
app.dialog = None;
let params = f.params();
if let Err(e) = app.session.execute(&f.command, params) {
app.ui.status = e.to_string();
}
return;
}
if close {
app.dialog = None;
}
}
pub fn show_info(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
let (title, body) = app.dialog_state.info.clone();
let mut close = false;
super::dialogs::modal(ctx, &title, vec2(440.0, 160.0), t, |ui| {
ui.label(body);
ui.add_space(16.0);
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.add(egui::Button::new(egui::RichText::new(" OK ").color(Color32::WHITE)).fill(t.accent)).clicked() {
close = true;
}
});
});
if close {
app.dialog = None;
}
}
pub const SETTINGS_PAGES: [(&str, &str); 17] = [
("general", "General"),
("startup", "Startup & Repair"),
("project", "Project"),
("composition", "Composition"),
("previews", "Previews"),
("appearance", "Appearance"),
("grids", "Grids & Guides"),
("labels", "Labels"),
("type", "Type"),
("import", "Import"),
("export", "Export"),
("audio", "Audio"),
("disk", "Disk"),
("memory", "Memory & CPU"),
("video", "Video"),
("3d", "3D"),
("scripting", "Scripting & Expressions"),
];
pub fn show_settings(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
let mut page = app.dialog_state.settings_page.clone();
let mut close = false;
let mut theme = None;
super::dialogs::modal(ctx, "Settings", vec2(640.0, 440.0), t, |ui| {
ui.horizontal_top(|ui| {
ui.vertical(|ui| {
ui.set_width(170.0);
for (id, label) in SETTINGS_PAGES {
if ui.selectable_label(page == id, label).clicked() {
page = id.to_string();
}
}
});
ui.separator();
ui.vertical(|ui| {
let title = SETTINGS_PAGES.iter().find(|p| p.0 == page).map(|p| p.1).unwrap_or("General");
ui.label(egui::RichText::new(title).font(Tokens::semibold(13.0)));
ui.add_space(8.0);
match page.as_str() {
"general" => {
ui.checkbox(&mut app.ui.show_menu_bar, "Show the in-window menu bar");
ui.checkbox(&mut app.ui.snapping, "Snapping");
}
"appearance" => {
for (k, name) in [("dark", "Dark"), ("darker", "Darker"), ("light", "Light")] {
if ui.button(name).clicked() {
theme = crate::theme::ThemeKind::from_name(k);
}
}
}
"previews" => {
ui.checkbox(&mut app.ui.cache_when_idle, "Cache frames when idle");
ui.checkbox(&mut app.ui.viewer.fast_preview, "Fast previews");
}
"grids" => {
ui.checkbox(&mut app.ui.viewer.grid, "Show grid");
ui.checkbox(&mut app.ui.viewer.guides, "Show guides");
ui.checkbox(&mut app.ui.viewer.safe_margins, "Show title/action safe");
}
"labels" => {
for l in effectcraft_engine::color::Label::ALL.into_iter().skip(1) {
ui.horizontal(|ui| {
let [r, g, b] = l.rgb();
let (rect, _) = ui.allocate_exact_size(vec2(26.0, 14.0), egui::Sense::hover());
ui.painter().rect_filled(rect, 2.0, Color32::from_rgb(r, g, b));
ui.label(l.name());
});
}
}
_ => {
ui.label(egui::RichText::new("No options on this page yet.").color(t.text_dim));
}
}
});
});
ui.add_space(10.0);
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.add(egui::Button::new(egui::RichText::new(" OK ").color(Color32::WHITE)).fill(t.accent)).clicked() {
close = true;
}
});
});
app.dialog_state.settings_page = page;
if let Some(k) = theme {
app.set_theme(ctx, k);
}
if close {
app.dialog = None;
}
}
pub fn show_shortcuts(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
let mut q = app.dialog_state.palette_query.clone();
let mut close = false;
// (shortcut, where, label)
let mut rows: Vec<(String, String, String)> = vec![];
for (path, e) in effectcraft_engine::menus::entries() {
if let Some(sc) = &e.shortcut {
rows.push((crate::menus::shortcut_text(sc), path.join(" ▸ "), e.label.clone()));
}
}
for c in effectcraft_engine::command_specs().iter().filter(|c| c.menu.is_empty()) {
if let Some(sc) = c.shortcut
&& !rows.iter().any(|r| r.2 == c.label)
{
rows.push((crate::menus::shortcut_text(sc), "Commands".into(), c.label.to_string()));
}
}
for c in crate::menus::UI_COMMANDS {
if let Some(sc) = c.shortcut {
rows.push((crate::menus::shortcut_text(sc), "Panels & Tools".into(), c.label.to_string()));
}
}
super::dialogs::modal(ctx, "Keyboard Shortcuts", vec2(640.0, 520.0), t, |ui| {
ui.add(egui::TextEdit::singleline(&mut q).hint_text("Search commands or shortcuts").desired_width(f32::INFINITY));
ui.add_space(8.0);
let ql = q.to_lowercase();
egui::ScrollArea::vertical().max_height(400.0).show(ui, |ui| {
egui::Grid::new("shortcut-grid").num_columns(3).striped(true).spacing([18.0, 4.0]).show(ui, |ui| {
for (sc, place, label) in rows.iter().filter(|r| ql.is_empty() || format!("{} {} {}", r.0, r.1, r.2).to_lowercase().contains(&ql)) {
ui.label(egui::RichText::new(sc).monospace());
ui.label(label);
ui.label(egui::RichText::new(place).color(t.text_dim));
ui.end_row();
}
});
});
ui.add_space(8.0);
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.add(egui::Button::new(egui::RichText::new(" OK ").color(Color32::WHITE)).fill(t.accent)).clicked() {
close = true;
}
});
});
app.dialog_state.palette_query = q;
if close {
app.dialog = None;
}
}
pub fn show_view_options(app: &mut EffectcraftApp, ctx: &egui::Context, t: &Tokens) {
let mut close = false;
super::dialogs::modal(ctx, "View Options", vec2(360.0, 330.0), t, |ui| {
let v = &mut app.ui.viewer;
ui.checkbox(&mut v.show_layer_controls, "Layer controls");
ui.checkbox(&mut v.show_masks, "Masks");
ui.checkbox(&mut v.rulers, "Rulers");
ui.checkbox(&mut v.guides, "Guides");
ui.checkbox(&mut v.grid, "Grid");
ui.checkbox(&mut v.safe_margins, "Title/action safe");
ui.checkbox(&mut v.transparency_grid, "Transparency grid");
ui.add_space(12.0);
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.add(egui::Button::new(egui::RichText::new(" OK ").color(Color32::WHITE)).fill(t.accent)).clicked() {
close = true;
}
});
});
if close {
app.dialog = None;
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn form_params_build_arrays_and_choices() {
let f = Form {
title: "T".into(),
command: "layer.setTransform".into(),
base: json!({"prop": "position"}),
fields: vec![
Field::num("value[0]", "X", 10.0),
Field::num("value[1]", "Y", 20.0),
Field::choice("mode", "M", &[("A", json!("a")), ("B", json!("b"))], 1),
],
};
assert_eq!(f.params(), json!({"prop": "position", "value": [10.0, 20.0], "mode": "b"}));
}
}
+1 -1
View File
@@ -53,7 +53,7 @@ pub fn preview(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
p.text(pos2(lr.max.x + 6.0, yy), Align2::LEFT_CENTER, "Loop", Tokens::ui(12.0), t.text);
let ar = Rect::from_min_size(pos2(rect.min.x + 90.0, yy - 8.0), vec2(16.0, 16.0));
if widgets::checkbox(ui, ar, app.ui.preview_audio, &t, egui::Id::new("pv-audio")).clicked() {
let _ = crate::menus::invoke(app, &ctx, "playback.muteAudio", json!({}));
let _ = crate::menus::invoke(app, &ctx, "playback.audio", json!({}));
}
app.auto.add("preview.audio", ar, "Include Audio");
p.text(pos2(ar.max.x + 6.0, yy), Align2::LEFT_CENTER, "Include Audio", Tokens::ui(12.0), t.text);
+1
View File
@@ -5,6 +5,7 @@ pub mod dialogs;
pub mod dialogs_3d;
pub mod effect_controls;
pub mod effects_presets;
pub mod forms;
pub mod graph;
pub mod info;
pub mod key_dialogs;
+65 -5
View File
@@ -27,6 +27,8 @@ enum RowKind {
open: bool,
has_children: bool,
fx: Option<bool>,
/// Eye switch (layer styles).
eye: Option<bool>,
},
Prop {
uid: u64,
@@ -256,6 +258,7 @@ fn build_rows(app: &EffectcraftApp, comp: &Comp) -> Vec<Row> {
open: tl.open_groups.contains(&g.uid),
has_children: true,
fx: Some(g.enabled),
eye: None,
},
});
if tl.open_groups.contains(&g.uid) {
@@ -270,7 +273,14 @@ fn build_rows(app: &EffectcraftApp, comp: &Comp) -> Vec<Row> {
rows.push(Row {
layer: l.id,
depth: 1,
kind: RowKind::Group { uid: g.uid, name: g.name.clone(), open: tl.open_groups.contains(&g.uid), has_children: true, fx: None },
kind: RowKind::Group {
uid: g.uid,
name: g.name.clone(),
open: tl.open_groups.contains(&g.uid),
has_children: true,
fx: None,
eye: None,
},
});
if tl.open_groups.contains(&g.uid) {
push_group(&mut rows, l, g, 2, &tl.open_groups);
@@ -278,6 +288,36 @@ fn build_rows(app: &EffectcraftApp, comp: &Comp) -> Vec<Row> {
}
}
}
"props" => {
// Animation ▸ Reveal Properties…: the engine picked the uids.
fn groups_in<'a>(g: &'a PropGroup, set: &std::collections::BTreeSet<u64>, out: &mut Vec<&'a PropGroup>) {
for sg in g.groups() {
if set.contains(&sg.uid) {
out.push(sg);
} else {
groups_in(sg, set, out);
}
}
}
let mut groups = vec![];
groups_in(&l.props, &tl.reveal_props, &mut groups);
for g in groups {
let open = tl.open_groups.contains(&g.uid);
rows.push(Row {
layer: l.id,
depth: 1,
kind: RowKind::Group { uid: g.uid, name: g.name.clone(), open, has_children: !g.children.is_empty(), fx: None, eye: None },
});
if open {
push_group(&mut rows, l, g, 2, &tl.open_groups);
}
}
let mut found = vec![];
collect_props(&l.props, &mut found, &|p| prop_visible(p, l) && tl.reveal_props.contains(&p.uid));
for uid in found {
rows.push(Row { layer: l.id, depth: 1, kind: RowKind::Prop { uid } });
}
}
_ => {
let mut found = vec![];
let root = if group.is_empty() {
@@ -304,7 +344,14 @@ fn build_rows(app: &EffectcraftApp, comp: &Comp) -> Vec<Row> {
rows.push(Row {
layer: l.id,
depth: 1,
kind: RowKind::Group { uid: g.uid, name: g.name.clone(), open, has_children: !g.children.is_empty(), fx: None },
kind: RowKind::Group {
uid: g.uid,
name: g.name.clone(),
open,
has_children: !g.children.is_empty(),
fx: None,
eye: (g.match_id == effectcraft_engine::project::styles::GROUP).then_some(g.enabled),
},
});
if open {
push_group(&mut rows, l, g, 2, &tl.open_groups);
@@ -317,7 +364,7 @@ fn build_rows(app: &EffectcraftApp, comp: &Comp) -> Vec<Row> {
rows.push(Row {
layer: l.id,
depth: 2,
kind: RowKind::Group { uid: wuid, name: "Waveform".into(), open: wopen, has_children: true, fx: None },
kind: RowKind::Group { uid: wuid, name: "Waveform".into(), open: wopen, has_children: true, fx: None, eye: None },
});
if wopen {
rows.push(Row { layer: l.id, depth: 3, kind: RowKind::Waveform { item: item.0 } });
@@ -349,10 +396,13 @@ fn push_group(rows: &mut Vec<Row>, l: &Layer, g: &PropGroup, depth: usize, open:
Node::Group(sg) => {
let o = open.contains(&sg.uid);
let fx = matches!(sg.kind, GroupKind::Effect { .. }).then_some(sg.enabled);
// Layer style groups have eye switches (not Blending Options).
let eye = (g.match_id == effectcraft_engine::project::styles::GROUP && sg.match_id != effectcraft_engine::project::styles::BLENDING)
.then_some(sg.enabled);
rows.push(Row {
layer: l.id,
depth,
kind: RowKind::Group { uid: sg.uid, name: sg.name.clone(), open: o, has_children: !sg.children.is_empty(), fx },
kind: RowKind::Group { uid: sg.uid, name: sg.name.clone(), open: o, has_children: !sg.children.is_empty(), fx, eye },
});
if o {
push_group(rows, l, sg, depth + 1, open);
@@ -943,7 +993,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
}
}
}
RowKind::Group { uid, name, open, has_children, fx } => {
RowKind::Group { uid, name, open, has_children, fx, eye } => {
lp.rect_filled(left, 0.0, if ri % 2 == 0 { t.row } else { t.row_alt });
gp.rect_filled(Rect::from_min_max(pos2(graph_x0, r.min.y), r.max), 0.0, t.tl_bg);
let indent = cw.name + 6.0 + 14.0 * row.depth as f32;
@@ -959,6 +1009,16 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
if widgets::icon_toggle(ui, fr_, Icon::Fx, *en, &t, egui::Id::new(("gfx", uid)), None).clicked() {
actions.push(("effect.toggle".into(), json!({"layer": layer.id.0, "effect": uid})));
}
app.auto.add(&format!("timeline.group.{uid}.fx"), fr_, name);
}
if let Some(en) = eye {
// Layer style eye switch in the A/V column, like AE.
let er = Rect::from_center_size(pos2(cw.av + 10.0, cy), vec2(17.0, 17.0));
lp.rect_stroke(er.shrink(1.5), 2.0, Stroke::new(1.0, t.separator), StrokeKind::Inside);
if widgets::icon_toggle(ui, er, Icon::Eye, *en, &t, egui::Id::new(("geye", uid)), None).clicked() {
actions.push(("layer.style.toggle".into(), json!({"layer": layer.id.0, "style": uid})));
}
app.auto.add(&format!("timeline.group.{uid}.eye"), er, name);
}
lp.text(pos2(indent + 10.0, cy), Align2::LEFT_CENTER, name, Tokens::ui(12.0), t.text);
// Mask mode + inverted inline.
+30 -2
View File
@@ -263,7 +263,8 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
let bar_h = 30.0;
let bar = Rect::from_min_max(pos2(rect.min.x, rect.max.y - bar_h), rect.max);
let area = Rect::from_min_max(pos2(rect.min.x, nav.max.y), pos2(rect.max.x, bar.min.y));
p.rect_filled(area, 0.0, t.pasteboard);
let pasteboard = app.ui.viewer.pasteboard.map(|[r, g, b]| Color32::from_rgb(r, g, b)).unwrap_or(t.pasteboard);
p.rect_filled(area, 0.0, pasteboard);
let (cw, ch) = (comp.width as f32, comp.height as f32);
let fit = ((area.width() - 40.0) / cw).min((area.height() - 40.0) / ch).max(0.01);
@@ -340,6 +341,24 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
}
}
// Comp guides (View ▸ Show Guides) and the region of interest.
if app.ui.viewer.guides {
let stroke = Stroke::new(1.0, Color32::from_rgb(0x3c, 0xc8, 0xf0));
for g in &comp.guides {
if g.vertical {
let x = comp_rect.min.x + g.position as f32 * zoom;
painter.line_segment([pos2(x, area.min.y), pos2(x, area.max.y)], stroke);
} else {
let y = comp_rect.min.y + g.position as f32 * zoom;
painter.line_segment([pos2(area.min.x, y), pos2(area.max.x, y)], stroke);
}
}
}
if let Some([rx, ry, rw, rh]) = app.session.state.region_of_interest {
let r = Rect::from_min_size(comp_rect.min + vec2(rx as f32 * zoom, ry as f32 * zoom), vec2(rw as f32 * zoom, rh as f32 * zoom));
painter.rect_stroke(r, 0.0, Stroke::new(1.0, Color32::WHITE), StrokeKind::Middle);
}
// Overlays + interaction.
let snap_project = app.session.project.clone();
let snap_expr = app.session.expr.clone();
@@ -1207,7 +1226,16 @@ fn bottom_bar(app: &mut EffectcraftApp, ui: &mut egui::Ui, bar: Rect, zoom: f32,
app.ui.viewer.res = Resolution::ALL[i];
}
x = r.max.x + 6.0;
let _ = tog(ui, &mut app.auto, &mut x, Icon::Region, false, "roi", "Region of Interest");
let has_roi = app.session.state.region_of_interest.is_some();
if tog(ui, &mut app.auto, &mut x, Icon::Region, has_roi, "roi", "Region of Interest") {
// Toggle a centred region of interest (Composition ▸ Crop Comp to Region of Interest).
let rect = if has_roi {
serde_json::Value::Null
} else {
json!([comp.width as f64 / 4.0, comp.height as f64 / 4.0, comp.width as f64 / 2.0, comp.height as f64 / 2.0])
};
let _ = app.session.execute("view.setRegionOfInterest", json!({"rect": rect}));
}
if tog(ui, &mut app.auto, &mut x, Icon::Checker, app.ui.viewer.transparency_grid, "transparency", "Toggle Transparency Grid") {
app.ui.viewer.transparency_grid = !app.ui.viewer.transparency_grid;
}
+22
View File
@@ -199,6 +199,7 @@ impl Resolution {
}
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(default)]
pub struct ViewerState {
/// Magnification (1 = 100%); None = fit.
pub zoom: Option<f32>,
@@ -213,6 +214,14 @@ pub struct ViewerState {
pub channel: String,
pub show_layer_controls: bool,
pub fast_preview: bool,
/// View ▸ Show Guides / Snap to Guides / Lock Guides / Snap to Grid.
pub guides: bool,
pub snap_guides: bool,
pub lock_guides: bool,
pub snap_grid: bool,
/// View ▸ Panel Background Color (`None` = theme default).
pub pasteboard: Option<[u8; 3]>,
pub custom_pasteboard: [u8; 3],
}
impl Default for ViewerState {
@@ -229,6 +238,12 @@ impl Default for ViewerState {
channel: "RGB".into(),
show_layer_controls: true,
fast_preview: false,
guides: true,
snap_guides: false,
lock_guides: false,
snap_grid: false,
pasteboard: None,
custom_pasteboard: [0x80, 0x80, 0x80],
}
}
}
@@ -249,6 +264,9 @@ pub struct TimelineState {
pub open_groups: BTreeSet<u64>,
/// "Reveal" filter: only show these property match ids (P/S/R/T/A…) — empty = normal.
pub reveal: Vec<String>,
/// Properties / groups (uids) shown by the `props` reveal (Animation ▸ Reveal Properties…).
#[serde(default)]
pub reveal_props: BTreeSet<u64>,
/// Graph Editor: `value` or `speed` graph.
#[serde(default = "value_graph")]
pub graph_mode: String,
@@ -286,6 +304,7 @@ impl Default for TimelineState {
open_layers: BTreeSet::new(),
open_groups: BTreeSet::new(),
reveal: vec![],
reveal_props: BTreeSet::new(),
graph_mode: value_graph(),
graph_show_selected: true,
graph_auto_zoom: true,
@@ -342,6 +361,8 @@ pub struct UiState {
#[serde(default = "yes")]
pub preview_audio: bool,
pub start_screen: bool,
/// Composition ▸ Preview ▸ Cache Frames When Idle.
pub cache_when_idle: bool,
}
impl Default for UiState {
@@ -374,6 +395,7 @@ impl Default for UiState {
preview_cache_first: false,
preview_audio: true,
start_screen: false,
cache_when_idle: false,
}
}
}
+9 -1
View File
@@ -61,7 +61,7 @@ text animators and shape contents are groups in the same tree.
`Renderer::comp_frame(comp, t)` walks the layers bottom to top. For each visible layer it renders
the **source** (solid, footage frame, text, shape contents, or a nested comp), applies **masks**,
then **effects** in order, then the **transform** into comp space (with motion blur sub-samples
then **effects** in order, then **layer styles**, then the **transform** into comp space (with motion blur sub-samples
when enabled), the **track matte**, and finally **blends** into the accumulator. Adjustment layers
apply their effects to the accumulator. Runs of 3D layers are composited per pixel through the
active camera, with lights, shadows and depth of field.
@@ -81,6 +81,14 @@ the Effect > Audio effects (`effects::audio_fx`, applied per layer with a pre-ro
independent). Export and preview playback share it; the desktop app plays it through cpal and the
audio clock drives preview playback (`ui-egui::audio`).
**Layer styles** (Layer ▸ Layer Styles; `crates/render/src/styles.rs`) render in layer space and
may grow the layer's bounds. Drop Shadow and Outer Glow become separate passes composited below the
layer with their own blend modes; the interior styles, Stroke and Bevel and Emboss are baked into
the layer body. Layer opacity fades the whole stack; Knockout and the R/G/B channel switches apply
at composite time. Styled pixels are cached separately from the layer content, so editing a style
reuses the cached source/masks/effects. Global Light is one setting per comp, mirrored into every
layer's Blending Options and kept in step after each edit.
Half, Third and Quarter resolution render proportionally fewer pixels end to end.
## 5. Expressions
Binary file not shown.

After

Width:  |  Height:  |  Size: 658 KiB

@@ -0,0 +1,8 @@
asset: effectcraft-3d.png
title: EffectCraft Classic 3D
author: EffectCraft contributors
source: original work (headless render of the EffectCraft UI via crates/ui-egui/examples/snapshot.rs)
license: MIT OR Apache-2.0
license-file:
added: 2026-10-01 by Claude (agent) for Brandon Thomas
notes: Screenshot of EffectCraft only, showing procedurally generated demo content from crates/engine/src/demo.rs and built-in effects. EffectCraft Classic 3D: the demo "3D Showcase" composition in Custom View 1, showing intersecting 3D planes, spot-light shadows, the camera frustum and light wireframes.
Binary file not shown.

After

Width:  |  Height:  |  Size: 446 KiB

@@ -0,0 +1,8 @@
asset: effectcraft-effects.png
title: EffectCraft effects
author: EffectCraft contributors
source: original work (headless render of the EffectCraft UI via crates/ui-egui/examples/snapshot.rs)
license: MIT OR Apache-2.0
license-file:
added: 2026-10-01 by Claude (agent) for Brandon Thomas
notes: Screenshot of EffectCraft only, showing procedurally generated demo content from crates/engine/src/demo.rs and built-in effects. EffectCraft effects: a CC Particle World particle burst with Glow on a black solid, with the Effect Controls panel listing its parameters.
Binary file not shown.

After

Width:  |  Height:  |  Size: 740 KiB

@@ -0,0 +1,8 @@
asset: effectcraft-graph-editor.png
title: EffectCraft Graph Editor
author: EffectCraft contributors
source: original work (headless render of the EffectCraft UI via crates/ui-egui/examples/snapshot.rs)
license: MIT OR Apache-2.0
license-file:
added: 2026-10-01 by Claude (agent) for Brandon Thomas
notes: Screenshot of EffectCraft only, showing procedurally generated demo content from crates/engine/src/demo.rs and built-in effects. EffectCraft Graph Editor: the value graph of the EFFECTCRAFT text animator Range Start keyframes with easing, and the graph editor button bar.
Binary file not shown.

After

Width:  |  Height:  |  Size: 746 KiB

@@ -0,0 +1,8 @@
asset: effectcraft-hero.png
title: EffectCraft main window
author: EffectCraft contributors
source: original work (headless render of the EffectCraft UI via crates/ui-egui/examples/snapshot.rs)
license: MIT OR Apache-2.0
license-file:
added: 2026-10-01 by Claude (agent) for Brandon Thomas
notes: Screenshot of EffectCraft only, showing procedurally generated demo content from crates/engine/src/demo.rs and built-in effects. EffectCraft main window: the demo composition "EffectCraft Intro" at 0:00:03:00 with the EFFECTCRAFT text layer selected, Properties panel (Layer Transform, Text, Paragraph, Text Animation), Project panel and Timeline.
Binary file not shown.

After

Width:  |  Height:  |  Size: 611 KiB

@@ -0,0 +1,8 @@
asset: effectcraft-render-queue.png
title: EffectCraft Render Queue panel with the demo compositions queued for H.264 and ProRes export
author: EffectCraft contributors
source: original work (headless render of the EffectCraft UI via crates/ui-egui/examples/snapshot.rs)
license: MIT OR Apache-2.0
license-file:
added: 2026-10-01 by Claude (agent) for Brandon Thomas
notes: Screenshot of EffectCraft only, showing procedurally generated demo content from crates/engine/src/demo.rs and built-in effects. EffectCraft Render Queue panel with the demo compositions queued for H.264 and ProRes export.