Skip to content

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

Keyframes: moving keys keeps the selection order

tylerjenningsw7643f803e0f4
diff --git a/crates/engine/src/commands/prop.rs b/crates/engine/src/commands/prop.rs
index 64c166fd5..903f9e131 100644
--- a/crates/engine/src/commands/prop.rs
+++ b/crates/engine/src/commands/prop.rs
@@ -862,17 +862,78 @@ pub(crate) fn edit_keys(s: &mut Session, label: &str, merge: Option<&str>, f: im
})
}
+/// The keys a key drag's step applies to, the drag's total and the project as it was before the
+/// drag. Steps of one drag (one `merge` key) start again from the keys as they were then, so a key
+/// passed over survives; `d` adds to the drag's total, or is that total (`absolute`).
+pub(crate) fn key_gesture(
+ s: &Session,
+ merge: Option<&str>,
+ d: Tick,
+ absolute: bool,
+) -> (Vec<KeyRef>, Tick, Option<std::sync::Arc<effectcraft_project::Project>>) {
+ let gesture = merge.is_some_and(|m| s.history.merge_key.as_deref() == Some(m)) && s.key_move.as_ref().map(|g| g.merge.as_str()) == merge;
+ match (&s.key_move, s.history.undo.last()) {
+ (Some(g), Some((_, base))) if gesture => (g.from.clone(), if absolute { d } else { g.total + d }, Some(base.clone())),
+ _ => (s.state.selected_keys.clone(), d, None),
+ }
+}
+
+/// Move keys `from` to the layer times `to` gives (from a key's layer and layer time). A key
+/// landing on another key of its property replaces it, roving keys follow their neighbours and
+/// keys of locked layers stay. Returns the keys' new references in `from`'s order: the selection
+/// keeps the order it was made in.
+pub(crate) fn move_key_refs(comp: &mut effectcraft_project::Comp, from: &[KeyRef], to: impl Fn(&Layer, Tick) -> Result<Tick>) -> Result<Vec<KeyRef>> {
+ let mut remapped: std::collections::HashMap<KeyRef, KeyRef> = Default::default();
+ let mut groups: std::collections::BTreeMap<(LayerId, Uid), Vec<Tick>> = Default::default();
+ for k in from {
+ groups.entry((k.layer, k.prop)).or_default().push(k.time);
+ }
+ for ((lid, uid), times) in groups {
+ let Some(l) = comp.layer_mut(lid) else { continue };
+ let at = |time| KeyRef { layer: lid, prop: uid, time };
+ if l.switches.locked {
+ remapped.extend(times.iter().map(|t| (at(*t), at(*t))));
+ continue;
+ }
+ let moves: Vec<(Tick, Tick)> = times.iter().map(|t| Ok((*t, to(l, *t)?))).collect::<Result<_>>()?;
+ let Some(pr) = l.props.find_mut(uid) else { continue };
+ // Take the moving keys out, then put them back at their new times.
+ let mut moved = vec![];
+ for (old, new) in &moves {
+ if let Some(i) = key_at(&pr.keys, *old) {
+ let mut k = pr.keys.remove(i);
+ k.time = *new;
+ moved.push((*old, k));
+ }
+ }
+ // Target time -> the key's time before the move.
+ let mut targets: std::collections::HashMap<Tick, Tick> = Default::default();
+ for (old, k) in moved {
+ targets.insert(k.time, old);
+ match pr.keys.binary_search_by(|x| x.time.cmp(&k.time)) {
+ Ok(j) => pr.keys[j] = k,
+ Err(j) => pr.keys.insert(j, k),
+ }
+ }
+ // Resolve stored indices before roving keys change their times.
+ let tracked: Vec<(Tick, usize)> = targets.into_iter().filter_map(|(t, old)| key_at(&pr.keys, t).map(|i| (old, i))).collect();
+ effectcraft_keyframe::retime_roving(&mut pr.keys, pr.spatial);
+ for (old, i) in tracked {
+ if let Some(key) = pr.keys.get(i) {
+ remapped.insert(at(old), at(key.time));
+ }
+ }
+ }
+ let mut seen = std::collections::HashSet::new();
+ Ok(from.iter().filter_map(|k| remapped.get(k).copied()).filter(|k| seen.insert(*k)).collect())
+}
+
/// Move the selected keys by `d` comp seconds, snapped to the comp's frames in comp time (keys
/// of time-stretched layers move with the pointer, not by the layer-time distance). Keys of
/// locked layers stay. A key landing on another key of its property replaces it.
pub(crate) fn shift_keys(s: &mut Session, label: &str, merge: Option<&str>, d: Tick) -> Result<Value> {
let cid = s.active_comp_id().ok_or(EngineError::NoComp)?;
- // A drag (steps with one merge key) starts again from the keys before it each step.
- let gesture = merge.is_some_and(|m| s.history.merge_key.as_deref() == Some(m)) && s.key_move.as_ref().map(|g| g.merge.as_str()) == merge;
- let (from, total, base) = match (&s.key_move, s.history.undo.last()) {
- (Some(g), Some((_, base))) if gesture => (g.from.clone(), g.total + d, Some(base.clone())),
- _ => (s.state.selected_keys.clone(), d, None),
- };
+ let (from, total, base) = key_gesture(s, merge, d, false);
s.key_move = merge.map(|m| crate::KeyMove { merge: m.to_string(), from: from.clone(), total });
s.edit(label, merge, |proj, st| {
if let Some(b) = base {
@@ -880,47 +941,7 @@ pub(crate) fn shift_keys(s: &mut Session, label: &str, merge: Option<&str>, d: T
}
let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;
let fr = comp.frame_rate;
- let mut groups: std::collections::BTreeMap<(LayerId, Uid), Vec<Tick>> = Default::default();
- for k in &from {
- groups.entry((k.layer, k.prop)).or_default().push(k.time);
- }
- let mut sel = vec![];
- for ((lid, uid), times) in groups {
- let Some(l) = comp.layer_mut(lid) else { continue };
- let to = |t: Tick| l.layer_time(fr.snap_nearest(l.comp_time(t) + total));
- let moves: Vec<(Tick, Tick)> = times.iter().map(|t| (*t, to(*t))).collect();
- if l.switches.locked {
- sel.extend(times.iter().map(|t| KeyRef { layer: lid, prop: uid, time: *t }));
- continue;
- }
- let Some(pr) = l.props.find_mut(uid) else { continue };
- // Take the moving keys out, then put them back at their new times.
- let mut moved = vec![];
- for (old, new) in &moves {
- if let Some(i) = key_at(&pr.keys, *old) {
- let mut k = pr.keys.remove(i);
- k.time = *new;
- moved.push(k);
- }
- }
- for k in moved {
- sel.push(KeyRef { layer: lid, prop: uid, time: k.time });
- match pr.keys.binary_search_by(|x| x.time.cmp(&k.time)) {
- Ok(j) => pr.keys[j] = k,
- Err(j) => pr.keys.insert(j, k),
- }
- }
- // Roving keys follow their neighbours: keep the selection on them.
- let before: Vec<Tick> = pr.keys.iter().map(|k| k.time).collect();
- if effectcraft_keyframe::retime_roving(&mut pr.keys, pr.spatial) {
- for r in sel.iter_mut().filter(|r| r.layer == lid && r.prop == uid) {
- if let Some(i) = before.iter().position(|t| *t == r.time) {
- r.time = pr.keys[i].time;
- }
- }
- }
- }
- st.selected_keys = sel;
+ st.selected_keys = move_key_refs(comp, &from, |l, t| Ok(l.layer_time(fr.snap_nearest(l.comp_time(t) + total))))?;
Ok(json!(st.selected_keys.len()))
})
}
diff --git a/crates/engine/src/tests_key_metadata_order.rs b/crates/engine/src/tests_key_metadata_order.rs
index fe2337c2c..18d4a1a9c 100644
--- a/crates/engine/src/tests_key_metadata_order.rs
+++ b/crates/engine/src/tests_key_metadata_order.rs
@@ -111,3 +111,16 @@ fn attribute_edit_deduplicates_legacy_refs_and_drops_stale_refs_without_snapping
let opacity = s.active_comp().unwrap().layer(LayerId(layer)).unwrap().props.find(prop).unwrap();
assert!(opacity.keys.iter().all(|k| k.out_interp == Interp::Linear));
}
+
+#[test]
+fn moving_keys_keeps_the_selection_order() {
+ let (mut s, first) = setup();
+ let second = s.execute_checked("layer.newSolid", json!({"name": "Other", "color": "#fff"})).unwrap()["layer"].as_u64().unwrap();
+ for layer in [first, second] {
+ add(&mut s, layer, "transform/opacity", 0, json!(0));
+ }
+ let (a, b) = (uid(&s, first, "transform/opacity"), uid(&s, second, "transform/opacity"));
+ s.execute_checked("keys.select", json!({"keys": [{"layer": second, "prop": b, "time": 0}, {"layer": first, "prop": a, "time": 0}]})).unwrap();
+ s.execute_checked("keys.move", json!({"delta": 2.0 / 30.0})).unwrap();
+ assert_eq!(s.state.selected_keys, vec![key(second, b, 2), key(first, a, 2)], "not sorted by layer");
+}