Skip to content

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

Timeline: selected nulls get no track matte (#1260)

tylerjenningsw987faa0b20c4
diff --git a/crates/ui-egui/src/panels/timeline.rs b/crates/ui-egui/src/panels/timeline.rs
index f2d91fa3d..49da29181 100644
--- a/crates/ui-egui/src/panels/timeline.rs
+++ b/crates/ui-egui/src/panels/timeline.rs
@@ -178,6 +178,12 @@ fn edited_layers(layer: LayerId, selected: &[LayerId]) -> Vec<u64> {
if selected.contains(&layer) { selected.iter().map(|l| l.0).collect() } else { vec![layer.0] }
}
+/// The layers a Track Matte edit on `layer`'s row applies to: [`edited_layers`] that can have a
+/// matte. Selected nulls, cameras and lights (no Track Matte on their rows) are left out.
+fn matte_layers(comp: &Comp, layer: LayerId, selected: &[LayerId]) -> Vec<u64> {
+ edited_layers(layer, selected).into_iter().filter(|l| comp.layer(LayerId(*l)).is_some_and(|l| l.source.is_av())).collect()
+}
+
/// A pick whip at `rect`: dragging it starts a pick whip of `kind` from `layer`'s `prop` (0 for
/// the layer's own), drawn and dropped at the end of [`show`].
#[allow(clippy::too_many_arguments)]
@@ -196,7 +202,11 @@ fn pick_whip(
app.auto.add(auto, rect, label);
if resp.drag_started() {
let state: PickWhip = (kind, layer, prop, rect.center());
- let layers = edited_layers(LayerId(layer), &app.session.state.selected_layers);
+ let selected = &app.session.state.selected_layers;
+ let layers = match (kind, app.session.active_comp()) {
+ (WHIP_MATTE, Some(comp)) => matte_layers(comp, LayerId(layer), selected),
+ _ => edited_layers(LayerId(layer), selected),
+ };
ui.ctx().data_mut(|d| {
d.insert_temp(pick_whip_id(), state);
d.insert_temp(whip_layers_id(), layers);
@@ -2208,7 +2218,7 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {
let current = layer.track_matte.and_then(|m| opts.iter().position(|o| o == m.kind.label()));
if let Some(i) = widgets::popup_menu(ui, pop, mr.left_bottom(), &opts, current) {
let ids: Vec<LayerId> = candidates.iter().map(|l| l.id).collect();
- if let Some(a) = opts.get(i).and_then(|o| track_matte_pick(&edited_layers(layer.id, &selected), &ids, i, o)) {
+ if let Some(a) = opts.get(i).and_then(|o| track_matte_pick(&matte_layers(&comp, layer.id, &selected), &ids, i, o)) {
actions.push(a);
}
}
diff --git a/crates/ui-egui/tests/ui_batch_links.rs b/crates/ui-egui/tests/ui_batch_links.rs
index 3836c8143..ce5845faa 100644
--- a/crates/ui-egui/tests/ui_batch_links.rs
+++ b/crates/ui-egui/tests/ui_batch_links.rs
@@ -152,3 +152,54 @@ fn track_matte_menu_and_pick_whip_set_the_selected_layers_mattes() {
whip(&mut h, &format!("timeline.layer.{c}.trackMattePickWhip"), x);
assert_eq!([matte(&h, a), matte(&h, c)], [Some((y, MatteKind::Alpha)), Some((x, MatteKind::Alpha))]);
}
+
+fn video(h: &Harness<'_, EffectcraftApp>, id: u64) -> bool {
+ h.state().session.active_comp().unwrap().layer(LayerId(id)).unwrap().switches.video
+}
+
+/// A selected layer locked with its Lock switch stays selected, and keeps its parent, its
+/// transform and its matte while another selected row's menus and pick whips change the rest.
+#[test]
+fn locked_selected_layers_keep_their_parent_and_matte() {
+ let (mut h, [a, b, c, _, x, _]) = harness();
+ select(&mut h, &[a, b]);
+ let at = rect(&h, &format!("timeline.layer.{b}.lock")).center();
+ click(&mut h, at);
+ let selected: Vec<u64> = h.state().session.state.selected_layers.iter().map(|l| l.0).collect();
+ assert!(h.state().session.active_comp().unwrap().layer(LayerId(b)).unwrap().switches.locked && selected == vec![a, b], "{selected:?}");
+ let b_position = position(&h, b);
+ choose(&mut h, &format!("timeline.layer.{a}.parent"), "3. P");
+ whip(&mut h, &format!("timeline.layer.{a}.pickWhip"), c);
+ choose(&mut h, &format!("timeline.layer.{a}.trackMatte"), "1. Y");
+ whip(&mut h, &format!("timeline.layer.{a}.trackMattePickWhip"), x);
+ assert_eq!((parent(&h, a), matte(&h, a)), (Some(c), Some((x, MatteKind::Alpha))), "A changed each time");
+ assert_eq!((parent(&h, b), matte(&h, b), position(&h, b)), (None, None, b_position), "locked B didn't");
+}
+
+/// Selected nulls (no Track Matte on their rows) get no matte from another row's menu or pick
+/// whip: at the top of the comp one used to refuse the whole mode change (nothing above it to
+/// take as a matte), at the bottom it took the layer above as its matte and hid it.
+#[test]
+fn selected_nulls_get_no_matte() {
+ let (mut h, [a, b, _, _, x, y]) = harness();
+ h.state_mut().session.execute("layer.setTrackMatte", json!({"layers": [a, b], "matte": x, "kind": "alpha"})).unwrap();
+ let n = h.state_mut().session.execute("layer.newNull", json!({"name": "N"})).unwrap()["layer"].as_u64().unwrap();
+ select(&mut h, &[a, b, n]);
+ choose(&mut h, &format!("timeline.layer.{a}.trackMatte"), "Luma Matte");
+ assert_eq!([matte(&h, a), matte(&h, b), matte(&h, n)], [Some((x, MatteKind::Luma)), Some((x, MatteKind::Luma)), None], "a null on top");
+ h.state_mut().session.execute("layer.arrange", json!({"layers": [n], "to": "back"})).unwrap();
+ select(&mut h, &[a, b, n]);
+ choose(&mut h, &format!("timeline.layer.{a}.trackMatte"), "Alpha Inverted Matte");
+ assert_eq!(
+ [matte(&h, a), matte(&h, b), matte(&h, n)],
+ [Some((x, MatteKind::AlphaInverted)), Some((x, MatteKind::AlphaInverted)), None],
+ "a null at the bottom"
+ );
+ assert!(video(&h, a), "A wasn't hidden as the null's matte");
+ whip(&mut h, &format!("timeline.layer.{a}.trackMattePickWhip"), y);
+ assert_eq!(
+ [matte(&h, a), matte(&h, b), matte(&h, n)],
+ [Some((y, MatteKind::AlphaInverted)), Some((y, MatteKind::AlphaInverted)), None],
+ "the pick whip too"
+ );
+}