Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

Keyframes: mute keyframes without deleting them (#1894)

Camille Moine047ffbaba516
diff --git a/crates/engine/src/cmd/prop.rs b/crates/engine/src/cmd/prop.rs
index ab2f0a1e2..663429fb2 100644
--- a/crates/engine/src/cmd/prop.rs
+++ b/crates/engine/src/cmd/prop.rs
@@ -1189,6 +1189,15 @@ fn toggle_hold(s: &mut Session, _: &Value) -> Result<Value> {
})
}
+fn set_muted(s: &mut Session, p: &Value) -> Result<Value> {
+ let muted = b_p(p, "muted").unwrap_or(true);
+ let label = if muted { "Mute Keyframes" } else { "Unmute Keyframes" };
+ edit_keys(s, label, None, move |keys, i, _| {
+ keys[i].muted = muted;
+ false
+ })
+}
+
/// A number or a per-dimension array of numbers.
fn nums_p(p: &Value, k: &str, scale: f64) -> Option<Vec<f64>> {
match p.get(k)? {
@@ -1381,6 +1390,7 @@ pub fn specs() -> Vec<CommandSpec> {
&json!({"which": "out"})
)),
cmd!("keys.toggleHold", "Toggle Hold Keyframe", ["Animation"], Some("Cmd+Alt+H"), "{}", has_keys, toggle_hold),
+ cmd!("keys.setMuted", "Mute Keyframes", ["Animation"], None, "{muted?: bool (default true)}", has_keys, set_muted),
cmd!(
"keys.interpolation",
"Keyframe Interpolation...",
diff --git a/crates/engine/src/menus.rs b/crates/engine/src/menus.rs
index 9296e1322..3a240fc60 100644
--- a/crates/engine/src/menus.rs
+++ b/crates/engine/src/menus.rs
@@ -1036,6 +1036,7 @@ Animation
---
Add Keyframe | anim.addKeyframe
Toggle Hold Keyframe | keys.toggleHold
+ Mute Keyframes | keys.setMuted
Keyframe Interpolation... | keys.interpolation
Keyframe Velocity... | keys.velocity
Keyframe Assistant
diff --git a/crates/engine/src/tests/menu_cmds.rs b/crates/engine/src/tests/menu_cmds.rs
index 93f81736f..f5db9500c 100644
--- a/crates/engine/src/tests/menu_cmds.rs
+++ b/crates/engine/src/tests/menu_cmds.rs
@@ -1483,6 +1483,32 @@ fn key_selection_toggles_and_skips_locked_layers_and_hold_restores_bezier() {
assert!(s.state.selected_keys.is_empty());
}
+#[test]
+fn muting_keys_skips_them_in_the_timeline_value_and_undoes() {
+ let mut s = comp();
+ let a = solid(&mut s, "#ff0000");
+ for (t, v) in [(0.0, 0.0), (1.0, 100.0), (2.0, 300.0)] {
+ s.execute("prop.addKey", json!({"layer": a, "path": "transform/opacity", "time": t, "value": v})).unwrap();
+ }
+ let value_at = |s: &Session, t: f64| layer(s, a).props.prop("transform/opacity").unwrap().value_at(Tick::from_seconds_f64(t)).as_f64();
+ let select = |s: &mut Session| s.execute("keys.select", json!({"keys": [{"layer": a, "path": "transform/opacity", "time": 1.0}]})).unwrap();
+ select(&mut s);
+ let before = value_at(&s, 0.5);
+ s.execute("keys.setMuted", json!({"muted": true})).unwrap();
+ assert!(layer(&s, a).props.prop("transform/opacity").unwrap().keys[1].muted);
+ // The muted key no longer bends the 0 → 300 segment.
+ assert!((value_at(&s, 0.5) - 75.0).abs() < 1e-6);
+ assert!((value_at(&s, 1.5) - 225.0).abs() < 1e-6);
+ s.undo();
+ assert!(!layer(&s, a).props.prop("transform/opacity").unwrap().keys[1].muted);
+ assert!((value_at(&s, 0.5) - before).abs() < 1e-6);
+ // The same command unmutes.
+ select(&mut s);
+ s.execute("keys.setMuted", json!({"muted": true})).unwrap();
+ s.execute("keys.setMuted", json!({"muted": false})).unwrap();
+ assert!(!layer(&s, a).props.prop("transform/opacity").unwrap().keys[1].muted);
+}
+
#[test]
fn transform_drags_apply_their_whole_offset_to_the_keys_they_started_with() {
let mut s = comp();
diff --git a/crates/interchange/src/export.rs b/crates/interchange/src/export.rs
index 7da18913a..cc44475f3 100644
--- a/crates/interchange/src/export.rs
+++ b/crates/interchange/src/export.rs
@@ -155,12 +155,7 @@ fn unsupported(project: &Project, comp: &Comp, l: &Layer, format: TimelineFormat
return Some(format!("blend mode {}", l.blend_mode.label()));
}
// Premiere's Basic Motion in the interchange formats has one (uniform) scale.
- if let Some(s) = l.transform().and_then(|t| t.get("scale"))
- && std::iter::once(&s.value).chain(s.keys.iter().map(|k| &k.value)).any(|v| {
- let a = v.as_vec3();
- (a[0] - a[1]).abs() > 1e-9
- })
- {
+ if l.transform().and_then(|t| t.get("scale")).is_some_and(non_uniform_scale) {
return Some("non-uniform scale".into());
}
if l.preserve_transparency {
@@ -581,10 +576,7 @@ impl Exporter<'_> {
}
}
if let Some(p) = tr.get("scale") {
- let uniform = std::iter::once(&p.value).chain(p.keys.iter().map(|k| &k.value)).all(|v| {
- let a = v.as_vec3();
- (a[0] - a[1]).abs() < 1e-9
- });
+ let uniform = !non_uniform_scale(p);
m.params.insert("scale".into(), param_out(p, &to_clip, |v| fp::ParamValue::Float(v.as_vec3()[1])));
if !uniform {
m.params.insert("scale_width".into(), param_out(p, &to_clip, |v| fp::ParamValue::Float(v.as_vec3()[0])));
@@ -636,6 +628,16 @@ fn differs(v: &Value, def: [f64; 2]) -> bool {
(a[0] - def[0]).abs() > 1e-6 || (a[1] - def[1]).abs() > 1e-6
}
+/// Whether a scale property is non-uniform at some point: active key values, or the static
+/// value when every key is muted (muted keys are not exported, #1894).
+fn non_uniform_scale(p: &Property) -> bool {
+ let non_uniform = |v: &Value| {
+ let a = v.as_vec3();
+ (a[0] - a[1]).abs() > 1e-9
+ };
+ if p.keys.iter().any(|k| !k.muted) { p.keys.iter().filter(|k| !k.muted).any(|k| non_uniform(&k.value)) } else { non_uniform(&p.value) }
+}
+
/// The clip's `id` effect, or a new instance of it (None if the registry has no such effect).
fn effect_or_new(ti: &fp::TrackItem, id: &str) -> Option<fp::EffectInstance> {
ti.effect(id).cloned().or_else(|| fp::find_effect(id).map(|e| e.instance()))
@@ -651,7 +653,9 @@ fn set_effect(ti: &mut fp::TrackItem, e: fp::EffectInstance) {
/// A property → a FilmCraft parameter (layer-time keys → clip-time keys).
fn param_out(p: &Property, to_clip: &impl Fn(Tick) -> filmcraft_time::Tick, conv: impl Fn(&Value) -> fp::ParamValue) -> fp::Param {
let mut out = fp::Param::new(conv(&p.value));
- for k in &p.keys {
+ // XML timelines have no mute state: leave muted keys out, as the Lottie exporter does, so
+ // the exported animation matches what the renderer shows (#1894).
+ for k in p.keys.iter().filter(|k| !k.muted) {
let mut fk = fp::Keyframe::new(to_clip(k.time), conv(&k.value));
fk.interp = match k.out_interp {
Interp::Linear => fp::Interpolation::Linear,
diff --git a/crates/interchange/src/tests.rs b/crates/interchange/src/tests.rs
index 1e0c7d417..2fe36d47b 100644
--- a/crates/interchange/src/tests.rs
+++ b/crates/interchange/src/tests.rs
@@ -480,6 +480,59 @@ fn tr_orig(l: &Layer) -> &effectcraft_project::Property {
l.transform().unwrap().get("position").unwrap()
}
+/// #1894: XML timelines have no mute state, so a muted key must not be written as a keyframe
+/// (the export would otherwise animate through it).
+#[test]
+fn export_skips_muted_keyframes() {
+ let mut p = Project::default();
+ let a = footage_item(&mut p, "/media/a.mov");
+ let mut c = Comp::new(W, H, FrameRate::new(25, 1), t(4.0));
+ let mut l = effectcraft_project::build::layer(&mut p, &c, "clip", LayerSource::Footage { item: a }, (W, H), None);
+ {
+ let pos = l.transform_mut().unwrap().get_mut("position").unwrap();
+ pos.keys = vec![
+ Keyframe::new(t(0.0), Value::Vec3([100.0, 120.0, 0.0])),
+ Keyframe::new(t(1.0), Value::Vec3([500.0, 240.0, 0.0])),
+ Keyframe::new(t(2.0), Value::Vec3([300.0, 60.0, 0.0])),
+ ];
+ pos.keys[1].muted = true;
+ }
+ c.layers.push(l);
+ let cid = comp_item(&mut p, "Main", c);
+ let out = export(&p, cid, &ExportOptions { format: TimelineFormat::Fcp7Xml, ..Default::default() }, &HashMap::new()).unwrap();
+ let (q, r) = import_doc(&out.bytes, "Main.xml", &mut probe);
+ let main = r.comps.iter().copied().find(|c| q.item(*c).unwrap().name == "Main").expect("Main");
+ let pos = layer(q.comp(main).unwrap(), "clip").transform().unwrap().get("position").unwrap();
+ assert_eq!(pos.keys.len(), 2, "the muted key was exported");
+ assert_eq!(pos.keys[0].value.as_vec3()[0], 100.0);
+ assert_eq!(pos.keys[1].value.as_vec3()[0], 300.0);
+}
+
+/// #1894: a muted non-uniform scale key must not force a uniform layer to pre-render; only the
+/// active keys matter, and the static value when every key is muted.
+#[test]
+fn muted_non_uniform_scale_does_not_force_prerendering() {
+ let mut p = Project::default();
+ let a = footage_item(&mut p, "/media/a.mov");
+ let mut c = Comp::new(W, H, FrameRate::new(25, 1), t(2.0));
+ let mut l = effectcraft_project::build::layer(&mut p, &c, "clip", LayerSource::Footage { item: a }, (W, H), None);
+ {
+ let scale = l.transform_mut().unwrap().get_mut("scale").unwrap();
+ scale.keys = vec![Keyframe::new(t(0.0), Value::Vec3([100.0, 100.0, 100.0])), Keyframe::new(t(1.0), Value::Vec3([50.0, 200.0, 100.0]))];
+ scale.keys[1].muted = true;
+ }
+ let lid = l.id;
+ c.layers.push(l);
+ let cid = comp_item(&mut p, "Main", c);
+ assert_eq!(prerender_reason(&p, cid, lid, &ExportOptions::default()), None);
+ // With every key muted the static value drives evaluation, so a non-uniform static scale
+ // still takes the flattened path.
+ let scale = p.comp_mut(cid).unwrap().layer_mut(lid).unwrap().transform_mut().unwrap().get_mut("scale").unwrap();
+ scale.keys[0].muted = true;
+ scale.value = Value::Vec3([50.0, 200.0, 100.0]);
+ assert_eq!(prerender_reason(&p, cid, lid, &ExportOptions::default()).as_deref(), Some("non-uniform scale"));
+}
+
#[test]
fn export_without_prerender_leaves_text_out() {
let (p, cid) = ae_project();
diff --git a/crates/keyframe/src/lib.rs b/crates/keyframe/src/lib.rs
index f0dd4849c..abf929fe9 100644
--- a/crates/keyframe/src/lib.rs
+++ b/crates/keyframe/src/lib.rs
@@ -15,6 +15,7 @@ pub mod value;
use effectcraft_time::{TICKS_PER_SECOND, Tick};
use serde::{Deserialize, Serialize};
+use std::borrow::Borrow;
pub use text_doc::{BaselineOption, CharStyle, Composer, Direction, FigureStyle, FigureWidth, Kerning, LineJoin, OpenType, ParaStyle, StyleRun};
pub use value::{FeatherPoint, Gradient, Justify, ShapePath, TextDoc, Value};
@@ -89,12 +90,19 @@ pub struct Keyframe {
/// Keyframe color label: index into the label list (0 = None).
#[serde(default, skip_serializing_if = "is_zero")]
pub label: u8,
+ /// Muted keys stay in the list (and the UI) but evaluation skips them.
+ #[serde(default, skip_serializing_if = "is_false")]
+ pub muted: bool,
}
fn is_zero(v: &u8) -> bool {
*v == 0
}
+fn is_false(v: &bool) -> bool {
+ !*v
+}
+
fn yes() -> bool {
true
}
@@ -116,6 +124,7 @@ impl Keyframe {
spatial_continuous: false,
roving: false,
label: 0,
+ muted: false,
}
}
pub fn hold(mut self) -> Keyframe {
@@ -320,16 +329,16 @@ fn v3(v: &Value) -> [f64; 3] {
/// tangent is a sixth of the way from the previous key to the next, the in tangent its mirror, and
/// key times play no part. An end key uses its one neighbour, so the path leaves the first key
/// and enters the last one toward the neighbouring key instead of with no tangent.
-fn auto_spatial(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
+fn auto_spatial<K: Borrow<Keyframe>>(keys: &[K], i: usize) -> ([f64; 3], [f64; 3]) {
if i >= keys.len() || keys.len() < 2 {
return ([0.0; 3], [0.0; 3]);
}
- let a = v3(&keys[i.saturating_sub(1)].value);
- let c = v3(&keys[(i + 1).min(keys.len() - 1)].value);
+ let a = v3(&keys[i.saturating_sub(1)].borrow().value);
+ let c = v3(&keys[(i + 1).min(keys.len() - 1)].borrow().value);
let tout = [(c[0] - a[0]) / 6.0, (c[1] - a[1]) / 6.0, (c[2] - a[2]) / 6.0];
// A side facing a key at the same position gets no tangent, so the segment between two
// identical keys has zero length and the layer holds still (#1675).
- let p = v3(&keys[i].value);
+ let p = v3(&keys[i].borrow().value);
let tin = if i > 0 && a == p { [0.0; 3] } else { [-tout[0], -tout[1], -tout[2]] };
let tout = if i + 1 < keys.len() && c == p { [0.0; 3] } else { tout };
(tin, tout)
@@ -337,7 +346,12 @@ fn auto_spatial(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
/// Effective spatial tangents of key `i` (auto or stored).
pub fn spatial_tangents(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
- let Some(key) = keys.get(i) else { return ([0.0; 3], [0.0; 3]) };
+ tangents_of(keys, i)
+}
+
+/// [`spatial_tangents`] over stored keys or a filtered list of them (see [`evaluate`]).
+fn tangents_of<K: Borrow<Keyframe>>(keys: &[K], i: usize) -> ([f64; 3], [f64; 3]) {
+ let Some(key) = keys.get(i).map(Borrow::borrow) else { return ([0.0; 3], [0.0; 3]) };
if key.spatial_auto { auto_spatial(keys, i) } else { (key.spatial_in, key.spatial_out) }
}
@@ -373,18 +387,18 @@ pub fn spatial_handles(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
}
/// Effective temporal ease of key `i` for dimension `d` (auto-Bezier keys get the neighbour slope).
-fn effective_ease(keys: &[Keyframe], i: usize, d: usize, spatial: bool, out: bool) -> Ease {
- let k = &keys[i];
+fn effective_ease<K: Borrow<Keyframe>>(keys: &[K], i: usize, d: usize, spatial: bool, out: bool) -> Ease {
+ let k = keys[i].borrow();
let list = if out { &k.out_ease } else { &k.in_ease };
if k.auto_bezier && i > 0 && i + 1 < keys.len() {
- let dt = secs(keys[i + 1].time) - secs(keys[i - 1].time);
+ let dt = secs(keys[i + 1].borrow().time) - secs(keys[i - 1].borrow().time);
let slope = if spatial {
- let a = v3(&keys[i - 1].value);
- let c = v3(&keys[i + 1].value);
+ let a = v3(&keys[i - 1].borrow().value);
+ let c = v3(&keys[i + 1].borrow().value);
((c[0] - a[0]).powi(2) + (c[1] - a[1]).powi(2) + (c[2] - a[2]).powi(2)).sqrt() / dt.max(1e-12)
} else {
- let a = keys[i - 1].value.components();
- let c = keys[i + 1].value.components();
+ let a = keys[i - 1].borrow().value.components();
+ let c = keys[i + 1].borrow().value.components();
(c.get(d).unwrap_or(&0.0) - a.get(d).unwrap_or(&0.0)) / dt.max(1e-12)
};
return Ease { speed: slope, influence: 1.0 / 6.0 };
@@ -508,23 +522,39 @@ pub fn time_reverse(keys: &mut [Keyframe]) {
}
/// Evaluate a keyframed property at `t`. `spatial` selects motion-path semantics for 2D/3D values.
+/// Muted keys are skipped, so the active neighbours interpolate as if they were not there; `None`
+/// means every key is muted (the property's static value applies).
pub fn evaluate(keys: &[Keyframe], t: Tick, spatial: bool) -> Option<Value> {
- let first = keys.first()?;
+ if !keys.iter().any(|k| k.muted) {
+ return evaluate_active(keys, t, spatial);
+ }
+ // Muting is rare: skip the muted keys by reference rather than copying every key and value.
+ let active: Vec<&Keyframe> = keys.iter().filter(|k| !k.muted).collect();
+ evaluate_active(&active, t, spatial)
+}
+
+fn evaluate_active<K: Borrow<Keyframe>>(keys: &[K], t: Tick, spatial: bool) -> Option<Value> {
+ let first = keys.first()?.borrow();
if keys.len() == 1 || t <= first.time {
return Some(first.value.clone());
}
- let last = keys.last()?;
+ let last = keys.last()?.borrow();
if t >= last.time {
return Some(last.value.clone());
}
- let i = keys.partition_point(|k| k.time <= t) - 1;
- Some(segment_value(keys, i, t, spatial))
+ let i = keys.partition_point(|k| k.borrow().time <= t) - 1;
+ Some(segment_value_of(keys, i, t, spatial))
}
/// Value inside segment `i` → `i+1` at time `t`.
pub fn segment_value(keys: &[Keyframe], i: usize, t: Tick, spatial: bool) -> Value {
- let a = &keys[i];
- let b = &keys[i + 1];
+ segment_value_of(keys, i, t, spatial)
+}
+
+/// [`segment_value`] over stored keys or a filtered list of them (see [`evaluate`]).
+fn segment_value_of<K: Borrow<Keyframe>>(keys: &[K], i: usize, t: Tick, spatial: bool) -> Value {
+ let a = keys[i].borrow();
+ let b = keys[i + 1].borrow();
if a.out_interp == Interp::Hold || !a.value.interpolates() {
return a.value.clone();
}
@@ -539,8 +569,8 @@ pub fn segment_value(keys: &[Keyframe], i: usize, t: Tick, spatial: bool) -> Val
if is_spatial {
let p0 = v3(&a.value);
let p3 = v3(&b.value);
- let (_, out_t) = spatial_tangents(keys, i);
- let (in_t, _) = spatial_tangents(keys, i + 1);
+ let (_, out_t) = tangents_of(keys, i);
+ let (in_t, _) = tangents_of(keys, i + 1);
let seg = SpatialSeg::new([p0, [p0[0] + out_t[0], p0[1] + out_t[1], p0[2] + out_t[2]], [p3[0] + in_t[0], p3[1] + in_t[1], p3[2] + in_t[2]], p3]);
let len = seg.length();
let f = if lin_out && lin_in || len <= 1e-12 {
@@ -617,6 +647,7 @@ pub fn set_key(keys: &mut Vec<Keyframe>, key: Keyframe) -> usize {
k.spatial_continuous = old.spatial_continuous;
k.roving = old.roving;
k.label = old.label;
+ k.muted = old.muted;
keys[i] = k;
i
}
diff --git a/crates/keyframe/src/tests.rs b/crates/keyframe/src/tests.rs
index 0a31cfc19..18e9b37be 100644
--- a/crates/keyframe/src/tests.rs
+++ b/crates/keyframe/src/tests.rs
@@ -395,3 +395,60 @@ proptest::proptest! {
proptest::prop_assert!((-1e-9..=10.0 + 1e-9).contains(&v));
}
}
+
+#[test]
+fn muted_keys_are_skipped_by_evaluation() {
+ let mut keys =
+ vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), Keyframe::new(s(1.0), Value::Scalar(100.0)), Keyframe::new(s(2.0), Value::Scalar(300.0))];
+ let at = |keys: &[Keyframe], t: f64| evaluate(keys, s(t), false).unwrap().as_f64();
+ assert!((at(&keys, 0.5) - 50.0).abs() < 1e-9);
+ assert!((at(&keys, 1.5) - 200.0).abs() < 1e-9);
+ keys[1].muted = true;
+ // The 0 → 300 segment now spans 0 → 2 s.
+ assert!((at(&keys, 0.5) - 75.0).abs() < 1e-9);
+ assert!((at(&keys, 1.0) - 150.0).abs() < 1e-9);
+ assert!((at(&keys, 1.5) - 225.0).abs() < 1e-9);
+ for k in &mut keys {
+ k.muted = true;
+ }
+ assert!(evaluate(&keys, s(0.5), false).is_none());
+}
+
+#[test]
+fn muted_key_automation_uses_the_active_neighbours() {
+ let mut keys = vec![
+ Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0])),
+ Keyframe::new(s(1.0), Value::Vec2([50.0, 100.0])),
+ Keyframe::new(s(2.0), Value::Vec2([100.0, 0.0])),
+ ];
+ for k in &mut keys {
+ k.auto_bezier = true;
+ k.in_interp = Interp::Bezier;
+ k.out_interp = Interp::Bezier;
+ }
+ let all = keys.clone();
+ let mut active = keys.clone();
+ active.remove(1);
+ keys[1].muted = true;
+ for t in [0.0, 0.25, 0.5, 1.0, 1.5, 1.75, 2.0] {
+ assert_eq!(evaluate(&keys, s(t), true), evaluate(&active, s(t), true), "{t}");
+ }
+ // The muted auto-Bezier key no longer bulges the motion path.
+ assert_ne!(evaluate(&keys, s(0.5), true), evaluate(&all, s(0.5), true));
+}
+
+#[test]
+fn mute_round_trips_and_survives_value_replacement() {
+ let mut k = Keyframe::new(s(0.0), Value::Scalar(1.0));
+ let json = serde_json::to_value(&k).unwrap();
+ assert!(json.get("muted").is_none(), "false is the default and is skipped");
+ k.muted = true;
+ let json = serde_json::to_value(&k).unwrap();
+ assert_eq!(json["muted"], serde_json::json!(true));
+ let back: Keyframe = serde_json::from_value(json).unwrap();
+ assert!(back.muted);
+ let mut keys = vec![k];
+ set_key(&mut keys, Keyframe::new(s(0.0), Value::Scalar(2.0)));
+ assert!(keys[0].muted);
+ assert_eq!(keys[0].value, Value::Scalar(2.0));
+}
diff --git a/crates/lottie/src/anim.rs b/crates/lottie/src/anim.rs
index e3264e3b7..4925460a9 100644
--- a/crates/lottie/src/anim.rs
+++ b/crates/lottie/src/anim.rs
@@ -73,9 +73,22 @@ fn is_spatial(p: &Property) -> bool {
}
/// Export a property as a Lottie animatable property (`{a, k}` plus `x` for expressions).
-/// `label` names the property in warnings.
+/// `label` names the property in warnings. Muted keys are omitted: Lottie has no mute state, and
+/// the remaining keys carry the animation the renderer shows.
pub(crate) fn export_prop(ex: &mut Ex, p: &Property, conv: &dyn Fn(&Value) -> Json, label: &str) -> Json {
- let mut out = if p.keys.is_empty() { json!({"a": 0, "k": conv(&p.value)}) } else { json!({"a": 1, "k": export_keys(ex, p, conv)}) };
+ let muted = p.keys.iter().any(|k| k.muted);
+ if muted {
+ ex.warn(format!("{label}: muted keyframes are not exported"));
+ }
+ let active: Vec<Keyframe>;
+ let keys: &[Keyframe] = if muted {
+ active = p.keys.iter().filter(|k| !k.muted).cloned().collect();
+ &active
+ } else {
+ &p.keys
+ };
+ let mut out =
+ if keys.is_empty() { json!({"a": 0, "k": conv(&p.value)}) } else { json!({"a": 1, "k": export_keys(ex, keys, is_spatial(p), p.hold_only, conv)}) };
if let Some(e) = p.expr.as_ref().filter(|e| e.enabled && !e.text.trim().is_empty()) {
if ex.include_expressions {
out["x"] = json!(e.text);
@@ -86,20 +99,18 @@ pub(crate) fn export_prop(ex: &mut Ex, p: &Property, conv: &dyn Fn(&Value) -> Js
out
}
-fn export_keys(ex: &Ex, p: &Property, conv: &dyn Fn(&Value) -> Json) -> Vec<Json> {
- let keys = &p.keys;
- let spatial = is_spatial(p);
+fn export_keys(ex: &Ex, keys: &[Keyframe], spatial: bool, hold_only: bool, conv: &dyn Fn(&Value) -> Json) -> Vec<Json> {
let mut out = Vec::with_capacity(keys.len());
for (i, k) in keys.iter().enumerate() {
let mut o = json!({"t": r6(ex.tb.frame(k.time)), "s": wrap(conv(&k.value))});
if i + 1 == keys.len() {
- if k.out_interp == Interp::Hold || p.hold_only {
+ if k.out_interp == Interp::Hold || hold_only {
o["h"] = json!(1);
}
out.push(o);
continue;
}
- if k.out_interp == Interp::Hold || p.hold_only || !k.value.interpolates() {
+ if k.out_interp == Interp::Hold || hold_only || !k.value.interpolates() {
o["h"] = json!(1);
out.push(o);
continue;
diff --git a/crates/lottie/src/tests.rs b/crates/lottie/src/tests.rs
index 31f3a70bb..203f04c04 100644
--- a/crates/lottie/src/tests.rs
+++ b/crates/lottie/src/tests.rs
@@ -878,3 +878,21 @@ fn external_images_are_local_or_skipped() {
assert_eq!(std::path::Path::new(&paths[0]), base.join("images").join("a.png"));
assert_eq!(r.warnings.iter().filter(|w| w.contains("is not imported")).count(), assets.len() - 1, "{:?}", r.warnings);
}
+
+#[test]
+fn muted_keys_are_omitted_from_the_export() {
+ let (mut p, cid) = setup();
+ let mut l = solid_layer(&mut p, cid, [0.0, 1.0, 0.0], 20, 20);
+ let mut b = Keyframe::new(s(1.0), Value::Scalar(100.0));
+ b.muted = true;
+ l.props.prop_mut("transform/opacity").unwrap().keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), b, Keyframe::new(s(2.0), Value::Scalar(300.0))];
+ push(&mut p, cid, l);
+ let (q, nc, warnings, json) = roundtrip(&p, cid, &ExportOptions::default());
+ assert!(warnings.iter().any(|w| w.contains("muted keyframes")), "{warnings:?}");
+ // Lottie has no mute state: the two active keys carry the 0 → 300 animation.
+ assert_eq!(json["layers"][0]["ks"]["o"]["k"].as_array().unwrap().len(), 2);
+ assert_eq!(json["layers"][0]["ks"]["o"]["k"][1]["s"], json!([300.0]));
+ let opacity_at = |p: &Project, cid: ItemId, t: f64| p.comp(cid).unwrap().layers[0].props.prop("transform/opacity").unwrap().value_at(s(t)).as_f64();
+ assert!((opacity_at(&p, cid, 1.0) - 150.0).abs() < 1e-6);
+ assert!((opacity_at(&q, nc, 1.0) - 150.0).abs() < 1e-6);
+}
diff --git a/crates/ui-egui/src/i18n.rs b/crates/ui-egui/src/i18n.rs
index 254eec49c..8712ab74f 100644
--- a/crates/ui-egui/src/i18n.rs
+++ b/crates/ui-egui/src/i18n.rs
@@ -836,6 +836,7 @@ const SIMPLIFIED_CHINESE: &[(&str, &str, &str)] = &[
("layer.applyTextPreset", "Drop In Lines", "行落下"),
("anim.addKeyframe", "Add Keyframe", "添加关键帧"),
("keys.toggleHold", "Toggle Hold Keyframe", "切换定格关键帧"),
+ ("keys.setMuted", "Mute Keyframes", "静音关键帧"),
("keys.interpolation", "Keyframe Interpolation...", "关键帧插值..."),
("keys.velocity", "Keyframe Velocity...", "关键帧速度..."),
("", "Keyframe Assistant", "关键帧辅助"),
@@ -1472,6 +1473,7 @@ const TRADITIONAL_CHINESE: &[(&str, &str, &str)] = &[
("layer.applyTextPreset", "Drop In Lines", "行落下"),
("anim.addKeyframe", "Add Keyframe", "新增關鍵影格"),
("keys.toggleHold", "Toggle Hold Keyframe", "切換定格關鍵影格"),
+ ("keys.setMuted", "Mute Keyframes", "靜音關鍵影格"),
("keys.interpolation", "Keyframe Interpolation...", "關鍵影格插補..."),
("keys.velocity", "Keyframe Velocity...", "關鍵影格速度..."),
("", "Keyframe Assistant", "關鍵影格輔助"),
@@ -2105,6 +2107,7 @@ const JAPANESE: &[(&str, &str, &str)] = &[
("layer.applyTextPreset", "Drop In Lines", "行をドロップイン"),
("anim.addKeyframe", "Add Keyframe", "キーフレームを追加"),
("keys.toggleHold", "Toggle Hold Keyframe", "停止したキーフレームの切り替え"),
+ ("keys.setMuted", "Mute Keyframes", "キーフレームをミュート"),
("keys.interpolation", "Keyframe Interpolation...", "キーフレーム補間法..."),
("keys.velocity", "Keyframe Velocity...", "キーフレーム速度..."),
("", "Keyframe Assistant", "キーフレーム補助"),
@@ -2741,6 +2744,7 @@ const UKRAINIAN: &[(&str, &str, &str)] = &[
("layer.applyTextPreset", "Drop In Lines", "Поява рядків згори"),
("anim.addKeyframe", "Add Keyframe", "Додати ключовий кадр"),
("keys.toggleHold", "Toggle Hold Keyframe", "Перемкнути утримання ключового кадру"),
+ ("keys.setMuted", "Mute Keyframes", "Заглушити ключові кадри"),
("keys.interpolation", "Keyframe Interpolation...", "Інтерполяція ключових кадрів..."),
("keys.velocity", "Keyframe Velocity...", "Швидкість ключових кадрів..."),
("", "Keyframe Assistant", "Помічник ключових кадрів"),
@@ -3378,6 +3382,7 @@ const SPANISH: &[(&str, &str, &str)] = &[
("layer.applyTextPreset", "Drop In Lines", "Entrada de líneas cayendo"),
("anim.addKeyframe", "Add Keyframe", "Añadir fotograma clave"),
("keys.toggleHold", "Toggle Hold Keyframe", "Conmutar mantener fotograma clave"),
+ ("keys.setMuted", "Mute Keyframes", "Silenciar fotogramas clave"),
("keys.interpolation", "Keyframe Interpolation...", "Interpolación de fotogramas clave..."),
("keys.velocity", "Keyframe Velocity...", "Velocidad de fotogramas clave..."),
("", "Keyframe Assistant", "Asistente de fotogramas clave"),
@@ -4013,6 +4018,7 @@ const PORTUGUESE: &[(&str, &str, &str)] = &[
("layer.applyTextPreset", "Drop In Lines", "Entrar com queda de linhas"),
("anim.addKeyframe", "Add Keyframe", "Adicionar quadro-chave"),
("keys.toggleHold", "Toggle Hold Keyframe", "Alternar quadro-chave de retenção"),
+ ("keys.setMuted", "Mute Keyframes", "Silenciar quadros-chave"),
("keys.interpolation", "Keyframe Interpolation...", "Interpolação de quadro-chave..."),
("keys.velocity", "Keyframe Velocity...", "Velocidade do quadro-chave..."),
("", "Keyframe Assistant", "Assistente de quadro-chave"),
@@ -4655,6 +4661,7 @@ const RUSSIAN: &[(&str, &str, &str)] = &[
("layer.applyTextPreset", "Drop In Lines", "Появление строк сверху"),
("anim.addKeyframe", "Add Keyframe", "Добавить ключевой кадр"),
("keys.toggleHold", "Toggle Hold Keyframe", "Переключить фиксацию ключевого кадра"),
+ ("keys.setMuted", "Mute Keyframes", "Отключить ключевые кадры"),
("keys.interpolation", "Keyframe Interpolation...", "Интерполяция ключевых кадров..."),
("keys.velocity", "Keyframe Velocity...", "Скорость ключевых кадров..."),
("", "Keyframe Assistant", "Помощник по ключевым кадрам"),
@@ -5290,6 +5297,7 @@ const FRENCH: &[(&str, &str, &str)] = &[
("layer.applyTextPreset", "Drop In Lines", "Chute des lignes depuis le haut"),
("anim.addKeyframe", "Add Keyframe", "Ajouter une image clé"),
("keys.toggleHold", "Toggle Hold Keyframe", "Activer/Désactiver l'image clé figée"),
+ ("keys.setMuted", "Mute Keyframes", "Désactiver les images clés"),
("keys.interpolation", "Keyframe Interpolation...", "Interpolation des images clés..."),
("keys.velocity", "Keyframe Velocity...", "Vitesse des images clés..."),
("", "Keyframe Assistant", "Assistant d'images clés"),
@@ -5925,6 +5933,7 @@ const GERMAN: &[(&str, &str, &str)] = &[
("layer.applyTextPreset", "Drop In Lines", "Zeilen fallen ein"),
("anim.addKeyframe", "Add Keyframe", "Keyframe hinzufügen"),
("keys.toggleHold", "Toggle Hold Keyframe", "Halte-Keyframe umschalten"),
+ ("keys.setMuted", "Mute Keyframes", "Keyframes stummschalten"),
("keys.interpolation", "Keyframe Interpolation...", "Keyframe-Interpolation..."),
("keys.velocity", "Keyframe Velocity...", "Keyframe-Geschwindigkeit..."),
("", "Keyframe Assistant", "Keyframe-Assistent"),
@@ -6561,6 +6570,7 @@ const CZECH: &[(&str, &str, &str)] = &[
("layer.applyTextPreset", "Drop In Lines", "Spustit řádky shora"),
("anim.addKeyframe", "Add Keyframe", "Přidat klíčový snímek"),
("keys.toggleHold", "Toggle Hold Keyframe", "Přepnout podržení klíčového snímku"),
+ ("keys.setMuted", "Mute Keyframes", "Ztlumit klíčové snímky"),
("keys.interpolation", "Keyframe Interpolation...", "Interpolace klíčových snímků..."),
("keys.velocity", "Keyframe Velocity...", "Rychlost klíčového snímku..."),
("", "Keyframe Assistant", "Pomocník klíčových snímků"),
diff --git a/crates/ui-egui/src/panels/graph.rs b/crates/ui-egui/src/panels/graph.rs
index 24df22616..51b288cc6 100644
--- a/crates/ui-egui/src/panels/graph.rs
+++ b/crates/ui-egui/src/panels/graph.rs
@@ -48,9 +48,21 @@ struct KeyPt {
t: f64,
v: f64,
sel: bool,
+ muted: bool,
handles: Vec<Handle>,
}
+/// A graph key's fill and edge colours: muted keys stay visible and selectable, dimmed.
+fn key_colors(t: &Tokens, edge: Color32, k: &KeyPt) -> (Color32, Color32) {
+ let fill = match (k.muted, k.sel) {
+ (true, true) => t.keyframe_selected.gamma_multiply(0.5),
+ (true, false) => Color32::from_gray(0x70),
+ (false, true) => t.keyframe_selected,
+ (false, false) => Color32::from_gray(0xe0),
+ };
+ (fill, if k.muted { edge.gamma_multiply(0.4) } else { edge })
+}
+
struct Curve<'a> {
layer: &'a Layer,
prop: &'a Property,
@@ -153,7 +165,7 @@ fn curves<'a>(app: &EffectcraftApp, comp: &'a Comp, ectx: &EvalCtx, tm: TMap, pl
let dt = e.influence * dur * if out_side { 1.0 } else { -1.0 };
let (hv, show) = if speed { (e.speed.abs(), true) } else { (k.value.components().get(d).copied().unwrap_or(0.0) + e.speed * dt, !spatial) };
let bezier = if out_side { k.out_interp == Interp::Bezier } else { k.in_interp == Interp::Bezier };
- if ks && show && (bezier || speed) {
+ if ks && !k.muted && show && (bezier || speed) {
handles.push(Handle { out: out_side, t: kt + dt, v: hv, speed: e.speed, dur });
}
}
@@ -162,7 +174,7 @@ fn curves<'a>(app: &EffectcraftApp, comp: &'a Comp, ectx: &EvalCtx, tm: TMap, pl
} else {
k.value.components().get(d).copied().unwrap_or(0.0)
};
- keys.push(KeyPt { idx: i, time: k.time, t: kt, v, sel: ks, handles });
+ keys.push(KeyPt { idx: i, time: k.time, t: kt, v, sel: ks, muted: k.muted, handles });
}
out.push(Curve { layer: l, prop: pr, dim: d, color, pts, keys, editable: !spatial });
}
@@ -522,9 +534,9 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
}
}
// The key itself.
- let col = if k.sel { t.keyframe_selected } else { Color32::from_gray(0xe0) };
+ let (col, edge) = key_colors(&t, c.color, k);
pc.rect_filled(Rect::from_center_size(kp, vec2(7.0, 7.0)), 0.0, col);
- pc.rect_stroke(Rect::from_center_size(kp, vec2(7.0, 7.0)), 0.0, Stroke::new(1.0, c.color), StrokeKind::Outside);
+ pc.rect_stroke(Rect::from_center_size(kp, vec2(7.0, 7.0)), 0.0, Stroke::new(1.0, edge), StrokeKind::Outside);
let kr = Rect::from_center_size(kp, vec2(11.0, 11.0));
let kresp = ui.interact(kr, egui::Id::unique(("gkey", uid, d, k.idx)), Sense::click_and_drag());
app.auto.add(&format!("timeline.graph.key.{uid}.{d}.{}", k.idx), kr, &c.prop.name);
diff --git a/crates/ui-egui/src/panels/timeline.rs b/crates/ui-egui/src/panels/timeline.rs
index 98bc4d8d2..81e39ccaf 100644
--- a/crates/ui-egui/src/panels/timeline.rs
+++ b/crates/ui-egui/src/panels/timeline.rs
@@ -4111,6 +4111,7 @@ fn key_context_menu(app: &mut EffectcraftApp, g: &mut Rw, rc: &RowCtx<'_>, prop:
("Keyframe Interpolation…", "keys.interpolation", json!({})),
("Keyframe Velocity…", "keys.velocity", json!({})),
("Toggle Hold Keyframe", "keys.toggleHold", json!({})),
+ (if k.muted { "Unmute Keyframes" } else { "Mute Keyframes" }, "keys.setMuted", json!({"muted": !k.muted})),
("Rove Across Time", "keys.interpolation", json!({"roving": !k.roving})),
("-", "", json!({})),
("Easy Ease", "keys.easyEase", json!({})),
@@ -4203,6 +4204,8 @@ fn key_paint(g: &Rw, rc: &RowCtx<'_>, k: &effectcraft_engine::keyframe::Keyframe
None if ks => t.keyframe_selected,
None => t.keyframe,
};
+ // Muted keys stay visible and editable but no longer drive the value.
+ let kcol = if k.muted { kcol.gamma_multiply(0.35) } else { kcol };
if k.roving {
// Roving keys: a small dot (their time follows their neighbours).
gp.circle_filled(c, 2.5, kcol);
diff --git a/crates/ui-egui/src/panels/viewer_overlays.rs b/crates/ui-egui/src/panels/viewer_overlays.rs
index ef4549db6..05884abce 100644
--- a/crates/ui-egui/src/panels/viewer_overlays.rs
+++ b/crates/ui-egui/src/panels/viewer_overlays.rs
@@ -360,31 +360,36 @@ pub(crate) fn motion_path(
}
let v = k.value.as_vec3();
let s = to_scr(v);
- // Auto-Bezier keys show handles on a side the path leaves straight too (a two-key path's
- // ends), to drag it into a curve; Linear keys (no tangents) show none.
- let (tin, tout) = if k.spatial_auto {
- effectcraft_engine::keyframe::spatial_handles(&pos.keys, i)
- } else {
- effectcraft_engine::keyframe::spatial_tangents(&pos.keys, i)
- };
- for (out, tg) in [(false, tin), (true, tout)] {
- let has = (out && i + 1 < pos.keys.len()) || (!out && i > 0);
- if !has || (tg[0] == 0.0 && tg[1] == 0.0) {
- continue;
+ let selected = sel.contains(&KeyRef { layer: l.id, prop: pos.uid, time: k.time });
+ // A muted position key is off the motion path: no tangents, and a dimmed point.
+ let kc = if k.muted { col.gamma_multiply(if selected { 0.55 } else { 0.35 }) } else { col };
+ if !k.muted {
+ // Auto-Bezier keys show handles on a side the path leaves straight too (a two-key path's
+ // ends), to drag it into a curve; Linear keys (no tangents) show none.
+ let (tin, tout) = if k.spatial_auto {
+ effectcraft_engine::keyframe::spatial_handles(&pos.keys, i)
+ } else {
+ effectcraft_engine::keyframe::spatial_tangents(&pos.keys, i)
+ };
+ for (out, tg) in [(false, tin), (true, tout)] {
+ let has = (out && i + 1 < pos.keys.len()) || (!out && i > 0);
+ if !has || (tg[0] == 0.0 && tg[1] == 0.0) {
+ continue;
+ }
+ let h = to_scr([v[0] + tg[0], v[1] + tg[1], v[2] + tg[2]]);
+ painter.line_segment([s, h], Stroke::new(1.0, kc));
+ painter.circle_filled(h, 3.0, kc);
+ let side = if out { "out" } else { "in" };
+ app.auto.add(&format!("viewer.motionPath.{}.{i}.{side}", l.id.0), Rect::from_center_size(h, vec2(8.0, 8.0)), "Spatial tangent");
+ hits.push(KeyHit { layer: l.id, prop: pos.uid, time: k.time, pos: h, tangent: Some(out), value: v, p2c });
}
- let h = to_scr([v[0] + tg[0], v[1] + tg[1], v[2] + tg[2]]);
- painter.line_segment([s, h], Stroke::new(1.0, col));
- painter.circle_filled(h, 3.0, col);
- let side = if out { "out" } else { "in" };
- app.auto.add(&format!("viewer.motionPath.{}.{i}.{side}", l.id.0), Rect::from_center_size(h, vec2(8.0, 8.0)), "Spatial tangent");
- hits.push(KeyHit { layer: l.id, prop: pos.uid, time: k.time, pos: h, tangent: Some(out), value: v, p2c });
}
let r = Rect::from_center_size(s, vec2(7.0, 7.0));
- if sel.contains(&KeyRef { layer: l.id, prop: pos.uid, time: k.time }) {
- painter.rect_filled(r, 0.0, col);
+ if selected {
+ painter.rect_filled(r, 0.0, kc);
} else {
painter.rect_filled(r, 0.0, Color32::from_black_alpha(140));
- painter.rect_stroke(r, 0.0, Stroke::new(1.0, col), StrokeKind::Inside);
+ painter.rect_stroke(r, 0.0, Stroke::new(1.0, kc), StrokeKind::Inside);
}
app.auto.add(&format!("viewer.motionPath.{}.{i}", l.id.0), r.expand(2.0), "Position keyframe");
hits.push(KeyHit { layer: l.id, prop: pos.uid, time: k.time, pos: s, tangent: None, value: v, p2c });