mirror of
https://github.com/storytold/effectcraft.git
synced 2026-10-25 02:27:00 -06:00
Brandon Thomas
2cf28e5e24
Keep footage dropped on the timeline at its full length (#795) # Conflicts: # crates/engine/src/tests_timeline.rs
966 lines
55 KiB
Rust
966 lines
55 KiB
Rust
//! Timeline depth: keyframe clipboard, easing, velocity/interpolation, roving, nudging, graph
|
||
//! editor key edits, time remapping/stretch/reverse/freeze, separate dimensions, pick-whips,
|
||
//! expressions and masks (pen tool). Every command is checked with undo/redo.
|
||
|
||
use effectcraft_keyframe::{Interp, Value as KV};
|
||
use effectcraft_project::Property;
|
||
use serde_json::{Value, json};
|
||
|
||
use crate::Session;
|
||
|
||
/// A 4 s, 30 fps comp with one solid; returns (session, layer id).
|
||
pub(crate) fn setup() -> (Session, u64) {
|
||
let mut s = Session::default();
|
||
s.execute("comp.new", json!({"name": "T", "width": 400, "height": 300, "frameRate": 30, "duration": 4})).unwrap();
|
||
let r = s.execute("layer.newSolid", json!({"color": "#ffffff", "width": 100, "height": 100})).unwrap();
|
||
(s, r["layer"].as_u64().unwrap())
|
||
}
|
||
|
||
pub(crate) fn prop(s: &Session, layer: u64, path: &str) -> Property {
|
||
s.active_comp().unwrap().layer(effectcraft_project::LayerId(layer)).unwrap().props.prop(path).unwrap().clone()
|
||
}
|
||
|
||
/// Key `path` at the given (time, value) pairs.
|
||
pub(crate) fn animate(s: &mut Session, layer: u64, path: &str, keys: &[(f64, Value)]) {
|
||
for (t, v) in keys {
|
||
s.execute("prop.addKey", json!({"layer": layer, "path": path, "time": t, "value": v})).unwrap();
|
||
}
|
||
}
|
||
|
||
fn select_prop_keys(s: &mut Session, layer: u64, path: &str) {
|
||
s.execute("prop.select", json!({"layer": layer, "path": path})).unwrap();
|
||
}
|
||
|
||
fn undo_redo_roundtrip(s: &mut Session, check_after: impl Fn(&Session), check_before: impl Fn(&Session)) {
|
||
check_after(s);
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
check_before(s);
|
||
s.execute("edit.redo", json!({})).unwrap();
|
||
check_after(s);
|
||
}
|
||
|
||
#[test]
|
||
fn easy_ease_family_sets_influence_and_zero_speed() {
|
||
let (mut s, l) = setup();
|
||
animate(&mut s, l, "transform/opacity", &[(0.0, json!(0)), (1.0, json!(100)), (2.0, json!(0))]);
|
||
select_prop_keys(&mut s, l, "transform/opacity");
|
||
s.execute("keys.easyEase", json!({})).unwrap();
|
||
undo_redo_roundtrip(
|
||
&mut s,
|
||
|s| {
|
||
let p = prop(s, l, "transform/opacity");
|
||
assert!(p.keys.iter().all(|k| k.in_interp == Interp::Bezier && k.out_interp == Interp::Bezier));
|
||
assert!((p.keys[1].in_ease[0].influence - 1.0 / 3.0).abs() < 1e-9 && p.keys[1].in_ease[0].speed == 0.0);
|
||
},
|
||
|s| assert!(prop(s, l, "transform/opacity").keys.iter().all(|k| k.in_interp == Interp::Linear)),
|
||
);
|
||
// Easy Ease In only touches the incoming side; Out only the outgoing side.
|
||
s.execute("keys.interpolation", json!({"interpolation": "linear"})).unwrap();
|
||
s.execute("keys.easyEaseIn", json!({})).unwrap();
|
||
let p = prop(&s, l, "transform/opacity");
|
||
assert!(p.keys.iter().all(|k| k.in_interp == Interp::Bezier && k.out_interp == Interp::Linear));
|
||
s.execute("keys.interpolation", json!({"interpolation": "linear"})).unwrap();
|
||
s.execute("keys.easyEaseOut", json!({})).unwrap();
|
||
let p = prop(&s, l, "transform/opacity");
|
||
assert!(p.keys.iter().all(|k| k.in_interp == Interp::Linear && k.out_interp == Interp::Bezier));
|
||
// Eased motion is slow near the key.
|
||
s.execute("keys.easyEase", json!({})).unwrap();
|
||
let p = prop(&s, l, "transform/opacity");
|
||
let early = p.value_at(effectcraft_time::Tick::from_seconds_f64(0.1)).as_f64();
|
||
assert!(early < 5.0, "{early}");
|
||
}
|
||
|
||
#[test]
|
||
fn keyframe_copy_paste_keeps_relative_timing_and_crosses_properties() {
|
||
let (mut s, l) = setup();
|
||
animate(&mut s, l, "transform/rotation", &[(0.5, json!(0)), (1.0, json!(90)), (2.0, json!(45))]);
|
||
select_prop_keys(&mut s, l, "transform/rotation");
|
||
s.execute("keys.easyEase", json!({})).unwrap();
|
||
assert_eq!(s.execute("edit.copy", json!({})).unwrap(), json!(3));
|
||
assert!(s.state.clip_is_keys);
|
||
// Paste into the same property at 2.5 s: keys at 2.5, 3.0 and 4.0 (clamped by nothing).
|
||
s.execute("time.set", json!({"time": 2.5})).unwrap();
|
||
s.execute("keys.select", json!({"keys": []})).unwrap();
|
||
s.execute("edit.paste", json!({})).unwrap();
|
||
let after = |s: &Session| {
|
||
let p = prop(s, l, "transform/rotation");
|
||
let times: Vec<f64> = p.keys.iter().map(|k| (k.time.seconds() * 30.0).round() / 30.0).collect();
|
||
assert_eq!(times, vec![0.5, 1.0, 2.0, 2.5, 3.0, 4.0]);
|
||
assert_eq!(p.keys[4].value, KV::Scalar(90.0));
|
||
assert_eq!(p.keys[4].in_interp, Interp::Bezier, "interpolation travels with the keys");
|
||
assert_eq!(s.state.selected_keys.len(), 3, "pasted keys are selected");
|
||
};
|
||
undo_redo_roundtrip(&mut s, after, |s| assert_eq!(prop(s, l, "transform/rotation").keys.len(), 3));
|
||
// Cross-property paste of one property's keys into another of the same type (Scalar).
|
||
let r = s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
|
||
let l2 = r["layer"].as_u64().unwrap();
|
||
select_prop_keys(&mut s, l, "transform/rotation");
|
||
s.execute("keys.select", json!({"keys": [{"layer": l, "prop": prop(&s, l, "transform/rotation").uid, "time": 1.0}]})).unwrap();
|
||
s.execute("keys.copy", json!({})).unwrap();
|
||
s.execute("time.set", json!({"time": 1.0})).unwrap();
|
||
s.execute("prop.select", json!({"layer": l2, "path": "transform/opacity", "selectKeys": false})).unwrap();
|
||
s.execute("keys.paste", json!({"layers": [l2]})).unwrap();
|
||
let op = prop(&s, l2, "transform/opacity");
|
||
assert_eq!(op.keys.len(), 1);
|
||
assert_eq!(op.keys[0].value, KV::Scalar(90.0));
|
||
// Incompatible target (Vec3 position) is refused when explicitly given.
|
||
let e = s.execute("keys.paste", json!({"layers": [l2], "path": "transform/position"}));
|
||
assert!(e.is_err() || prop(&s, l2, "transform/position").keys.is_empty());
|
||
}
|
||
|
||
#[test]
|
||
fn cut_removes_keys_and_paste_restores_them() {
|
||
let (mut s, l) = setup();
|
||
animate(&mut s, l, "transform/opacity", &[(0.0, json!(10)), (1.0, json!(20))]);
|
||
select_prop_keys(&mut s, l, "transform/opacity");
|
||
s.execute("edit.cut", json!({})).unwrap();
|
||
assert!(prop(&s, l, "transform/opacity").keys.is_empty());
|
||
s.execute("time.set", json!({"time": 0.0})).unwrap();
|
||
s.execute("layer.select", json!({"layers": [l]})).unwrap();
|
||
s.execute("edit.paste", json!({})).unwrap();
|
||
assert_eq!(prop(&s, l, "transform/opacity").keys.len(), 2);
|
||
}
|
||
|
||
#[test]
|
||
fn select_all_and_nudge_keys() {
|
||
let (mut s, l) = setup();
|
||
animate(&mut s, l, "transform/opacity", &[(0.0, json!(10)), (1.0, json!(20))]);
|
||
animate(&mut s, l, "transform/rotation", &[(0.5, json!(10))]);
|
||
s.state.selected_props.clear();
|
||
s.execute("layer.select", json!({"layers": [l]})).unwrap();
|
||
assert_eq!(s.execute("keys.selectAll", json!({})).unwrap(), json!(3));
|
||
s.execute("keys.nudgeForward", json!({})).unwrap();
|
||
let after = |s: &Session| {
|
||
let p = prop(s, l, "transform/opacity");
|
||
assert!((p.keys[0].time.seconds() - 1.0 / 30.0).abs() < 1e-6);
|
||
assert_eq!(s.state.selected_keys.len(), 3);
|
||
};
|
||
undo_redo_roundtrip(&mut s, after, |s| assert_eq!(prop(s, l, "transform/opacity").keys[0].time.0, 0));
|
||
s.execute("keys.nudgeBackward10", json!({})).unwrap();
|
||
let p = prop(&s, l, "transform/opacity");
|
||
assert!((p.keys[0].time.seconds() + 9.0 / 30.0).abs() < 1e-6, "{}", p.keys[0].time.seconds());
|
||
}
|
||
|
||
#[test]
|
||
fn velocity_dialog_values_per_dimension_and_continuous() {
|
||
let (mut s, l) = setup();
|
||
animate(&mut s, l, "transform/scale", &[(0.0, json!([100, 100])), (1.0, json!([200, 50])), (2.0, json!([100, 100]))]);
|
||
s.execute("keys.select", json!({"keys": [{"layer": l, "prop": prop(&s, l, "transform/scale").uid, "time": 1.0}]})).unwrap();
|
||
let info = s.execute("keys.info", json!({})).unwrap();
|
||
assert_eq!(info[0]["units"], "%/sec");
|
||
assert_eq!(info[0]["dims"], 2);
|
||
// Linear sides present the segment slope: +100 %/s in X on the incoming side.
|
||
assert!((info[0]["inEase"][0]["speed"].as_f64().unwrap() - 100.0).abs() < 1e-6, "{info}");
|
||
s.execute("keys.velocity", json!({"inSpeed": [10, -20], "inInfluence": 50, "continuous": true})).unwrap();
|
||
let after = |s: &Session| {
|
||
let k = &prop(s, l, "transform/scale").keys[1];
|
||
assert_eq!(k.in_ease[0].speed, 10.0);
|
||
assert_eq!(k.in_ease[1].speed, -20.0);
|
||
assert_eq!(k.out_ease[1].speed, -20.0, "continuous mirrors incoming");
|
||
assert!((k.out_ease[0].influence - 0.5).abs() < 1e-9);
|
||
assert!(k.continuous);
|
||
};
|
||
undo_redo_roundtrip(&mut s, after, |s| assert_eq!(prop(s, l, "transform/scale").keys[1].in_interp, Interp::Linear));
|
||
}
|
||
|
||
/// Spatial Bezier keeps the handles a key has and gives a straight linear path handles a third of
|
||
/// the way along it (they had none), so the path can be pulled into a curve; the motion stays the
|
||
/// same (#290). Auto-Bezier keys keep their tangents, a sixth of the way to the neighbour here.
|
||
#[test]
|
||
fn spatial_bezier_gives_a_straight_path_handles() {
|
||
let (mut s, l) = setup();
|
||
animate(&mut s, l, "transform/position", &[(0.0, json!([0, 0])), (2.0, json!([300, 0]))]);
|
||
let mid = prop(&s, l, "transform/position").value_at(effectcraft_time::Tick::from_seconds_f64(0.7)).as_vec3();
|
||
select_prop_keys(&mut s, l, "transform/position");
|
||
for (from, handle) in [("autoBezier", 50.0), ("linear", 100.0)] {
|
||
s.execute("keys.interpolation", json!({"spatial": from})).unwrap();
|
||
s.execute("keys.interpolation", json!({"spatial": "bezier"})).unwrap();
|
||
let p = prop(&s, l, "transform/position");
|
||
assert!(p.keys.iter().all(|k| !k.spatial_auto));
|
||
assert_eq!((p.keys[0].spatial_out, p.keys[1].spatial_in), ([handle, 0.0, 0.0], [-handle, 0.0, 0.0]), "from {from}");
|
||
let now = p.value_at(effectcraft_time::Tick::from_seconds_f64(0.7)).as_vec3();
|
||
assert!((now[0] - mid[0]).abs() < 0.01 && now[1].abs() < 1e-9, "from {from}: {mid:?} → {now:?}");
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn interpolation_dialog_temporal_spatial_and_roving() {
|
||
let (mut s, l) = setup();
|
||
animate(&mut s, l, "transform/position", &[(0.0, json!([0, 0])), (0.3, json!([300, 0])), (2.0, json!([400, 0]))]);
|
||
select_prop_keys(&mut s, l, "transform/position");
|
||
s.execute("keys.interpolation", json!({"interpolation": "hold"})).unwrap();
|
||
assert!(prop(&s, l, "transform/position").keys.iter().all(|k| k.out_interp == Interp::Hold));
|
||
s.execute("keys.interpolation", json!({"interpolation": "autoBezier"})).unwrap();
|
||
assert!(prop(&s, l, "transform/position").keys.iter().all(|k| k.auto_bezier));
|
||
s.execute("keys.interpolation", json!({"interpolation": "continuousBezier", "spatial": "linear"})).unwrap();
|
||
let p = prop(&s, l, "transform/position");
|
||
assert!(p.keys.iter().all(|k| k.continuous && !k.auto_bezier && !k.spatial_auto && k.spatial_out == [0.0; 3]));
|
||
// Rove the middle key: its time follows the path length (300 of 400 px → 1.5 s).
|
||
let uid = p.uid;
|
||
s.execute("keys.select", json!({"keys": [{"layer": l, "prop": uid, "time": 0.3}]})).unwrap();
|
||
s.execute("keys.interpolation", json!({"roving": true})).unwrap();
|
||
let after = |s: &Session| {
|
||
let p = prop(s, l, "transform/position");
|
||
assert!(p.keys[1].roving);
|
||
assert!((p.keys[1].time.seconds() - 1.5).abs() < 0.01, "{}", p.keys[1].time.seconds());
|
||
// The selection follows the roving key.
|
||
assert!((s.state.selected_keys[0].time.seconds() - 1.5).abs() < 0.01);
|
||
};
|
||
undo_redo_roundtrip(&mut s, after, |s| assert!(!prop(s, l, "transform/position").keys[1].roving));
|
||
// Moving the last key re-times the roving key.
|
||
s.execute("keys.set", json!({"layer": l, "path": "transform/position", "time": 2.0, "newTime": 4.0})).unwrap();
|
||
let p = prop(&s, l, "transform/position");
|
||
assert!((p.keys[1].time.seconds() - 3.0).abs() < 0.02, "{}", p.keys[1].time.seconds());
|
||
// Toggle hold on a key and back.
|
||
s.execute("keys.select", json!({"keys": [{"layer": l, "prop": uid, "time": 0.0}]})).unwrap();
|
||
s.execute("keys.toggleHold", json!({})).unwrap();
|
||
assert_eq!(prop(&s, l, "transform/position").keys[0].out_interp, Interp::Hold);
|
||
s.execute("keys.toggleHold", json!({})).unwrap();
|
||
assert_ne!(prop(&s, l, "transform/position").keys[0].out_interp, Interp::Hold);
|
||
}
|
||
|
||
#[test]
|
||
fn graph_editor_key_and_handle_edits() {
|
||
let (mut s, l) = setup();
|
||
animate(&mut s, l, "transform/opacity", &[(0.0, json!(0)), (2.0, json!(100))]);
|
||
// Drag a key in the value graph: new time + value, merged into one undo step.
|
||
s.execute("keys.set", json!({"layer": l, "path": "transform/opacity", "time": 2.0, "newTime": 1.0, "value": 50, "merge": "g1"})).unwrap();
|
||
s.execute("keys.set", json!({"layer": l, "path": "transform/opacity", "time": 1.0, "newTime": 1.5, "value": 60, "merge": "g1"})).unwrap();
|
||
let p = prop(&s, l, "transform/opacity");
|
||
assert!((p.keys[1].time.seconds() - 1.5).abs() < 1e-6);
|
||
assert_eq!(p.keys[1].value, KV::Scalar(60.0));
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert!((prop(&s, l, "transform/opacity").keys[1].time.seconds() - 2.0).abs() < 1e-6);
|
||
s.execute("edit.redo", json!({})).unwrap();
|
||
// A key can't be dragged past its neighbour.
|
||
s.execute("keys.set", json!({"layer": l, "path": "transform/opacity", "time": 1.5, "newTime": -1.0})).unwrap();
|
||
let p = prop(&s, l, "transform/opacity");
|
||
assert!(p.keys[1].time > p.keys[0].time);
|
||
// Handle drag: out side of key 0 → speed 200 %/s, 60 % influence.
|
||
s.execute("keys.setEase", json!({"layer": l, "path": "transform/opacity", "time": 0.0, "side": "out", "speed": 200, "influence": 60})).unwrap();
|
||
let k = &prop(&s, l, "transform/opacity").keys[0];
|
||
assert_eq!(k.out_interp, Interp::Bezier);
|
||
assert_eq!(k.out_ease[0].speed, 200.0);
|
||
assert!((k.out_ease[0].influence - 0.6).abs() < 1e-9);
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert_eq!(prop(&s, l, "transform/opacity").keys[0].out_interp, Interp::Linear);
|
||
}
|
||
|
||
#[test]
|
||
fn convert_expression_to_keyframes_on_a_reversed_layer_keeps_values() {
|
||
let (mut s, l) = setup();
|
||
// These tests run without an expression host, so the conversion bakes the keyed ramp under the expression.
|
||
animate(&mut s, l, "transform/rotation", &[(0.0, json!(0)), (3.0, json!(30))]);
|
||
s.execute("prop.setExpression", json!({"layer": l, "path": "transform/rotation", "expression": "value"})).unwrap();
|
||
s.execute("layer.timeReverse", json!({"layers": [l]})).unwrap();
|
||
let at = |t: f64| json!({"layer": l, "path": "transform/rotation", "time": t});
|
||
let sample = |s: &mut Session| [0.5, 1.0, 2.0].map(|t| s.execute("prop.get", at(t)).unwrap()["value"].as_f64().unwrap());
|
||
let before = sample(&mut s);
|
||
assert!(before[0] > before[1] && before[1] > before[2], "{before:?}");
|
||
s.execute("prop.convertExpressionToKeyframes", json!({"layer": l, "path": "transform/rotation"})).unwrap();
|
||
let keys = prop(&s, l, "transform/rotation").keys;
|
||
assert!(keys.len() > 1);
|
||
assert!(keys.windows(2).all(|w| w[0].time < w[1].time));
|
||
let after = sample(&mut s);
|
||
assert!(before.iter().zip(after).all(|(b, a)| (b - a).abs() < 1e-6), "{before:?} -> {after:?}");
|
||
}
|
||
|
||
#[test]
|
||
fn time_reverse_keyframes() {
|
||
let (mut s, l) = setup();
|
||
animate(&mut s, l, "transform/opacity", &[(0.0, json!(0)), (1.0, json!(30)), (3.0, json!(100))]);
|
||
select_prop_keys(&mut s, l, "transform/opacity");
|
||
s.execute("keys.timeReverse", json!({})).unwrap();
|
||
let after = |s: &Session| {
|
||
let p = prop(s, l, "transform/opacity");
|
||
assert_eq!(p.keys[0].value, KV::Scalar(100.0));
|
||
assert!((p.keys[1].time.seconds() - 2.0).abs() < 1e-6);
|
||
};
|
||
undo_redo_roundtrip(&mut s, after, |s| assert_eq!(prop(s, l, "transform/opacity").keys[0].value, KV::Scalar(0.0)));
|
||
}
|
||
|
||
#[test]
|
||
fn pen_tool_draws_edits_and_closes_a_mask() {
|
||
let (mut s, l) = setup();
|
||
// Click (corner), click, drag (Bezier), click on the first vertex (close).
|
||
let r = s.execute("mask.new", json!({"layer": l, "vertices": [[10, 10]]})).unwrap();
|
||
let m = r["mask"].as_u64().unwrap();
|
||
s.execute("mask.addVertex", json!({"layer": l, "mask": m, "point": [90, 10]})).unwrap();
|
||
s.execute("mask.addVertex", json!({"layer": l, "mask": m, "point": [90, 90]})).unwrap();
|
||
s.execute("mask.setVertex", json!({"layer": l, "mask": m, "index": 2, "in": [0, -20], "out": [0, 20], "merge": "pen"})).unwrap();
|
||
s.execute("mask.addVertex", json!({"layer": l, "mask": m, "point": [10, 90]})).unwrap();
|
||
s.execute("mask.setClosed", json!({"layer": l, "mask": m, "closed": true})).unwrap();
|
||
let path = |s: &Session| prop(s, l, "masks/#1/path").value.as_path().unwrap().clone();
|
||
let p = path(&s);
|
||
assert_eq!(p.vertices, vec![[10.0, 10.0], [90.0, 10.0], [90.0, 90.0], [10.0, 90.0]]);
|
||
assert_eq!(p.out_tangents[2], [0.0, 20.0]);
|
||
assert!(p.closed);
|
||
assert_eq!(s.state.selected_vertices.last().unwrap().index, 3);
|
||
// The mask cuts the 100×100 solid (layer centred in the 400×300 comp at 150..250, 100..200).
|
||
let cid = s.active_comp_id().unwrap();
|
||
let img = s.render(cid, effectcraft_time::Tick::ZERO, effectcraft_render::RenderOpts { scale: 1.0, ..Default::default() });
|
||
assert!(img.get(200, 150)[3] > 0.99 && img.get(152, 102)[3] < 0.01);
|
||
// Undo removes the close, redo restores it.
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert!(!path(&s).closed);
|
||
s.execute("edit.redo", json!({})).unwrap();
|
||
// Select two vertices and drag them; Delete removes them.
|
||
s.execute("mask.selectVertices", json!({"vertices": [{"layer": l, "mask": m, "index": 0}, {"layer": l, "mask": m, "index": 1}]})).unwrap();
|
||
s.execute("mask.moveVertices", json!({"delta": [5, -5], "merge": "v1"})).unwrap();
|
||
s.execute("mask.moveVertices", json!({"delta": [5, -5], "merge": "v1"})).unwrap();
|
||
assert_eq!(path(&s).vertices[1], [100.0, 0.0]);
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert_eq!(path(&s).vertices[1], [90.0, 10.0], "a drag is one undo step");
|
||
s.execute("edit.clear", json!({})).unwrap();
|
||
assert_eq!(path(&s).vertices.len(), 2);
|
||
assert!(!path(&s).closed);
|
||
// Animated mask paths get a key at the current time.
|
||
s.execute("prop.toggleAnimation", json!({"layer": l, "path": "masks/#1/path"})).unwrap();
|
||
s.execute("time.set", json!({"time": 1.0})).unwrap();
|
||
s.execute("mask.setVertex", json!({"layer": l, "mask": 1, "index": 0, "point": [0, 0]})).unwrap();
|
||
assert_eq!(prop(&s, l, "masks/#1/path").keys.len(), 2);
|
||
// Mode / feather / opacity / expansion through the timeline commands.
|
||
s.execute("layer.setMask", json!({"layer": l, "mask": m, "mode": "Subtract", "inverted": true})).unwrap();
|
||
s.execute("prop.set", json!({"layer": l, "path": "masks/#1/feather", "value": [4, 4]})).unwrap();
|
||
s.execute("prop.set", json!({"layer": l, "path": "masks/#1/expansion", "value": 3})).unwrap();
|
||
s.execute("prop.set", json!({"layer": l, "path": "masks/#1/opacity", "value": 50})).unwrap();
|
||
assert_eq!(prop(&s, l, "masks/#1/opacity").value, KV::Scalar(50.0));
|
||
s.execute("mask.removeAll", json!({"layer": l})).unwrap();
|
||
assert!(s.active_comp().unwrap().layers[0].masks().unwrap().children.is_empty());
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert_eq!(s.active_comp().unwrap().layers[0].masks().unwrap().children.len(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn alt_click_stopwatch_toggles_a_self_reference_expression() {
|
||
let (mut s, l) = setup();
|
||
s.execute("prop.setExpression", json!({"layer": l, "path": "transform/opacity"})).unwrap();
|
||
assert_eq!(prop(&s, l, "transform/opacity").expr.unwrap().text, "transform.opacity");
|
||
s.execute("prop.setExpression", json!({"layer": l, "path": "transform/opacity", "enabled": false})).unwrap();
|
||
assert!(!prop(&s, l, "transform/opacity").expr.unwrap().enabled);
|
||
s.execute("prop.setExpression", json!({"layer": l, "path": "transform/opacity", "enabled": true})).unwrap();
|
||
s.execute("prop.setExpression", json!({"layer": l, "path": "transform/opacity"})).unwrap();
|
||
assert!(prop(&s, l, "transform/opacity").expr.is_none());
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert!(prop(&s, l, "transform/opacity").expr.unwrap().enabled);
|
||
}
|
||
|
||
#[test]
|
||
fn add_expression_without_path_uses_the_selected_property() {
|
||
let (mut s, l) = setup();
|
||
// Nothing selected: the same hint as Add Property to Essential Graphics.
|
||
let err = s.execute("prop.setExpression", json!({})).unwrap_err().to_string();
|
||
assert!(err.contains("select a property in the timeline"), "{err}");
|
||
assert!(prop(&s, l, "transform/opacity").expr.is_none());
|
||
// Animation > Add Expression sends no parameters.
|
||
s.execute("prop.select", json!({"layer": l, "path": "transform/opacity"})).unwrap();
|
||
s.execute("prop.setExpression", json!({})).unwrap();
|
||
assert_eq!(prop(&s, l, "transform/opacity").expr.unwrap().text, "transform.opacity");
|
||
// One undo step removes it.
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert!(prop(&s, l, "transform/opacity").expr.is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn layer_comp_and_key_times_stay_frame_aligned() {
|
||
let aligned = |fr: effectcraft_time::FrameRate, t: effectcraft_time::Tick| fr.snap(t) == t;
|
||
// The demo project: every comp duration, layer in/out/start and key time is on a frame.
|
||
let mut s = Session::default();
|
||
s.execute("file.openDemoProject", json!({})).unwrap();
|
||
for (_, c) in s.project.comps() {
|
||
let fr = c.frame_rate;
|
||
assert!(aligned(fr, c.duration), "duration {:?}", c.duration);
|
||
for l in &c.layers {
|
||
for t in [l.in_point, l.out_point, l.start_time] {
|
||
assert!(aligned(fr, t), "{} {t:?}", l.name);
|
||
}
|
||
l.props.walk("", &mut |_, pr| {
|
||
for k in &pr.keys {
|
||
assert!(aligned(fr, l.comp_time(k.time)), "{} {}", l.name, pr.name);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
let lower = s.active_comp().unwrap().layer_by_name("Lower Third").unwrap();
|
||
let fr = s.active_comp().unwrap().frame_rate;
|
||
assert_eq!(fr.frame_at(lower.in_point), 150, "5 s at 29.97 is frame 150 (0:00:05:00)");
|
||
// Commands snap: comp duration, layer timing, key times.
|
||
s.execute("comp.new", json!({"name": "F", "frameRate": 29.97, "duration": 10.0})).unwrap();
|
||
let c = s.active_comp().unwrap();
|
||
assert_eq!(c.frame_rate.frame_at(c.duration), 300);
|
||
assert!(aligned(c.frame_rate, c.duration));
|
||
let l = s.execute("layer.newSolid", json!({"color": "#fff"})).unwrap()["layer"].as_u64().unwrap();
|
||
s.execute("layer.timing", json!({"layers": [l], "in": 1.01, "out": 3.3333, "delta": 0.02})).unwrap();
|
||
let ly = s.active_comp().unwrap().layers[0].clone();
|
||
let fr = s.active_comp().unwrap().frame_rate;
|
||
for t in [ly.in_point, ly.out_point, ly.start_time] {
|
||
assert!(aligned(fr, t), "{t:?}");
|
||
}
|
||
s.execute("prop.addKey", json!({"layer": l, "path": "transform/opacity", "time": 1.2345, "value": 10})).unwrap();
|
||
let k = prop(&s, l, "transform/opacity").keys[0].time;
|
||
assert!(aligned(fr, ly.comp_time(k)));
|
||
// Layer shifted one frame (delta 0.02 s rounds to 1 frame): 1.2345 s + 1 frame -> frame 38.
|
||
assert_eq!(fr.frame_at(ly.comp_time(k)), 38);
|
||
}
|
||
|
||
#[test]
|
||
fn time_set_snaps_to_the_nearest_frame_and_ae_timecode() {
|
||
let mut s = Session::default();
|
||
s.execute("comp.new", json!({"name": "T", "width": 100, "height": 100, "frameRate": 29.97, "duration": 10})).unwrap();
|
||
let r = s.execute("time.set", json!({"time": 2.5})).unwrap();
|
||
assert_eq!(r["frame"], 75);
|
||
let fr = s.active_comp().unwrap().frame_rate;
|
||
assert_eq!(effectcraft_time::format_timecode_ae(75, fr, false), "0:00:02:15");
|
||
assert_eq!(effectcraft_time::format_timecode_ae(75, fr, true), "0;00;02;15");
|
||
}
|
||
|
||
#[test]
|
||
fn time_set_keeps_the_frame_shown_in_the_current_time_field() {
|
||
let mut s = Session::default();
|
||
s.execute("comp.new", json!({"name": "Example", "width": 64, "height": 64, "frameRate": 30, "duration": 0.6, "startTimecode": "0:00:00:05"})).unwrap();
|
||
let r = s.execute("time.set", json!({"frame": 0})).unwrap();
|
||
assert_eq!(r["display"], "0:00:00:05");
|
||
let r = s.execute("time.set", json!({"timecode": "0:00:00:05"})).unwrap();
|
||
assert_eq!((r["frame"].as_i64(), r["time"].as_f64()), (Some(0), Some(0.0)));
|
||
|
||
s.execute("file.projectSettings", json!({"timeDisplay": "frames"})).unwrap();
|
||
std::sync::Arc::make_mut(&mut s.project).settings.frame_start = 1;
|
||
let r = s.execute("time.set", json!({"frame": 12})).unwrap();
|
||
assert_eq!(r["display"], "00013");
|
||
let r = s.execute("time.set", json!({"timecode": "00013"})).unwrap();
|
||
assert_eq!((r["frame"].as_i64(), r["time"].as_f64()), (Some(12), Some(0.4)));
|
||
let r = s.execute("time.set", json!({"timecode": "+1"})).unwrap();
|
||
assert_eq!(r["frame"], 13);
|
||
}
|
||
|
||
/// Frames display style: typed digits are a frame count, so 00100 is frame 100, not 1 s (#530).
|
||
#[test]
|
||
fn time_set_reads_frames_style_digits_as_a_frame_count() {
|
||
let mut s = Session::default();
|
||
s.execute("comp.new", json!({"name": "Long", "width": 64, "height": 64, "frameRate": 30, "duration": 10})).unwrap();
|
||
s.execute("file.projectSettings", json!({"timeDisplay": "frames"})).unwrap();
|
||
let r = s.execute("time.set", json!({"timecode": "00100"})).unwrap();
|
||
assert_eq!(r["frame"], 100);
|
||
assert_eq!(r["display"], "00100");
|
||
}
|
||
|
||
#[test]
|
||
fn separate_dimensions_split_and_rejoin() {
|
||
let (mut s, l) = setup();
|
||
animate(&mut s, l, "transform/position", &[(0.0, json!([0, 100])), (2.0, json!([200, 50]))]);
|
||
s.execute("prop.separateDimensions", json!({"layer": l})).unwrap();
|
||
let after = |s: &Session| {
|
||
let x = prop(s, l, "transform/positionX");
|
||
let y = prop(s, l, "transform/positionY");
|
||
assert_eq!(x.keys.len(), 2);
|
||
assert_eq!(y.keys[1].value, KV::Scalar(50.0));
|
||
// The layer still renders at the same place (render sees the separated values).
|
||
let cid = s.active_comp_id().unwrap();
|
||
let comp = s.project.comp(cid).unwrap();
|
||
let layer = &comp.layers[0];
|
||
let ctx = effectcraft_render::EvalCtx::new(&s.project, cid, comp, effectcraft_time::Tick::from_seconds_f64(1.0));
|
||
let p = ctx.value(layer, layer.transform().unwrap().get("position").unwrap()).as_vec3();
|
||
assert!((p[0] - 100.0).abs() < 1e-6 && (p[1] - 75.0).abs() < 1e-6, "{p:?}");
|
||
};
|
||
undo_redo_roundtrip(&mut s, after, |s| assert!(s.active_comp().unwrap().layers[0].transform().unwrap().get("positionX").is_none()));
|
||
// X and Y animate independently.
|
||
s.execute("keys.select", json!({"keys": []})).unwrap();
|
||
s.execute("prop.select", json!({"layer": l, "path": "transform/positionX"})).unwrap();
|
||
s.execute("keys.easyEase", json!({})).unwrap();
|
||
assert_eq!(prop(&s, l, "transform/positionY").keys[0].out_interp, Interp::Linear);
|
||
// Setting Position (viewer drags) writes X/Y.
|
||
s.execute("time.set", json!({"time": 3.0})).unwrap();
|
||
s.execute("prop.set", json!({"layer": l, "path": "transform/position", "value": [7, 8, 0]})).unwrap();
|
||
assert_eq!(prop(&s, l, "transform/positionX").keys.len(), 3);
|
||
// Re-join: one Position with keys at the union of times.
|
||
s.execute("prop.separateDimensions", json!({"layer": l})).unwrap();
|
||
let p = prop(&s, l, "transform/position");
|
||
assert_eq!(p.keys.len(), 3);
|
||
assert_eq!(p.keys[2].value, KV::Vec3([7.0, 8.0, 0.0]));
|
||
assert!(s.active_comp().unwrap().layers[0].transform().unwrap().get("positionX").is_none());
|
||
}
|
||
|
||
#[test]
|
||
fn parenting_keeps_the_layer_in_place() {
|
||
let (mut s, child) = setup();
|
||
let r = s.execute("layer.newNull", json!({})).unwrap();
|
||
let par = r["layer"].as_u64().unwrap();
|
||
s.execute("prop.set", json!({"layer": par, "path": "transform/position", "value": [300, 200]})).unwrap();
|
||
s.execute("prop.set", json!({"layer": par, "path": "transform/rotation", "value": 90})).unwrap();
|
||
s.execute("prop.set", json!({"layer": par, "path": "transform/scale", "value": [200, 200]})).unwrap();
|
||
s.execute("prop.set", json!({"layer": child, "path": "transform/position", "value": [100, 50]})).unwrap();
|
||
let world = |s: &Session| {
|
||
let cid = s.active_comp_id().unwrap();
|
||
let comp = s.project.comp(cid).unwrap();
|
||
let l = comp.layer(effectcraft_project::LayerId(child)).unwrap();
|
||
let ctx = effectcraft_render::EvalCtx::new(&s.project, cid, comp, effectcraft_time::Tick::ZERO);
|
||
let (m, _) = ctx.layer_to_comp(l);
|
||
let a = m.apply(effectcraft_geom::vec2(50.0, 50.0));
|
||
let b = m.apply(effectcraft_geom::vec2(100.0, 50.0));
|
||
(a, (b.y - a.y).atan2(b.x - a.x).to_degrees(), (b.x - a.x).hypot(b.y - a.y))
|
||
};
|
||
let before = world(&s);
|
||
s.execute("layer.setParent", json!({"layers": [child], "parent": par})).unwrap();
|
||
let after = world(&s);
|
||
assert!((before.0.x - after.0.x).abs() < 1e-6 && (before.0.y - after.0.y).abs() < 1e-6, "{before:?} {after:?}");
|
||
assert!((before.1 - after.1).abs() < 1e-6 && (before.2 - after.2).abs() < 1e-6);
|
||
assert!((prop(&s, child, "transform/rotation").value.as_f64() + 90.0).abs() < 1e-9);
|
||
// Unparenting restores comp-space values.
|
||
s.execute("layer.setParent", json!({"layers": [child], "parent": null})).unwrap();
|
||
let p = prop(&s, child, "transform/position").value.as_vec3();
|
||
assert!((p[0] - 100.0).abs() < 1e-6 && (p[1] - 50.0).abs() < 1e-6, "{p:?}");
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert!(s.active_comp().unwrap().layer(effectcraft_project::LayerId(child)).unwrap().parent.is_some());
|
||
}
|
||
|
||
/// #284: toggling stopwatches with one `merge` key (dragging over them) is one undo step.
|
||
#[test]
|
||
fn stopwatch_toggles_with_a_merge_key_are_one_undo_step() {
|
||
let (mut s, l) = setup();
|
||
let steps = s.history.undo.len();
|
||
for path in ["transform/position", "transform/scale", "transform/opacity"] {
|
||
s.execute("prop.toggleAnimation", json!({"layer": l, "path": path, "value": true, "merge": "drag"})).unwrap();
|
||
}
|
||
assert_eq!(s.history.undo.len(), steps + 1);
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert!(["transform/position", "transform/scale", "transform/opacity"].iter().all(|p| !prop(&s, l, p).is_animated()));
|
||
}
|
||
|
||
#[test]
|
||
fn pick_whip_generates_ae_reference_expressions() {
|
||
let (mut s, l) = setup();
|
||
let r = s.execute("layer.newSolid", json!({"name": "Other", "color": "#00ff00"})).unwrap();
|
||
let o = r["layer"].as_u64().unwrap();
|
||
s.execute("effect.apply", json!({"layer": o, "effect": "Gaussian Blur"})).unwrap();
|
||
s.execute("layer.addMask", json!({"layer": o})).unwrap();
|
||
let cases = [
|
||
("transform/opacity", json!({"layer": o, "path": "transform/opacity"}), "thisComp.layer(\"Other\").transform.opacity"),
|
||
("transform/rotation", json!({"layer": l, "path": "transform/opacity"}), "transform.opacity"),
|
||
("transform/rotation", json!({"layer": o, "path": "effects/#1/blurriness"}), "thisComp.layer(\"Other\").effect(\"Gaussian Blur\")(\"Blurriness\")"),
|
||
("transform/opacity", json!({"layer": o, "path": "masks/#1/feather"}), "thisComp.layer(\"Other\").mask(\"Mask 1\").maskFeather[0]"),
|
||
("transform/scale", json!({"layer": o, "path": "transform/rotation"}), "temp = thisComp.layer(\"Other\").transform.rotation;\n[temp, temp]"),
|
||
("transform/position", json!({"layer": o, "path": "transform/position"}), "thisComp.layer(\"Other\").transform.position"),
|
||
];
|
||
for (path, target, want) in cases {
|
||
let got = s.execute("prop.pickWhip", json!({"layer": l, "path": path, "target": target})).unwrap();
|
||
assert_eq!(got, json!(want));
|
||
assert_eq!(prop(&s, l, path).expr.unwrap().text, want);
|
||
}
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert_ne!(prop(&s, l, "transform/position").expr.map(|e| e.text), Some("thisComp.layer(\"Other\").transform.position".into()));
|
||
assert!(s.execute("prop.pickWhip", json!({"layer": l, "path": "transform/opacity", "target": {"layer": l, "path": "transform/opacity"}})).is_err());
|
||
}
|
||
|
||
/// #407: Reset without a value gives a property its own default (a Transform property's, an
|
||
/// effect parameter's) besides removing its keyframes and expression.
|
||
#[test]
|
||
fn reset_gives_a_property_its_default() {
|
||
let (mut s, l) = setup();
|
||
s.execute("effect.apply", json!({"layer": l, "effect": "Gaussian Blur"})).unwrap();
|
||
let blur = prop(&s, l, "effects/#1/blurriness").value;
|
||
let set = [
|
||
("transform/anchor", json!([10, 20, 0])),
|
||
("transform/position", json!([10, 20, 0])),
|
||
("transform/scale", json!([50, 70, 100])),
|
||
("transform/rotation", json!(30)),
|
||
("transform/opacity", json!(40)),
|
||
("effects/#1/blurriness", json!(25)),
|
||
];
|
||
for (path, v) in &set {
|
||
s.execute("prop.set", json!({"layer": l, "path": path, "value": v})).unwrap();
|
||
}
|
||
animate(&mut s, l, "transform/rotation", &[(0.0, json!(10)), (1.0, json!(20))]);
|
||
s.execute("prop.setExpression", json!({"layer": l, "path": "transform/opacity", "expression": "50"})).unwrap();
|
||
for (path, _) in &set {
|
||
s.execute("prop.reset", json!({"layer": l, "path": path})).unwrap();
|
||
}
|
||
let v = |s: &Session, path: &str| prop(s, l, path).value;
|
||
assert_eq!(v(&s, "transform/anchor"), KV::Vec3([50.0, 50.0, 0.0]), "the solid's centre");
|
||
assert_eq!(v(&s, "transform/position"), KV::Vec3([200.0, 150.0, 0.0]), "the comp's centre");
|
||
assert_eq!(v(&s, "transform/scale"), KV::Vec3([100.0; 3]));
|
||
assert_eq!(v(&s, "transform/rotation"), KV::Scalar(0.0));
|
||
assert!(!prop(&s, l, "transform/rotation").is_animated());
|
||
assert_eq!(v(&s, "transform/opacity"), KV::Scalar(100.0));
|
||
assert!(prop(&s, l, "transform/opacity").expr.is_none());
|
||
assert_eq!(v(&s, "effects/#1/blurriness"), blur);
|
||
// A given default still wins.
|
||
s.execute("prop.reset", json!({"layer": l, "path": "transform/opacity", "default": 30})).unwrap();
|
||
assert_eq!(v(&s, "transform/opacity"), KV::Scalar(30.0));
|
||
}
|
||
|
||
/// #363: dropped on one of the target's values the pick whip picks that dimension
|
||
/// (`position[0]`), as in After Effects; a multi-dimension property follows it on every axis.
|
||
#[test]
|
||
fn pick_whip_picks_one_dimension_of_the_target() {
|
||
let (mut s, l) = setup();
|
||
let o = s.execute("layer.newSolid", json!({"name": "Other", "color": "#00ff00"})).unwrap()["layer"].as_u64().unwrap();
|
||
let whip = |s: &mut Session, path: &str, d: u64| {
|
||
s.execute("prop.pickWhip", json!({"layer": l, "path": path, "target": {"layer": o, "path": "transform/position", "dimension": d}}))
|
||
};
|
||
let r = "thisComp.layer(\"Other\").transform.position";
|
||
assert_eq!(whip(&mut s, "transform/rotation", 0).unwrap(), json!(format!("{r}[0]")));
|
||
assert_eq!(whip(&mut s, "transform/scale", 1).unwrap(), json!(format!("temp = {r}[1];\n[temp, temp]")));
|
||
assert_eq!(prop(&s, l, "transform/scale").expr.unwrap().text, format!("temp = {r}[1];\n[temp, temp]"));
|
||
// A 2D layer's Position has two.
|
||
assert!(whip(&mut s, "transform/rotation", 2).is_err());
|
||
}
|
||
|
||
/// #284: with the expression being edited, the pick whip puts the reference at the cursor,
|
||
/// replacing the selected characters (After Effects), in one undo step.
|
||
#[test]
|
||
fn pick_whip_inserts_into_the_expression_being_edited() {
|
||
let (mut s, l) = setup();
|
||
let o = s.execute("layer.newSolid", json!({"name": "Ö", "color": "#00ff00"})).unwrap()["layer"].as_u64().unwrap();
|
||
let whip = |s: &mut Session, base: &str, range: Value| {
|
||
let mut p = json!({"layer": l, "path": "transform/opacity", "target": {"layer": o, "path": "transform/rotation"}, "expression": base});
|
||
if !range.is_null() {
|
||
p["range"] = range;
|
||
}
|
||
s.execute("prop.pickWhip", p)
|
||
};
|
||
let r = "thisComp.layer(\"Ö\").transform.rotation";
|
||
// Characters, not bytes: "é" before the cursor.
|
||
assert_eq!(whip(&mut s, "é + 5", json!([1, 1])).unwrap(), json!(format!("é{r} + 5")));
|
||
assert_eq!(prop(&s, l, "transform/opacity").expr.unwrap().text, format!("é{r} + 5"));
|
||
// A selection (either way round) is replaced; no range: at the end.
|
||
assert_eq!(whip(&mut s, "a*2+b", json!([4, 2])).unwrap(), json!(format!("a*{r}b")));
|
||
assert_eq!(whip(&mut s, "x + ", Value::Null).unwrap(), json!(format!("x + {r}")));
|
||
// Past the end clamps; a malformed range is an error.
|
||
assert_eq!(whip(&mut s, "7", json!([9, 99])).unwrap(), json!(format!("7{r}")));
|
||
assert!(whip(&mut s, "7", json!([1])).is_err());
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert_eq!(prop(&s, l, "transform/opacity").expr.unwrap().text, format!("x + {r}"));
|
||
}
|
||
|
||
/// Outer comp (4 s) containing a precomp whose 10×10 white solid moves x = 10 + 20·t (t in s).
|
||
/// Returns (session, precomp layer id in the outer comp).
|
||
fn precomp_setup() -> (Session, u64) {
|
||
let mut s = Session::default();
|
||
s.execute("comp.new", json!({"name": "Inner", "width": 100, "height": 100, "frameRate": 30, "duration": 4})).unwrap();
|
||
let r = s.execute("layer.newSolid", json!({"color": "#ffffff", "width": 10, "height": 10})).unwrap();
|
||
let l = r["layer"].as_u64().unwrap();
|
||
animate(&mut s, l, "transform/position", &[(0.0, json!([10, 50])), (4.0, json!([90, 50]))]);
|
||
s.execute("comp.new", json!({"name": "Outer", "width": 100, "height": 100, "frameRate": 30, "duration": 4})).unwrap();
|
||
let r = s.execute("layer.addItem", json!({"item": "Inner"})).unwrap();
|
||
let pl = r["layer"].as_u64().unwrap();
|
||
s.execute("layer.select", json!({"layers": [pl]})).unwrap();
|
||
(s, pl)
|
||
}
|
||
|
||
/// X of the moving square's centre in the outer comp at `t`.
|
||
fn square_x(s: &Session, t: f64) -> f64 {
|
||
let cid = s.active_comp_id().unwrap();
|
||
let img = s.render(cid, effectcraft_time::Tick::from_seconds_f64(t), effectcraft_render::RenderOpts { scale: 1.0, ..Default::default() });
|
||
let xs: Vec<usize> = (0..img.width as usize).filter(|x| img.get(*x as i64, 50)[3] > 0.5).collect();
|
||
assert!(!xs.is_empty(), "nothing drawn at {t}");
|
||
(xs[0] + xs[xs.len() - 1]) as f64 / 2.0 + 0.5
|
||
}
|
||
|
||
#[test]
|
||
fn time_remap_enable_freeze_and_disable() {
|
||
let (mut s, l) = precomp_setup();
|
||
assert!((square_x(&s, 1.0) - 30.0).abs() < 1.5);
|
||
s.execute("layer.enableTimeRemap", json!({})).unwrap();
|
||
let after = |s: &Session| {
|
||
let p = prop(s, l, "timeRemap");
|
||
assert_eq!(p.keys.len(), 2);
|
||
assert_eq!(p.keys[1].value, KV::Scalar(4.0));
|
||
// Remapping at identity shows the same frames.
|
||
assert!((square_x(s, 1.0) - 30.0).abs() < 1.5);
|
||
};
|
||
undo_redo_roundtrip(&mut s, after, |s| assert!(s.active_comp().unwrap().layers[0].props.get("timeRemap").is_none()));
|
||
// Remap the first key to show source time 3 s at comp time 0.
|
||
s.execute("keys.set", json!({"layer": l, "path": "timeRemap", "time": 0.0, "value": 3.0})).unwrap();
|
||
assert!((square_x(&s, 0.0) - 70.0).abs() < 1.5, "{}", square_x(&s, 0.0));
|
||
// Freeze Frame at 2 s: one hold key; every frame shows source time 2 s.
|
||
s.execute("time.set", json!({"time": 2.0})).unwrap();
|
||
s.execute("keys.set", json!({"layer": l, "path": "timeRemap", "time": 0.0, "value": 0.0})).unwrap();
|
||
s.execute("layer.freezeFrame", json!({})).unwrap();
|
||
let p = prop(&s, l, "timeRemap");
|
||
assert_eq!(p.keys.len(), 1);
|
||
assert_eq!(p.keys[0].out_interp, Interp::Hold);
|
||
for t in [0.0, 1.0, 3.5] {
|
||
assert!((square_x(&s, t) - 50.0).abs() < 1.5, "{t}: {}", square_x(&s, t));
|
||
}
|
||
// Ctrl+Alt+T again disables remapping.
|
||
s.execute("layer.enableTimeRemap", json!({})).unwrap();
|
||
assert!((square_x(&s, 1.0) - 30.0).abs() < 1.5);
|
||
// Solids can't be remapped.
|
||
let r = s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
|
||
assert!(s.execute("layer.enableTimeRemap", json!({"layers": [r["layer"]]})).is_err());
|
||
}
|
||
|
||
/// Edit ▸ Clear with Time Remap selected (clicking its name selects all its keys) turns time
|
||
/// remapping off instead of deleting the layer (#290); one selected key is still just a key.
|
||
#[test]
|
||
fn deleting_time_remap_turns_time_remapping_off() {
|
||
let (mut s, l) = precomp_setup();
|
||
s.execute("layer.enableTimeRemap", json!({})).unwrap();
|
||
let uid = prop(&s, l, "timeRemap").uid;
|
||
s.execute("keys.select", json!({"keys": [{"layer": l, "prop": uid, "time": 0.0}], "selectProperties": true})).unwrap();
|
||
s.execute("edit.clear", json!({})).unwrap();
|
||
assert_eq!(prop(&s, l, "timeRemap").keys.len(), 1, "only the selected key went");
|
||
s.execute("prop.select", json!({"layer": l, "prop": uid})).unwrap();
|
||
s.execute("edit.clear", json!({})).unwrap();
|
||
let comp = s.active_comp().unwrap();
|
||
assert_eq!(comp.layers.len(), 1, "the layer stays");
|
||
assert!(comp.layers[0].props.get("timeRemap").is_none(), "time remapping is off");
|
||
assert!(s.state.selected_keys.is_empty() && !s.state.selected_props.iter().any(|(_, u)| *u == uid));
|
||
assert!((square_x(&s, 1.0) - 30.0).abs() < 1.5);
|
||
// One undo step brings it back.
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert_eq!(prop(&s, l, "timeRemap").keys.len(), 1);
|
||
}
|
||
|
||
/// Enable Time Remapping on a layer extended past its source's end (its last frame frozen) puts
|
||
/// the end key at the source's end, not at the extended out point (#290).
|
||
#[test]
|
||
fn time_remap_on_an_extended_layer_ends_at_the_source_end() {
|
||
let mut s = Session::default();
|
||
s.execute("comp.new", json!({"name": "Inner", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
|
||
s.execute("comp.new", json!({"name": "Outer", "width": 100, "height": 100, "frameRate": 30, "duration": 4})).unwrap();
|
||
let l = s.execute("layer.addItem", json!({"item": "Inner"})).unwrap()["layer"].as_u64().unwrap();
|
||
s.execute("layer.timing", json!({"layers": [l], "out": 4.0})).unwrap();
|
||
s.execute("layer.enableTimeRemap", json!({"layers": [l]})).unwrap();
|
||
let p = prop(&s, l, "timeRemap");
|
||
let keys: Vec<(f64, KV)> = p.keys.iter().map(|k| (k.time.seconds(), k.value.clone())).collect();
|
||
assert_eq!(keys, vec![(0.0, KV::Scalar(0.0)), (2.0, KV::Scalar(2.0))]);
|
||
assert_eq!(s.active_comp().unwrap().layers[0].out_point.seconds(), 4.0, "the layer stays extended");
|
||
}
|
||
|
||
#[test]
|
||
fn freeze_on_last_frame_extends_the_layer() {
|
||
let (mut s, l) = precomp_setup();
|
||
s.execute("layer.timing", json!({"layers": [l], "out": 2.0})).unwrap();
|
||
s.execute("layer.freezeOnLastFrame", json!({})).unwrap();
|
||
let layer = s.active_comp().unwrap().layers[0].clone();
|
||
assert_eq!(layer.out_point, s.active_comp().unwrap().duration);
|
||
// Plays normally, then holds the frame before the old out point.
|
||
assert!((square_x(&s, 1.0) - 30.0).abs() < 1.5);
|
||
let hold = 10.0 + 20.0 * (2.0 - 1.0 / 30.0);
|
||
assert!((square_x(&s, 3.5) - hold).abs() < 1.5, "{}", square_x(&s, 3.5));
|
||
}
|
||
|
||
#[test]
|
||
fn time_reverse_layer_plays_backwards_and_round_trips() {
|
||
let (mut s, l) = precomp_setup();
|
||
let before = s.active_comp().unwrap().layers[0].clone();
|
||
s.execute("layer.timeReverse", json!({})).unwrap();
|
||
let after = |s: &Session| {
|
||
let ly = &s.active_comp().unwrap().layers[0];
|
||
assert_eq!(ly.stretch, -100.0);
|
||
assert_eq!((ly.in_point, ly.out_point), (before.in_point, before.out_point));
|
||
// First frame shows the last source frame; the end shows the start.
|
||
let last = 10.0 + 20.0 * (4.0 - 1.0 / 30.0);
|
||
assert!((square_x(s, 0.0) - last).abs() < 1.5, "{}", square_x(s, 0.0));
|
||
assert!((square_x(s, 4.0 - 1.0 / 30.0) - 10.0).abs() < 1.5);
|
||
};
|
||
undo_redo_roundtrip(&mut s, after, |s| assert_eq!(s.active_comp().unwrap().layers[0].stretch, 100.0));
|
||
// Reversing twice restores normal playback.
|
||
s.execute("layer.timeReverse", json!({"layers": [l]})).unwrap();
|
||
let ly = &s.active_comp().unwrap().layers[0];
|
||
assert_eq!(ly.stretch, 100.0);
|
||
assert_eq!(ly.start_time, before.start_time);
|
||
assert!((square_x(&s, 1.0) - 30.0).abs() < 1.5);
|
||
}
|
||
|
||
#[test]
|
||
fn time_stretch_holds_in_current_or_out() {
|
||
let (mut s, l) = precomp_setup();
|
||
s.execute("layer.timeStretch", json!({"percent": 50})).unwrap();
|
||
let ly = s.active_comp().unwrap().layers[0].clone();
|
||
assert_eq!(ly.stretch, 50.0);
|
||
assert!((ly.out_point.seconds() - 2.0).abs() < 1e-6);
|
||
// Twice as fast: comp 1 s shows source 2 s.
|
||
assert!((square_x(&s, 1.0) - 50.0).abs() < 1.5);
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
// Hold the current frame (2 s) in place while doubling the duration.
|
||
s.execute("time.set", json!({"time": 2.0})).unwrap();
|
||
s.execute("layer.timeStretch", json!({"layers": [l], "duration": 8.0, "hold": "current"})).unwrap();
|
||
let ly = s.active_comp().unwrap().layers[0].clone();
|
||
assert!((ly.stretch - 200.0).abs() < 1e-6);
|
||
assert!((ly.in_point.seconds() + 2.0).abs() < 1e-6, "{}", ly.in_point.seconds());
|
||
assert!((square_x(&s, 2.0) - 50.0).abs() < 1.5);
|
||
// Hold the out point.
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
s.execute("layer.timeStretch", json!({"layers": [l], "percent": 50, "hold": "out"})).unwrap();
|
||
let ly = s.active_comp().unwrap().layers[0].clone();
|
||
assert!((ly.out_point.seconds() - 4.0).abs() < 1e-6 && (ly.in_point.seconds() - 2.0).abs() < 1e-6);
|
||
assert!(s.execute("layer.timeStretch", json!({"layers": [l], "percent": 0})).is_err());
|
||
}
|
||
|
||
#[test]
|
||
fn arrange_above_moves_layers_to_a_place_in_the_stack() {
|
||
let mut s = Session::default();
|
||
s.execute("comp.new", json!({"name": "Stack", "width": 100, "height": 100, "duration": 2})).unwrap();
|
||
for n in ["D", "C", "B", "A"] {
|
||
s.execute("layer.newSolid", json!({"name": n, "width": 10, "height": 10})).unwrap();
|
||
}
|
||
let names = |s: &Session| s.active_comp().unwrap().layers.iter().map(|l| l.name.clone()).collect::<Vec<_>>();
|
||
assert_eq!(names(&s), ["A", "B", "C", "D"]);
|
||
// A below C (one undo step), then B and D together above A, then C to the bottom.
|
||
s.execute("layer.arrange", json!({"layers": ["A"], "above": "D"})).unwrap();
|
||
assert_eq!(names(&s), ["B", "C", "A", "D"]);
|
||
s.execute("layer.arrange", json!({"layers": ["B", "D"], "above": "A"})).unwrap();
|
||
assert_eq!(names(&s), ["C", "B", "D", "A"]);
|
||
s.execute("layer.arrange", json!({"layers": ["C"], "to": "back"})).unwrap();
|
||
assert_eq!(names(&s), ["B", "D", "A", "C"]);
|
||
s.undo();
|
||
assert_eq!(names(&s), ["C", "B", "D", "A"]);
|
||
// A layer can't go above itself; unknown targets fail.
|
||
assert!(s.execute("layer.arrange", json!({"layers": ["B"], "above": "B"})).is_err());
|
||
assert!(s.execute("layer.arrange", json!({"layers": ["B"], "above": "Nope"})).is_err());
|
||
}
|
||
|
||
#[test]
|
||
fn toggle_transform_key_covers_selected_layers_separated_position_and_3d_rotation() {
|
||
let mut s = Session::default();
|
||
s.execute("comp.new", json!({"name": "K", "width": 100, "height": 100, "duration": 2})).unwrap();
|
||
let a = s.execute("layer.newSolid", json!({"name": "A", "width": 10, "height": 10})).unwrap()["layer"].as_u64().unwrap();
|
||
let b = s.execute("layer.newSolid", json!({"name": "B", "width": 10, "height": 10})).unwrap()["layer"].as_u64().unwrap();
|
||
s.execute("layer.select", json!({"layers": [a, b]})).unwrap();
|
||
let keys = |s: &Session, l: u64, path: &str| prop(s, l, path).keys.len();
|
||
// Both selected layers get an Opacity key, in one undo step; again removes them.
|
||
let steps = s.history.undo.len();
|
||
s.execute("keys.toggleTransform", json!({"prop": "opacity"})).unwrap();
|
||
assert_eq!((keys(&s, a, "transform/opacity"), keys(&s, b, "transform/opacity")), (1, 1));
|
||
assert_eq!(s.history.undo.len(), steps + 1);
|
||
s.execute("keys.toggleTransform", json!({"prop": "opacity"})).unwrap();
|
||
assert_eq!(keys(&s, a, "transform/opacity"), 0);
|
||
// A 3D layer's Rotation key covers Orientation and X/Y/Z Rotation.
|
||
s.execute("layer.setSwitch", json!({"layers": [a], "switch": "threeD", "value": true})).unwrap();
|
||
s.execute("keys.toggleTransform", json!({"layers": [a], "prop": "rotation"})).unwrap();
|
||
for p in ["orientation", "rotationX", "rotationY", "rotation"] {
|
||
assert_eq!(keys(&s, a, &format!("transform/{p}")), 1, "{p}");
|
||
}
|
||
assert!(s.execute("keys.toggleTransform", json!({"prop": "skew"})).is_err());
|
||
}
|
||
|
||
/// #355, #491: with several layers selected, the stopwatch, the keyframe button and value edits
|
||
/// (`selected: true`, as the panels send them) apply to every selected layer in one undo step; a
|
||
/// scrub (`offset`) moves each layer by the same amount, a typed value sets them all.
|
||
#[test]
|
||
fn property_edits_apply_to_every_selected_layer() {
|
||
let (mut s, a) = setup();
|
||
let b = s.execute("layer.newSolid", json!({"color": "#ff0000", "width": 50, "height": 50})).unwrap()["layer"].as_u64().unwrap();
|
||
let c = s.execute("layer.newSolid", json!({"color": "#00ff00", "width": 50, "height": 50})).unwrap()["layer"].as_u64().unwrap();
|
||
s.execute("prop.set", json!({"layer": b, "path": "transform/position", "value": [10, 20]})).unwrap();
|
||
s.execute("layer.select", json!({"layers": [a, b]})).unwrap();
|
||
let pos = |s: &Session, l: u64| prop(s, l, "transform/position").value_at(effectcraft_time::Tick::ZERO).components();
|
||
let uid = prop(&s, a, "transform/position").uid;
|
||
|
||
// Stopwatch on all selected layers, one undo step; the unselected layer is untouched.
|
||
let undo = s.history.undo.len();
|
||
s.execute("prop.toggleAnimation", json!({"layer": a, "prop": uid, "selected": true})).unwrap();
|
||
assert!(prop(&s, a, "transform/position").is_animated() && prop(&s, b, "transform/position").is_animated());
|
||
assert!(!prop(&s, c, "transform/position").is_animated());
|
||
assert_eq!(s.history.undo.len(), undo + 1);
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert!(!prop(&s, a, "transform/position").is_animated() && !prop(&s, b, "transform/position").is_animated());
|
||
|
||
// A scrub moves both by the same change (merged into one step while it continues).
|
||
let (pa, pb) = (pos(&s, a), pos(&s, b));
|
||
for k in 1..=3 {
|
||
let v = [pa[0] + 5.0 * k as f64, pa[1]];
|
||
s.execute("prop.set", json!({"layer": a, "prop": uid, "value": v, "selected": true, "offset": true, "merge": "scrub-1"})).unwrap();
|
||
}
|
||
assert_eq!(pos(&s, a)[..2], [pa[0] + 15.0, pa[1]]);
|
||
assert_eq!(pos(&s, b)[..2], [pb[0] + 15.0, pb[1]]);
|
||
assert_eq!(s.history.undo.len(), undo + 1, "one undo step for the scrub");
|
||
// A typed value sets them all.
|
||
s.execute("prop.set", json!({"layer": a, "path": "transform/opacity", "value": 40, "selected": true})).unwrap();
|
||
assert_eq!(prop(&s, b, "transform/opacity").value.as_f64(), 40.0);
|
||
assert_eq!(prop(&s, c, "transform/opacity").value.as_f64(), 100.0);
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert_eq!(prop(&s, a, "transform/opacity").value.as_f64(), 100.0);
|
||
assert_eq!(prop(&s, b, "transform/opacity").value.as_f64(), 100.0);
|
||
|
||
// The keyframe button adds a key on each selected layer.
|
||
s.execute("prop.toggleKey", json!({"layer": a, "path": "transform/scale", "selected": true})).unwrap();
|
||
assert_eq!(prop(&s, a, "transform/scale").keys.len(), 1);
|
||
assert_eq!(prop(&s, b, "transform/scale").keys.len(), 1);
|
||
// Without `selected` only the given layer changes.
|
||
s.execute("prop.set", json!({"layer": a, "path": "transform/rotation", "value": 30})).unwrap();
|
||
assert_eq!(prop(&s, b, "transform/rotation").value.as_f64(), 0.0);
|
||
}
|
||
|
||
/// #770: Proportional Scrubbing (After Effects 26.2, Ctrl+Alt / Cmd+Opt scrub). The change is
|
||
/// spread over the selected layers by selection order (not stacking order): the first keeps its
|
||
/// value, the last takes all of it, the one between half; whichever layer is scrubbed. One undo
|
||
/// step; a keyframed property gets a key at the current time, the unchanged first layer none.
|
||
#[test]
|
||
fn proportional_scrub_spreads_the_change_by_selection_order() {
|
||
let (mut s, a) = setup();
|
||
let b = s.execute("layer.newSolid", json!({"color": "#ff0000", "width": 50, "height": 50})).unwrap()["layer"].as_u64().unwrap();
|
||
let c = s.execute("layer.newSolid", json!({"color": "#00ff00", "width": 50, "height": 50})).unwrap()["layer"].as_u64().unwrap();
|
||
s.execute("prop.set", json!({"layer": b, "path": "transform/rotation", "value": 20})).unwrap();
|
||
// Selection order c, a, b.
|
||
s.execute("layer.select", json!({"layers": [c]})).unwrap();
|
||
s.execute("layer.select", json!({"layers": [a], "add": true})).unwrap();
|
||
s.execute("layer.select", json!({"layers": [b], "toggle": true})).unwrap();
|
||
let rot = |s: &Session, l: u64| prop(s, l, "transform/rotation").value.as_f64();
|
||
let uid = prop(&s, a, "transform/rotation").uid;
|
||
|
||
// Scrub layer a (the middle one) by +10 a frame, three frames: the UI sends a's shown value
|
||
// plus the drag.
|
||
let undo = s.history.undo.len();
|
||
for _ in 0..3 {
|
||
let v = rot(&s, a) + 10.0;
|
||
s.execute("prop.set", json!({"layer": a, "prop": uid, "value": v, "selected": true, "offset": true, "proportional": true, "merge": "scrub-r"}))
|
||
.unwrap();
|
||
}
|
||
assert_eq!(rot(&s, c), 0.0, "the first selected layer keeps its value");
|
||
assert_eq!(rot(&s, a), 15.0, "the middle one moves by half");
|
||
assert_eq!(rot(&s, b), 50.0, "the last one moves by the whole change");
|
||
assert_eq!(s.history.undo.len(), undo + 1, "one undo step for the scrub");
|
||
s.execute("edit.undo", json!({})).unwrap();
|
||
assert_eq!((rot(&s, c), rot(&s, a), rot(&s, b)), (0.0, 0.0, 20.0));
|
||
|
||
// Vectors and keyframes: Position animated on every layer, scrubbed on the last layer at 1 s.
|
||
for l in [a, b, c] {
|
||
s.execute("prop.set", json!({"layer": l, "path": "transform/position", "value": [100, 100], "time": 0.0})).unwrap();
|
||
s.execute("prop.toggleAnimation", json!({"layer": l, "path": "transform/position"})).unwrap();
|
||
}
|
||
s.execute("time.set", json!({"time": 1.0})).unwrap();
|
||
let pos_uid = prop(&s, b, "transform/position").uid;
|
||
s.execute("prop.set", json!({"layer": b, "prop": pos_uid, "value": [140, 80], "selected": true, "offset": true, "proportional": true})).unwrap();
|
||
let at1 = |s: &Session, l: u64| {
|
||
let p = prop(s, l, "transform/position");
|
||
(p.keys.len(), p.value_at(effectcraft_time::Tick::from_seconds_f64(1.0)).components()[..2].to_vec())
|
||
};
|
||
assert_eq!(at1(&s, c), (1, vec![100.0, 100.0]), "no key on the first selected layer");
|
||
assert_eq!(at1(&s, a), (2, vec![120.0, 90.0]));
|
||
assert_eq!(at1(&s, b), (2, vec![140.0, 80.0]));
|
||
|
||
// Without `proportional` a scrub still moves them all by the same change.
|
||
s.execute("prop.set", json!({"layer": a, "prop": uid, "value": 5, "selected": true, "offset": true})).unwrap();
|
||
assert_eq!((rot(&s, c), rot(&s, a), rot(&s, b)), (5.0, 5.0, 25.0));
|
||
}
|
||
|
||
#[test]
|
||
fn proportional_share_is_linear_in_selection_order() {
|
||
use crate::commands::prop::proportional_share;
|
||
assert_eq!((0..5).map(|i| proportional_share(i, 5)).collect::<Vec<_>>(), [0.0, 0.25, 0.5, 0.75, 1.0]);
|
||
// One layer (or a bad count) takes the whole change; an index past the end the last share.
|
||
assert_eq!(proportional_share(0, 1), 1.0);
|
||
assert_eq!(proportional_share(0, 0), 1.0);
|
||
assert_eq!(proportional_share(usize::MAX, 3), 1.0);
|
||
}
|
||
|
||
#[test]
|
||
fn add_item_keeps_footage_longer_than_the_comp_at_full_length() {
|
||
let mut s = Session::default();
|
||
s.execute("comp.new", json!({"name": "T", "width": 400, "height": 300, "frameRate": 30, "duration": 4})).unwrap();
|
||
let f = effectcraft_project::Footage {
|
||
width: 100,
|
||
height: 100,
|
||
has_video: true,
|
||
duration: effectcraft_time::Tick::from_seconds_f64(10.0),
|
||
..Default::default()
|
||
};
|
||
let item = std::sync::Arc::make_mut(&mut s.project).add_item("long.mp4", effectcraft_color::Label::None, None, effectcraft_project::ItemKind::Footage(f));
|
||
let l = s.execute("layer.addItem", json!({"item": item.0})).unwrap()["layer"].as_u64().unwrap();
|
||
let layer = s.active_comp().unwrap().layer(effectcraft_project::LayerId(l)).unwrap();
|
||
assert_eq!(layer.out_point.seconds(), 10.0);
|
||
}
|