EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Merge remote-tracking branch 'origin/main' into enhance/batch-parent-matte
tylerjenningswb1c0a2394dbb
diff --cc crates/engine/src/cmd/layer.rsindex 000000000,f6d2feb04..885518fc3mode 000000,100644..100644--- a/crates/engine/src/cmd/layer.rs+++ b/crates/engine/src/cmd/layer.rs@@@ -1,0 -1,212 +1,212 @@@+ //! Layer menu.++ use effectcraft_color::{BlendMode, Label};+ use effectcraft_keyframe::{Justify, TextDoc, Value as KV};+ use effectcraft_project::build::{self, Ids};+ use effectcraft_project::{+ Comp, FootageKind, FrameBlend, GroupKind, ItemId, ItemKind, Layer, LayerId, LayerSource, MaskMode, MatteKind, Node, Project, PropGroup, Quality, Solid,+ TrackMatte, limits,+ };+ use effectcraft_time::Tick;+ use serde_json::{Value, json};++ use super::{CommandSpec, b_p, bad, comp_id, f_p, has_comp, has_layers, layer_mut, layer_p, layers_p, merge_p, resolve_layer, str_p, unlocked};+ use crate::{EngineError, Result, Session, cmd};++ mod contents;+ mod create;+ mod parent;+ mod replace;+ mod select;+ mod switches;+ mod timing;+ mod transform;++ use contents::{add_mask, add_shape_item, mask_props, set_text};+ use create::{add_item, new_adjustment, new_null, new_shape, new_solid, new_text};+ pub(crate) use create::{color_p, index_p, insert_layer, insert_layer_at, place, position_p};+ pub(crate) use parent::parent_fixes;+ use parent::set_parent;+ use replace::{has_replace_source, replace_source};+ use select::{select, select_next, select_prev, select_step};+ use switches::{blend, rename, set_comment, set_switch, track_matte};+ use timing::{arrange, move_frames, precompose, slip, timing};+ use transform::{has_layer_settings, layer_settings, transform_op};+ pub(crate) use transform::{offset_position, transform_default, update_position};++ /// `p` with `key` set.+ fn with(p: &Value, key: &str, v: Value) -> Value {+ let mut p = if p.is_object() { p.clone() } else { json!({}) };+ p[key] = v;+ p+ }++ pub fn specs() -> Vec<CommandSpec> {+ vec![+ cmd!(+ "layer.newText",+ "Text",+ ["Layer", "New"],+ Some("Cmd+Alt+Shift+T"),+ "{text?, name? (layer name; default the text), position? [x,y], box? [x,y,w,h] (paragraph text, comp space), vertical?, edit? (start editing), font?, style?, size?, fill?, stroke?, applyFill?, applyStroke?, strokeWidth?, tracking?, leading?, baselineShift?, hScale?, vScale?, tsume?, fauxBold?, fauxItalic?, allCaps?, smallCaps?, baseline?, superscript?, subscript?, kerning?, ligatures?, justify?, indentLeft?, indentRight?, indentFirst?, spaceBefore?, spaceAfter?, direction?, composer?, hangingPunctuation?, strokeOverFill?} (attributes as layer.setText)",+ has_comp,+ new_text+ ),+ cmd!("layer.newSolid", "Solid...", ["Layer", "New"], Some("Cmd+Y"), "{name?, color? #hex|[r,g,b], width?, height?, pixelAspect?}", has_comp, new_solid),+ cmd!("layer.newNull", "Null Object", ["Layer", "New"], Some("Cmd+Alt+Shift+Y"), "{name?}", has_comp, new_null),+ cmd!(+ "layer.newShape",+ "Shape Layer",+ ["Layer", "New"],+ None,+ "{kind?: rect|rounded|ellipse|star|polygon|none, name?, size?, fill?, fillType?, fillBlend?, fillOpacity?, stroke?, strokeType?, strokeBlend?, strokeOpacity?, strokeWidth?, position?}",+ has_comp,+ new_shape+ ),+ cmd!("layer.newAdjustment", "Adjustment Layer", ["Layer", "New"], Some("Cmd+Alt+Y"), "{name?}", has_comp, new_adjustment),+ cmd!(+ "layer.settings",+ "Layer Settings...",+ ["Layer"],+ Some("Cmd+Shift+Y"),+ "{layer?, name?, color?, width?, height?, pixelAspect?, affectAll?: bool (default true; false gives this layer its own copy of a solid other layers use)} → {layer, solid?}",+ has_layer_settings,+ layer_settings+ ),+ cmd!(+ "layer.addItem",+ "Add Footage to Comp",+ ["File"],+ Some("Cmd+/"),+ "{item: id|name, time? (s, the In point), index? (1-based stack position; default above the selected layer), position? ([x, y] comp px; default the centre), duration? (s, for a still)}",+ has_comp,+ add_item+ ),+ cmd!(+ "layer.replaceSource",+ "Replace Layer Source",+ [],+ Some("Cmd+Alt+/"),+ "{comp?, layers?, layer?, item?: id|name (default the Project panel selection), fixExpressions?: bool (accepted for After Effects compatibility)} → {layers, item}",+ has_replace_source,+ replace_source+ ),+ cmd!("layer.select", "Select Layers", [], None, "{layers: [id|name|#n], add?, toggle?}", has_comp, select),+ cmd!("layer.selectNext", "Select Next Layer", [], Some("Cmd+ArrowDown"), "{add?}", has_comp, select_next),+ cmd!("layer.selectPrevious", "Select Previous Layer", [], Some("Cmd+ArrowUp"), "{add?}", has_comp, select_prev),+ cmd!("layer.extendSelectionNext", "Extend Selection to Next Layer", [], Some("Cmd+Shift+ArrowDown"), "{}", has_comp, |s, _| select_step(+ s,+ &json!({"add": true}),+ 1+ )),+ cmd!("layer.extendSelectionPrevious", "Extend Selection to Previous Layer", [], Some("Cmd+Shift+ArrowUp"), "{}", has_comp, |s, _| select_step(+ s,+ &json!({"add": true}),+ -1+ )),+ cmd!(+ "layer.setSwitch",+ "Layer Switch",+ [],+ None,+ "{layers?, switch: video|audio|solo|lock|shy|collapse|quality|fx|frameBlend|motionBlur|adjustment|threeD|guide|preserveTransparency, value?, merge?, others? (the named layers alone: the other layers get the opposite state, or come back)}",+ has_layers,+ set_switch+ ),+ cmd!("layer.rename", "Rename", [], Some("Enter"), "{layer?, name}", has_layers, rename),+ cmd!("layer.setComment", "Layer Comment", [], None, "{layers?, comment}", has_layers, set_comment),+ cmd!("layer.setBlendMode", "Blending Mode", [], None, "{layers?, mode?: Normal|Multiply|Screen|…, step?: ±1}", has_layers, blend),+ cmd!(+ "layer.setTrackMatte",+ "Track Matte",+ [],+ None,- "{layer?, matte: layer|null, kind?: alpha|alphaInverted|luma|lumaInverted}",++ "{layers? | layer?, matte: layer|null, kind?: alpha|alphaInverted|luma|lumaInverted|preserve}",+ has_layers,+ track_matte+ ),+ cmd!("layer.setParent", "Parent", [], None, "{layers?, parent: layer|null, compensate?: bool}", has_layers, set_parent),+ cmd!(+ "layer.timing",+ "Layer Timing",+ [],+ None,+ "{layers?, op?: moveInToTime|moveOutToTime|moveInToStart|moveOutToEnd|trimInToTime|trimOutToTime, delta?, start?, in?, out?, inDelta?, outDelta? (seconds, per layer), merge?}",+ has_layers,+ timing+ ),+ cmd!("layer.moveInToStart", "Move Layer In Point to Beginning of Comp", [], Some("Alt+Home"), "{layers?}", has_layers, |s, p| timing(+ s,+ &with(p, "op", json!("moveInToStart"))+ )),+ cmd!("layer.moveOutToEnd", "Move Layer Out Point to End of Comp", [], Some("Alt+End"), "{layers?}", has_layers, |s, p| timing(+ s,+ &with(p, "op", json!("moveOutToEnd"))+ )),+ cmd!("layer.moveEarlier", "Move Layers 1 Frame Earlier", [], Some("Alt+PageUp"), "{layers?}", has_layers, |s, p| move_frames(s, p, -1)),+ cmd!("layer.moveLater", "Move Layers 1 Frame Later", [], Some("Alt+PageDown"), "{layers?}", has_layers, |s, p| move_frames(s, p, 1)),+ cmd!("layer.moveEarlier10", "Move Layers 10 Frames Earlier", [], Some("Alt+Shift+PageUp"), "{layers?}", has_layers, |s, p| move_frames(s, p, -10)),+ cmd!("layer.moveLater10", "Move Layers 10 Frames Later", [], Some("Alt+Shift+PageDown"), "{layers?}", has_layers, |s, p| move_frames(s, p, 10)),+ cmd!("layer.slip", "Slip Edit", [], None, "{layers?, delta? (seconds) | frames?, merge?}", has_layers, slip),+ cmd!("layer.slipBack", "Slip Edit 1 Frame Earlier", [], None, "{layers?}", has_layers, |s, p| {+ let mut p = p.clone();+ p["frames"] = json!(-1);+ slip(s, &p)+ }),+ cmd!("layer.slipForward", "Slip Edit 1 Frame Later", [], None, "{layers?}", has_layers, |s, p| {+ let mut p = p.clone();+ p["frames"] = json!(1);+ slip(s, &p)+ }),+ cmd!("layer.arrange", "Arrange", ["Layer", "Arrange"], None, "{layers?, to: front|forward|backward|back, index?, above?: layer}", has_layers, arrange),+ cmd!(+ "layer.precompose",+ "Pre-compose...",+ ["Layer"],+ Some("Cmd+Shift+C"),+ "{layers?, name?, mode?: move|leave, adjustDuration?, open?}",+ has_layers,+ precompose+ ),+ cmd!(+ "layer.addMask",+ "New Mask",+ ["Layer", "Mask"],+ Some("Cmd+Shift+N"),+ "{layer?, shape?: rect|ellipse|rounded|polygon|star, rect? [x,y,w,h] (layer space; a polygon or star fits its width), mode?}",+ has_layers,+ add_mask+ ),+ cmd!("layer.setMask", "Mask Mode", [], None, "{layer?, mask: index|uid|name, mode?, inverted?}", has_layers, mask_props),+ cmd!(+ "layer.addShapeItem",+ "Add (Shape)",+ [],+ None,+ "{layer?, kind: group|rect|ellipse|star|polygon|path|fill|stroke|gfill|gstroke|trim|repeater|round|offset|pucker|twist|zigzag|wiggle|merge|frontColor|bevelColor|sideColor|backColor, group?: uid|path} → {uid, path} (frontColor…backColor: the group's Front / Bevel / Side / Back item, which colours that surface of every extruded paint in the group in Advanced 3D)",+ has_layers,+ add_shape_item+ ),+ cmd!(+ "layer.setText",+ "Edit Text",+ [],+ None,+ "{layer?, range?: [start, end] (characters; default all), text?, font?, style?, size?, fill?, stroke?, applyFill?, applyStroke?, strokeWidth?, tracking?, leading?: px|\"auto\", baselineShift? px, hScale? %, vScale? %, tsume? %, fauxBold?, fauxItalic?, allCaps?, smallCaps?, baseline?: normal|superscript|subscript, superscript?, subscript?, kerning?: metrics|optical|number, ligatures?, discretionaryLigatures? (OpenType), contextualAlternates?, stylisticAlternates?, stylisticSets?: [1–20], ss01?, ss02?, ss03?, ss04?, ss05?, ss06?, ss07?, ss08?, ss09?, ss10?, ss11?, ss12?, ss13?, ss14?, ss15?, ss16?, ss17?, ss18?, ss19?, ss20?, swash?, titling?, ordinals?, fractions?, allSmallCaps?, figureStyle?: default|lining|oldStyle, figureWidth?: default|proportional|tabular, figures?, variations?: {tag: value} (variable font axes; null resets), justify?: left|center|right|justifyLeft|justifyCenter|justifyRight|justifyAll, indentLeft?, indentRight?, indentFirst?, spaceBefore?, spaceAfter?, direction?: ltr|rtl, composer?: everyLine|singleLine, hangingPunctuation?, strokeOverFill?, box?: [x,y,w,h]|null (layer space), vertical?}",+ has_layers,+ set_text+ ),+ cmd!(+ "layer.transform",+ "Transform",+ ["Layer", "Transform"],+ None,+ "{layers?, op: reset|center|fit|fitWidth|fitHeight|flipH|flipV}",+ has_layers,+ transform_op+ ),+ ]+ }++ #[allow(dead_code)]+ fn unused(_: &Comp) {}diff --cc crates/engine/src/cmd/layer/parent.rsindex 000000000,8565cbbb1..798702266mode 000000,100644..100644--- a/crates/engine/src/cmd/layer/parent.rs+++ b/crates/engine/src/cmd/layer/parent.rs@@@ -1,0 -1,452 +1,454 @@@+ use super::*;++ /// Re-express a layer in its new parent space without moving its anchor.+ pub(crate) struct ParentFix {+ pub layer: LayerId,+ /// Maps Position from the old parent's space into the new one's.+ m: effectcraft_geom::Mat3,+ /// Added to Rotation.+ rotation: f64,+ /// Multiply Scale.+ scale: [f64; 2],+ /// 3D AV layers retain their world-space anchor, including Z.+ position_3d: Option<effectcraft_geom::Mat4>,+ /// A uniform relative parent transform can preserve static Orientation and Scale.+ pose_3d: Option<([f64; 3], f64)>,+ }++ impl ParentFix {+ /// Re-express the layer's Position, Rotation and Scale (every key) in the new parent's space.+ pub fn apply(&self, l: &mut Layer) {+ let Some(tr) = l.props.sub_mut("transform") else { return };+ if let Some(m) = self.position_3d {+ // Spatial Position speed measures distance along its path. Its parent-space+ // unit changes even when the child's Orientation cannot be re-expressed.+ let position_speed = uniform_parent_pose(m, [0.0; 3]).map(|(_, factor)| factor.abs());+ let map_position = |v: &KV| {+ let q = m.apply(effectcraft_geom::Vec3::from(v.as_vec3()));+ KV::Vec3([q.x, q.y, q.z])+ };+ // Read all separated axes before writing any of them.+ let names = ["positionX", "positionY", "positionZ"];+ if tr.get("positionX").is_some() {+ let axes = names.map(|name| tr.get(name).cloned());+ let current = axes.each_ref().map(|pr| pr.as_ref().map(|pr| pr.value.as_f64()).unwrap_or(0.0));+ let q = m.apply(effectcraft_geom::Vec3::from(current));+ for (i, name) in names.into_iter().enumerate() {+ if let Some(pr) = tr.get_mut(name) {+ pr.value = KV::Scalar([q.x, q.y, q.z].get(i).copied().unwrap_or(0.0));+ for key in &mut pr.keys {+ let p = axes.each_ref().map(|axis| axis.as_ref().map(|axis| axis.value_at(key.time).as_f64()).unwrap_or(0.0));+ let q = m.apply(effectcraft_geom::Vec3::from(p));+ key.value = KV::Scalar([q.x, q.y, q.z].get(i).copied().unwrap_or(0.0));+ }+ }+ }+ }+ if let Some(pr) = tr.get_mut("position") {+ pr.value = map_position(&pr.value);+ for key in &mut pr.keys {+ key.value = map_position(&key.value);+ // Spatial tangents are vectors, so the parent's translation is excluded.+ for tangent in [&mut key.spatial_in, &mut key.spatial_out] {+ let v = m.apply_vec(effectcraft_geom::Vec3::from(*tangent));+ *tangent = [v.x, v.y, v.z];+ }+ }+ if let Some(factor) = position_speed+ .filter(|_| pr.spatial)+ .filter(|factor| pr.keys.iter().flat_map(|key| key.in_ease.iter().chain(&key.out_ease)).all(|ease| (ease.speed * *factor).is_finite()))+ {+ for key in &mut pr.keys {+ for ease in key.in_ease.iter_mut().chain(&mut key.out_ease) {+ ease.speed *= factor;+ }+ }+ }+ }+ // Cameras and lights aim with Point of Interest: move it by the same parent-space+ // change, so a two-node rig keeps its world frame (#1010, #1020).+ if let Some(pr) = tr.get_mut("poi") {+ pr.value = map_position(&pr.value);+ for key in &mut pr.keys {+ key.value = map_position(&key.value);+ for tangent in [&mut key.spatial_in, &mut key.spatial_out] {+ let v = m.apply_vec(effectcraft_geom::Vec3::from(*tangent));+ *tangent = [v.x, v.y, v.z];+ }+ }+ if let Some(factor) = position_speed+ .filter(|_| pr.spatial)+ .filter(|factor| pr.keys.iter().flat_map(|key| key.in_ease.iter().chain(&key.out_ease)).all(|ease| (ease.speed * *factor).is_finite()))+ {+ for key in &mut pr.keys {+ for ease in key.in_ease.iter_mut().chain(&mut key.out_ease) {+ ease.speed *= factor;+ }+ }+ }+ }+ if let Some((orientation, factor)) = self.pose_3d {+ if let Some(pr) = tr.get_mut("orientation") {+ pr.value = KV::Vec3(orientation);+ }+ if let Some(pr) = tr.get_mut("scale") {+ let scaled = |value: &KV| KV::Vec3(value.as_vec3().map(|v| v * factor));+ pr.value = scaled(&pr.value);+ for key in &mut pr.keys {+ key.value = scaled(&key.value);+ // Scale's temporal speeds use the same units as its values.+ for ease in key.in_ease.iter_mut().chain(&mut key.out_ease) {+ ease.speed *= factor;+ }+ }+ }+ }+ return;+ }+ let map = |pr: &mut effectcraft_project::Property, f: &dyn Fn(&KV) -> KV| {+ pr.value = f(&pr.value);+ for key in &mut pr.keys {+ key.value = f(&key.value);+ }+ };+ let m = self.m;+ if tr.get("positionX").is_some() {+ // Separated dimensions: X and Y move together, key by key at the same times.+ // Everything is read before anything is written.+ let [x, y] = [tr.get("positionX"), tr.get("positionY")].map(|p| p.map(|p| p.value.as_f64()).unwrap_or(0.0));+ let q = m.apply(effectcraft_geom::vec2(x, y));+ let keys_x: Vec<(Tick, f64)> = tr.get("positionX").map(|p| p.keys.iter().map(|k| (k.time, k.value.as_f64())).collect()).unwrap_or_default();+ let keys_y: Vec<(Tick, f64)> = tr.get("positionY").map(|p| p.keys.iter().map(|k| (k.time, k.value.as_f64())).collect()).unwrap_or_default();+ let at = |keys: &[(Tick, f64)], name: &str, t: Tick, tr: &PropGroup| {+ keys.iter().find(|k| k.0 == t).map(|k| k.1).unwrap_or_else(|| tr.get(name).map(|p| p.value_at(t).as_f64()).unwrap_or(0.0))+ };+ let (xs, ys): (Vec<f64>, Vec<f64>) = (+ keys_x.iter().map(|&(t, x)| m.apply(effectcraft_geom::vec2(x, at(&keys_y, "positionY", t, tr))).x).collect(),+ keys_y.iter().map(|&(t, y)| m.apply(effectcraft_geom::vec2(at(&keys_x, "positionX", t, tr), y)).y).collect(),+ );+ for (name, value, vals) in [("positionX", q.x, xs), ("positionY", q.y, ys)] {+ if let Some(pr) = tr.get_mut(name) {+ pr.value = KV::Scalar(value);+ for (k, v) in pr.keys.iter_mut().zip(vals) {+ k.value = KV::Scalar(v);+ }+ }+ }+ } else if let Some(pr) = tr.get_mut("position") {+ map(pr, &|v| {+ let c = v.as_vec3();+ let q = m.apply(effectcraft_geom::vec2(c[0], c[1]));+ KV::Vec3([q.x, q.y, c[2]])+ });+ }+ let (dr, k) = (self.rotation, self.scale);+ if let Some(pr) = tr.get_mut("rotation") {+ map(pr, &|v| KV::Scalar(v.as_f64() + dr));+ }+ if let Some(pr) = tr.get_mut("scale") {+ map(pr, &|v| {+ let c = v.as_vec3();+ KV::Vec3([c[0] * k[0], c[1] * k[1], c[2]])+ });+ }+ }+ }++ /// A uniform factor commutes with authored axis Rotation and Scale; prepend its orthogonal+ /// rotation to static Orientation using the existing Rz * Ry * Rx order.+ fn uniform_parent_pose(m: effectcraft_geom::Mat4, orientation: [f64; 3]) -> Option<([f64; 3], f64)> {+ use effectcraft_geom::{Mat4, Vec3, vec3};+ if !orientation.iter().all(|v| v.is_finite()) {+ return None;+ }+ let a = m.0;+ let columns = [vec3(a[0][0], a[1][0], a[2][0]), vec3(a[0][1], a[1][1], a[2][1]), vec3(a[0][2], a[1][2], a[2][2])];+ let magnitude = columns[0].x.hypot(columns[0].y).hypot(columns[0].z);+ if !magnitude.is_finite() || magnitude <= 0.0 {+ return None;+ }+ let c = columns.map(|c| c / magnitude);+ if c.iter().any(|c| (c.dot(*c) - 1.0).abs() > 1e-9) || c[0].dot(c[1]).abs() > 1e-9 || c[0].dot(c[2]).abs() > 1e-9 || c[1].dot(c[2]).abs() > 1e-9 {+ return None;+ }+ let cross = vec3(c[1].y * c[2].z - c[1].z * c[2].y, c[1].z * c[2].x - c[1].x * c[2].z, c[1].x * c[2].y - c[1].y * c[2].x);+ let factor = if c[0].dot(cross) < 0.0 { -magnitude } else { magnitude };+ let mut rotation = Mat4::IDENTITY;+ for row in 0..3 {+ for col in 0..3 {+ rotation.0[row][col] = a[row][col] / factor;+ }+ }+ if (0..3).all(|row| (0..3).all(|col| (rotation.0[row][col] - if row == col { 1.0 } else { 0.0 }).abs() < 1e-12)) {+ return Some((orientation, factor));+ }+ let r = (rotation * Mat4::orientation(Vec3::from(orientation))).0;+ // atan2 rather than asin: near ±90 degrees asin loses precision, while cos(y) stays exact.+ let cy = r[0][0].hypot(r[1][0]);+ let y = (-r[2][0]).atan2(cy);+ let (x, z) = if cy > 1e-9 { (r[2][1].atan2(r[2][2]), r[1][0].atan2(r[0][0])) } else { ((-r[1][2]).atan2(r[1][1]), 0.0) };+ Some(([x.to_degrees(), y.to_degrees(), z.to_degrees()], factor))+ }++ /// A parent change retains 2D transforms and the world-space anchor of 3D layers (Position,+ /// and Point of Interest for two-node cameras and lights). Position is+ /// re-expressed in the new parent's space (`None`: the composition), evaluated at the current+ /// time.+ pub(crate) fn parent_fixes(s: &Session, cid: ItemId, ids: &[LayerId], parent: Option<LayerId>) -> Vec<ParentFix> {+ let Some(comp) = s.project.comp(cid) else { return vec![] };+ let ectx =+ effectcraft_render::EvalCtx { project: &s.project, comp_id: cid, comp, time: s.time(), expr: s.expr.as_deref(), footage: Some(s.footage.as_ref()) };+ let space = |id: Option<LayerId>| -> effectcraft_geom::Mat3 {+ id.and_then(|i| comp.layer(i)).filter(|l| !l.is_3d()).map(|l| ectx.layer_to_comp(l).0).unwrap_or(effectcraft_geom::Mat3::IDENTITY)+ };+ let decompose = |m: &effectcraft_geom::Mat3| {+ let a = m.0;+ let sx = (a[0][0] * a[0][0] + a[1][0] * a[1][0]).sqrt();+ let det = a[0][0] * a[1][1] - a[0][1] * a[1][0];+ (a[1][0].atan2(a[0][0]).to_degrees(), sx, if sx > 1e-12 { det / sx } else { 0.0 })+ };+ let new_m = space(parent);+ let Some(inv) = new_m.inverse() else { return vec![] };+ let (rn, sxn, syn) = decompose(&new_m);+ let mut fixes: Vec<_> = comp+ .layers+ .iter()+ .filter(|l| ids.contains(&l.id) && !l.is_3d() && l.parent != parent)+ .map(|l| {+ let old_m = space(l.parent);+ let (ro, sxo, syo) = decompose(&old_m);+ let scale = [if sxn.abs() > 1e-12 { sxo / sxn } else { 1.0 }, if syn.abs() > 1e-12 { syo / syn } else { 1.0 }];+ ParentFix { layer: l.id, m: inv * old_m, rotation: ro - rn, scale, position_3d: None, pose_3d: None }+ })+ .collect();+ let space_3d = |id: Option<LayerId>| {+ id.and_then(|id| comp.layer(id)).map_or(effectcraft_geom::Mat4::IDENTITY, |layer| {+ // Parent transforms do not inherit the parent's source pixel-aspect stretch.+ let world = ectx.world_matrix(layer);+ let par = ectx.par_ratio(layer);+ let a = layer.transform().map(|tr| ectx.v3(layer, tr, "anchor", [0.0; 3])).unwrap_or([0.0; 3]);+ let anchor = effectcraft_geom::vec3(a[0], a[1], if layer.is_3d() { a[2] } else { 0.0 });+ world+ * effectcraft_geom::Mat4::translate(anchor)+ * effectcraft_geom::Mat4::scale(effectcraft_geom::vec3(1.0 / par, 1.0, 1.0))+ * effectcraft_geom::Mat4::translate(-anchor)+ })+ };+ if let Some(inv) = space_3d(parent).inverse().filter(|m| m.0.iter().flatten().all(|v| v.is_finite())) {+ // Cameras and lights compensate like 3D layers (Position, and Point of Interest for+ // two-node rigs), so parenting keeps the world frame (#1010, #1020). They have no+ // Scale, so `pose_3d` below stays `None` and Orientation is kept as authored.+ for layer in comp.layers.iter().filter(|l| ids.contains(&l.id) && l.is_3d() && l.parent != parent) {+ let m = inv * space_3d(layer.parent);+ if m.0.iter().flatten().all(|v| v.is_finite()) {+ let pose_3d = layer.transform().and_then(|tr| {+ let orientation = tr.get("orientation")?;+ let scale = tr.get("scale")?;+ // Animated Euler Orientation and auto-orient cannot be re-expressed by+ // prepending a constant Euler value. Expression-driven values stay authored.+ if !orientation.keys.is_empty()+ || orientation.expr.is_some()+ || scale.expr.is_some()+ || layer.auto_orient != effectcraft_project::AutoOrient::Off+ {+ return None;+ }+ let pose = uniform_parent_pose(m, orientation.value.as_vec3())?;+ let factor = pose.1;+ let values_finite = std::iter::once(&scale.value)+ .chain(scale.keys.iter().map(|key| &key.value))+ .all(|value| value.as_vec3().iter().all(|v| (v * factor).is_finite()));+ let speeds_finite = scale.keys.iter().flat_map(|key| key.in_ease.iter().chain(&key.out_ease)).all(|ease| (ease.speed * factor).is_finite());+ (values_finite && speeds_finite).then_some(pose)+ });+ fixes.push(ParentFix { layer: layer.id, m: effectcraft_geom::Mat3::IDENTITY, rotation: 0.0, scale: [1.0; 2], position_3d: Some(m), pose_3d });+ }+ }+ }+ fixes+ }++ /// Validate the proposed ancestor chain before any authored edit, including when compensation+ /// is disabled. Bound both unique ancestors and linear lookup/selection work on loaded graphs.+ fn check_parent_chain(comp: &Comp, ids: &[LayerId], parent: Option<LayerId>, max_visits: usize, max_work: usize) -> Result<()> {+ let mut seen = std::collections::HashSet::new();+ let mut work = 0usize;+ let mut cur = parent;+ while let Some(id) = cur {+ if seen.len() >= max_visits {+ return Err(bad("layer.setParent", "parent chain exceeds the safety visit limit"));+ }+ if !seen.insert(id) {+ return Err(bad("layer.setParent", "parent chain contains an existing cycle"));+ }+ for selected in ids {+ if work >= max_work {+ return Err(bad("layer.setParent", "parent chain exceeds the safety work limit"));+ }+ work += 1;+ if *selected == id {+ return Err(bad("layer.setParent", "parenting would create a cycle"));+ }+ }+ let mut ancestor = None;+ for layer in &comp.layers {+ if work >= max_work {+ return Err(bad("layer.setParent", "parent chain exceeds the safety work limit"));+ }+ work += 1;+ if layer.id == id {+ ancestor = Some(layer);+ break;+ }+ }+ let layer = ancestor.ok_or_else(|| bad("layer.setParent", "parent chain refers to a missing layer"))?;+ cur = layer.parent;+ }+ Ok(())+ }++ pub(super) fn set_parent(s: &mut Session, p: &Value) -> Result<Value> {+ let (cid, ids) = layers_p(s, p)?;++ // Locked layers keep their parent (several at once: the others are parented).++ let ids = unlocked(s, cid, ids, "layer.setParent")?;+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;+ let parent = match p.get("parent") {+ None | Some(Value::Null) => None,+ Some(v) => Some(resolve_layer(comp, v).ok_or_else(|| bad("layer.setParent", "no such parent layer"))?),+ };+ // A loaded cycle need not include a selected child. Validate before compensation or edit;+ // do not impose the renderer's 64-ancestor truncation as a new ordinary hierarchy limit.+ check_parent_chain(comp, &ids, parent, 4096, 1_048_576)?;+ // Like AE's pick-whip, parenting keeps the layer where it is: its transform is re-expressed+ // in the new parent's space (Position, Rotation, Scale), unless `compensate: false`.+ let compensate = b_p(p, "compensate").unwrap_or(true);+ let fixes = if compensate { parent_fixes(s, cid, &ids, parent) } else { vec![] };+ s.edit("Parent", None, |proj, _| {+ let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;+ for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {+ l.parent = parent;+ if let Some(f) = fixes.iter().find(|f| f.layer == l.id) {+ f.apply(l);+ }+ }+ Ok(())+ })?;+ Ok(Value::Null)+ }++ #[cfg(test)]+ mod parent_chain_tests {+ use super::*;+ use std::sync::Arc;++ fn fixture() -> (Session, u64, u64, u64) {+ let mut s = Session::default();+ s.execute("comp.new", json!({"name":"Parent safety","width":16,"height":16,"duration":1})).unwrap();+ let a = s.execute("layer.newSolid", json!({"name":"A"})).unwrap()["layer"].as_u64().unwrap();+ let b = s.execute("layer.newSolid", json!({"name":"B"})).unwrap()["layer"].as_u64().unwrap();+ let c = s.execute("layer.newSolid", json!({"name":"C"})).unwrap()["layer"].as_u64().unwrap();+ for id in [a, b, c] {+ s.execute("prop.set", json!({"layer":id,"path":"transform/anchor","value":[0,0,0]})).unwrap();+ }+ s.execute("prop.set", json!({"layer":a,"path":"transform/position","value":[100,200,0]})).unwrap();+ s.execute("prop.set", json!({"layer":c,"path":"transform/position","value":[10,20,0]})).unwrap();+ s.history.undo.clear();+ (s, a, b, c)+ }+ fn malformed_parent(s: &mut Session, child: u64, parent: u64) {+ let cid = s.active_comp_id().unwrap();+ Arc::make_mut(&mut s.project).comp_mut(cid).unwrap().layer_mut(LayerId(child)).unwrap().parent = Some(LayerId(parent));+ }+ fn assert_atomic_error(s: &mut Session, child: u64, parent: u64, compensate: bool, message: &str) {+ let before = s.project.clone();+ let revision = s.revision;+ let undo = s.history.undo.len();+ let err = s.execute("layer.setParent", json!({"layers":[child],"parent":parent,"compensate":compensate})).unwrap_err();+ assert!(err.to_string().contains(message), "{err}");+ assert!(Arc::ptr_eq(&before, &s.project));+ assert_eq!(s.revision, revision);+ assert_eq!(s.history.undo.len(), undo);+ }+ #[test]+ fn loaded_cycle_excluding_selected_child_is_rejected_atomically() {+ for compensate in [true, false] {+ let (mut s, a, b, c) = fixture();+ // Simulate a malformed loaded project. Never execute this on the unguarded baseline.+ malformed_parent(&mut s, a, b);+ malformed_parent(&mut s, b, a);+ assert_atomic_error(&mut s, c, a, compensate, "existing cycle");+ }+ }+ #[test]+ fn dangling_loaded_parent_is_rejected_atomically() {+ for compensate in [true, false] {+ let (mut s, a, _, c) = fixture();+ malformed_parent(&mut s, a, u64::MAX);+ assert_atomic_error(&mut s, c, a, compensate, "missing layer");+ }+ }+ #[test]+ fn selected_descendant_and_direct_self_are_rejected() {+ let (mut s, a, _, c) = fixture();+ assert_atomic_error(&mut s, c, c, false, "create a cycle");+ s.execute("layer.setParent", json!({"layers":[a],"parent":c,"compensate":false})).unwrap();+ assert_atomic_error(&mut s, c, a, true, "create a cycle");+ }+ #[test]+ fn ordinary_parent_and_unparent_keep_explicit_false_and_undo_semantics() {+ for compensate in [true, false] {+ let (mut s, a, _, c) = fixture();+ let old = s.project.clone();+ let world = |s: &Session| {+ let cid = s.active_comp_id().unwrap();+ let comp = s.active_comp().unwrap();+ let ctx = effectcraft_render::EvalCtx::new(&s.project, cid, comp, s.time());+ ctx.world_matrix(comp.layer(LayerId(c)).unwrap()).apply(effectcraft_geom::Vec3::ZERO)+ };+ let before = world(&s);+ s.execute("layer.setParent", json!({"layers":[c],"parent":a,"compensate":compensate})).unwrap();+ let expected = if compensate { before } else { before + effectcraft_geom::vec3(100.0, 200.0, 0.0) };+ assert!((world(&s) - expected).length() < 1e-9);+ assert_eq!(s.active_comp().unwrap().layer(LayerId(c)).unwrap().parent, Some(LayerId(a)));+ assert_eq!(s.history.undo.len(), 1);+ let parented = s.project.clone();+ assert!(s.undo());+ assert!(Arc::ptr_eq(&s.project, &old));+ assert!(s.redo());+ assert!(Arc::ptr_eq(&s.project, &parented));+ s.execute("layer.setParent", json!({"layers":[c],"parent":null,"compensate":compensate})).unwrap();+ assert_eq!(s.active_comp().unwrap().layer(LayerId(c)).unwrap().parent, None);+ assert!(s.undo());+ assert!(Arc::ptr_eq(&s.project, &parented));+ }+ }+ #[test]+ fn ancestor_and_lookup_work_budgets_fail_closed() {+ let (mut s, a, b, c) = fixture();+ malformed_parent(&mut s, a, b);+ let comp = s.active_comp().unwrap();+ // New solids are inserted above the selection: C,B,A. Walking A->B scans+ // three then two layers, and compares the one selected child twice: seven work units.+ assert_eq!(comp.layers.iter().map(|l| l.id).collect::<Vec<_>>(), vec![LayerId(c), LayerId(b), LayerId(a)]);+ assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 2, 7).is_ok());+ assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 2, 6).unwrap_err().to_string().contains("work limit"));+ assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 2, 256).is_ok());+ assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 1, 256).unwrap_err().to_string().contains("visit limit"));+ assert!(check_parent_chain(comp, &[LayerId(c)], Some(LayerId(a)), 2, 1).unwrap_err().to_string().contains("work limit"));+ assert!(check_parent_chain(comp, &[LayerId(c)], None, 0, 0).is_ok(), "unparenting does not traverse ancestors");+ }++ #[test]+ fn well_formed_chain_beyond_renderer_depth_is_not_unnecessarily_rejected() {+ let (s, _, _, c) = fixture();+ let mut comp = s.active_comp().unwrap().clone();+ let template = comp.layers.first().unwrap().clone();+ for n in 0..80 {+ let mut layer = template.clone();+ layer.id = LayerId(10_000 + n);+ layer.parent = (n < 79).then_some(LayerId(10_001 + n));+ comp.layers.push(layer);+ }+ assert!(check_parent_chain(&comp, &[LayerId(c)], Some(LayerId(10_000)), 4096, 1_048_576).is_ok());+ }+ }diff --cc crates/engine/src/cmd/layer/switches.rsindex 000000000,046cc37a4..834b93f36mode 000000,100644..100644--- a/crates/engine/src/cmd/layer/switches.rs+++ b/crates/engine/src/cmd/layer/switches.rs@@@ -1,0 -1,210 +1,299 @@@+ use super::*;++ pub(super) fn set_switch(s: &mut Session, p: &Value) -> Result<Value> {+ let (cid, ids) = layers_p(s, p)?;+ let name = str_p(p, "switch").ok_or_else(|| bad("layer.setSwitch", "missing `switch`"))?.to_string();+ let v = b_p(p, "value");+ let label = format!("Layer Switch ({name})");+ if b_p(p, "others") == Some(true) {+ return set_switch_others(s, cid, &ids, &name, v, &label);+ }+ // `merge`: a switch dragged over several layers in the Timeline is one undo step.+ let r = s.edit(&label, merge_p(p), |proj, _| {+ let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;+ let mut last = false;+ // Toggle relative to the first layer so a multi-selection ends up consistent.+ let first = comp.layers.iter().find(|l| ids.contains(&l.id)).map(|l| switch_value(l, &name)).unwrap_or(Some(false));+ let Some(first) = first else { return Err(bad("layer.setSwitch", format!("unknown switch `{name}`"))) };+ let target = v.unwrap_or(!first);+ for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {+ set_switch_value(l, &name, target);+ last = target;+ }+ Ok(last)+ })?;+ Ok(json!(r))+ }++ /// `layer.setSwitch {others: true}` (Alt-click on an A/V feature in the Timeline): the named+ /// layers stand alone, shown / heard / soloed / unlocked while every other layer the switch+ /// applies to is the opposite; when they already do, the other layers come back. `value` sets+ /// the other layers directly.+ fn set_switch_others(s: &mut Session, cid: ItemId, ids: &[LayerId], name: &str, value: Option<bool>, label: &str) -> Result<Value> {+ let r = s.edit(label, None, |proj, _| {+ let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;+ // The state that sets a layer apart: unlocked for Lock, on for the rest.+ let active = !matches!(name, "lock" | "locked");+ // Track mattes keep their video off by design.+ let mattes: Vec<LayerId> =+ if matches!(name, "video" | "eye") { comp.layers.iter().filter_map(|l| l.track_matte.map(|m| m.layer)).collect() } else { Vec::new() };+ let applies = |l: &Layer| match name {+ "audio" => l.props.sub("audio").is_some(),+ "lock" | "locked" => true,+ // Every layer has a Video switch (it hides a null's outline in the viewer and turns a+ // camera or light off), as the Timeline's eye cell shows; track mattes keep theirs off+ // by design.+ "video" | "eye" => !mattes.contains(&l.id),+ _ => l.source.is_av() && !mattes.contains(&l.id),+ };+ let mut alone = true;+ for l in comp.layers.iter().filter(|l| applies(l)) {+ let Some(on) = switch_value(l, name) else { return Err(bad("layer.setSwitch", format!("unknown switch `{name}`"))) };+ alone &= on == (ids.contains(&l.id) == active);+ }+ let others = value.unwrap_or(alone == active);+ for l in comp.layers.iter_mut().filter(|l| applies(l)) {+ let v = if ids.contains(&l.id) { active } else { others };+ set_switch_value(l, name, v);+ }+ Ok(others)+ })?;+ Ok(json!(r))+ }++ fn switch_value(l: &Layer, name: &str) -> Option<bool> {+ let sw = &l.switches;+ Some(match name {+ "video" | "eye" => sw.video,+ "audio" => sw.audio,+ "solo" => sw.solo,+ "lock" | "locked" => sw.locked,+ "shy" => sw.shy,+ "collapse" => sw.collapse,+ "quality" => sw.quality == Quality::Best,+ "fx" | "effects" => sw.effects,+ "frameBlend" => sw.frame_blend != FrameBlend::Off,+ "motionBlur" => sw.motion_blur,+ "adjustment" => sw.adjustment,+ "threeD" | "3d" | "3D" => sw.three_d,+ "guide" => sw.guide,+ "preserveTransparency" => l.preserve_transparency,+ _ => return None,+ })+ }++ fn set_switch_value(l: &mut Layer, name: &str, v: bool) {+ let sw = &mut l.switches;+ match name {+ "video" | "eye" => sw.video = v,+ "audio" => sw.audio = v,+ "solo" => sw.solo = v,+ "lock" | "locked" => sw.locked = v,+ "shy" => sw.shy = v,+ "collapse" => sw.collapse = v,+ "quality" => sw.quality = if v { Quality::Best } else { Quality::Draft },+ "fx" | "effects" => sw.effects = v,+ "frameBlend" => sw.frame_blend = if v { FrameBlend::FrameMix } else { FrameBlend::Off },+ "motionBlur" => sw.motion_blur = v,+ "adjustment" => sw.adjustment = v,+ "threeD" | "3d" | "3D" => {+ if sw.three_d && !v {+ drop_3d_values(l);+ }+ l.switches.three_d = v;+ }+ "guide" => sw.guide = v,+ "preserveTransparency" => l.preserve_transparency = v,+ _ => {}+ }+ }++ /// Turning the 3D switch off discards Z values, Orientation and X/Y Rotation (as in AE).+ fn drop_3d_values(l: &mut Layer) {+ let Some(tr) = l.transform_mut() else { return };+ for (m, keep) in [("position", 0.0), ("anchor", 0.0), ("scale", 100.0)] {+ if let Some(pr) = tr.get_mut(m) {+ let flat = |v: &mut KV| {+ if let KV::Vec3(a) = v {+ a[2] = keep;+ }+ };+ flat(&mut pr.value);+ for k in &mut pr.keys {+ flat(&mut k.value);+ }+ }+ }+ for (m, zero) in [("orientation", KV::Vec3([0.0; 3])), ("rotationX", KV::Scalar(0.0)), ("rotationY", KV::Scalar(0.0))] {+ if let Some(pr) = tr.get_mut(m) {+ pr.keys.clear();+ pr.expr = None;+ pr.value = zero;+ }+ }+ }++ pub(super) fn rename(s: &mut Session, p: &Value) -> Result<Value> {+ let (cid, lid) = layer_p(s, p, "layer.rename")?;+ let name = str_p(p, "name").ok_or_else(|| bad("layer.rename", "missing `name`"))?.to_string();+ s.edit("Rename Layer", None, |proj, _| {+ layer_mut(proj, cid, lid)?.name = name.clone();+ Ok(())+ })?;+ Ok(Value::Null)+ }++ /// The Timeline's Comment column.+ pub(super) fn set_comment(s: &mut Session, p: &Value) -> Result<Value> {+ let (cid, ids) = layers_p(s, p)?;+ let text = str_p(p, "comment").ok_or_else(|| bad("layer.setComment", "missing `comment`"))?.to_string();+ s.edit("Layer Comment", None, |proj, _| {+ let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;+ for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {+ l.comment = text.clone();+ }+ Ok(())+ })?;+ Ok(Value::Null)+ }++ pub(super) fn blend(s: &mut Session, p: &Value) -> Result<Value> {+ let (cid, ids) = layers_p(s, p)?;+ let mode = str_p(p, "mode").and_then(BlendMode::from_name);+ let step = p.get("step").and_then(Value::as_i64).unwrap_or(0);+ if mode.is_none() && step == 0 {+ return Err(bad("layer.setBlendMode", "need `mode` (e.g. Multiply) or `step` ±1"));+ }+ s.edit("Blending Mode", None, |proj, _| {+ let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;+ for l in comp.layers.iter_mut().filter(|l| ids.contains(&l.id)) {+ l.blend_mode = match mode {+ Some(m) => m,+ None if step > 0 => l.blend_mode.next(),+ None => l.blend_mode.previous(),+ };+ }+ Ok(())+ })?;+ Ok(Value::Null)+ }+++/// `layer.setTrackMatte`: `layers` (or `layer`, else the first selected layer; locked ones left++/// as they are) use `matte` as their track matte (none when null), in one undo step. `kind` sets the mode; `preserve` keeps++/// each layer's own (Alpha for a layer without a matte), so changing the matte of several layers++/// at once keeps their modes.+ pub(super) fn track_matte(s: &mut Session, p: &Value) -> Result<Value> {- let (cid, lid) = layer_p(s, p, "layer.setTrackMatte")?;++ let (cid, ids) = match p.get("layers") {++ Some(_) => layers_p(s, p)?,++ None => layer_p(s, p, "layer.setTrackMatte").map(|(c, l)| (c, vec![l]))?,++ };++ // Locked layers keep their matte (several at once: the others get it).++ let ids = unlocked(s, cid, ids, "layer.setTrackMatte")?;+ let comp = s.project.comp(cid).ok_or(EngineError::NoComp)?;+ let matte = match p.get("matte") {+ None | Some(Value::Null) => None,+ Some(v) => Some(resolve_layer(comp, v).ok_or_else(|| bad("layer.setTrackMatte", "no such matte layer"))?),+ };- let kind = str_p(p, "kind")- .map(|k| match k.to_ascii_lowercase().replace([' ', '_', '-'], "").as_str() {++ if ids.is_empty() {++ return Err(bad("layer.setTrackMatte", "no layers"));++ }++ if matte.is_some_and(|m| ids.contains(&m)) {++ return Err(bad("layer.setTrackMatte", "a layer can't be its own matte"));++ }++ // None: each layer keeps its own mode.++ let kind = match str_p(p, "kind").map(|k| k.to_ascii_lowercase().replace([' ', '_', '-'], "")) {++ Some(k) if k == "preserve" => None,++ Some(k) => Some(match k.as_str() {+ "alphainverted" | "alphainv" => MatteKind::AlphaInverted,+ "luma" => MatteKind::Luma,+ "lumainverted" | "lumainv" => MatteKind::LumaInverted,+ _ => MatteKind::Alpha,- })- .unwrap_or(MatteKind::Alpha);++ }),++ None => Some(MatteKind::Alpha),++ };+ s.edit("Track Matte", None, |proj, _| {+ let comp = proj.comp_mut(cid).ok_or(EngineError::NoComp)?;- if let Some(m) = matte {- if m == lid {- return Err(bad("layer.setTrackMatte", "a layer can't be its own matte"));- }- if let Some(ml) = comp.layer_mut(m) {- ml.switches.video = false;- }++ if let Some(ml) = matte.and_then(|m| comp.layer_mut(m)) {++ ml.switches.video = false;++ }++ for lid in &ids {++ let l = comp.layer_mut(*lid).ok_or(EngineError::NoComp)?;++ let kind = kind.unwrap_or_else(|| l.track_matte.map(|m| m.kind).unwrap_or_default());++ l.track_matte = matte.map(|layer| TrackMatte { layer, kind });+ }- comp.layer_mut(lid).ok_or(EngineError::NoComp)?.track_matte = matte.map(|layer| TrackMatte { layer, kind });+ Ok(())+ })?;+ Ok(Value::Null)+ }++++#[cfg(test)]++mod track_matte_batch_tests {++ use super::*;++ use std::sync::Arc;++++ fn matte_of(s: &Session, id: u64) -> Option<(u64, MatteKind)> {++ s.active_comp().unwrap().layer(LayerId(id)).unwrap().track_matte.map(|m| (m.layer.0, m.kind))++ }++++ /// #1260: several layers take one matte layer at once, in one undo step; `kind: "preserve"`++ /// keeps each one's mode; refused calls change nothing; one `layer` still works.++ #[test]++ fn several_layers_take_one_matte_and_keep_their_modes() {++ let mut s = Session::default();++ s.execute("comp.new", json!({"name":"Mattes","width":16,"height":16,"duration":1})).unwrap();++ let [a, b, c, x, y] = ["A", "B", "C", "X", "Y"].map(|n| s.execute("layer.newSolid", json!({"name": n})).unwrap()["layer"].as_u64().unwrap());++ s.execute("layer.setTrackMatte", json!({"layer": a, "matte": x, "kind": "luma"})).unwrap();++ s.execute("layer.setTrackMatte", json!({"layer": b, "matte": x})).unwrap();++ assert_eq!((matte_of(&s, a), matte_of(&s, b)), (Some((x, MatteKind::Luma)), Some((x, MatteKind::Alpha))), "one layer, as before");++ let (before, undo) = (s.project.clone(), s.history.undo.len());++ s.execute("layer.setTrackMatte", json!({"layers": [a, b, c], "matte": y, "kind": "preserve"})).unwrap();++ assert_eq!(++ [matte_of(&s, a), matte_of(&s, b), matte_of(&s, c)],++ [Some((y, MatteKind::Luma)), Some((y, MatteKind::Alpha)), Some((y, MatteKind::Alpha))],++ "each keeps its mode (Alpha without one)"++ );++ assert!(!s.active_comp().unwrap().layer(LayerId(y)).unwrap().switches.video, "the matte is hidden");++ assert_eq!(s.history.undo.len(), undo + 1, "one undo step");++ s.execute("edit.undo", json!({})).unwrap();++ assert!(s.project.same_content(&before));++ // Refused: a layer as its own matte, an unknown layer, no layers. Nothing changes.++ for p in [++ json!({"layers": [a, y], "matte": y}),++ json!({"layers": [a, 9999], "matte": y}),++ json!({"layers": [], "matte": y}),++ json!({"layers": [a], "matte": 9999}),++ ] {++ let (project, revision) = (s.project.clone(), s.revision);++ assert!(s.execute("layer.setTrackMatte", p.clone()).is_err(), "{p}");++ assert!(Arc::ptr_eq(&project, &s.project) && s.revision == revision, "{p} changed nothing");++ }++ s.execute("layer.setTrackMatte", json!({"layers": [a, b], "matte": null})).unwrap();++ assert_eq!((matte_of(&s, a), matte_of(&s, b)), (None, None), "both lose it");++ }++++ /// Locked layers keep their parent and matte when they are among several (the others change),++ /// and alone they are an error that changes nothing.++ #[test]++ fn locked_layers_keep_their_parent_and_matte() {++ let mut s = Session::default();++ s.execute("comp.new", json!({"name":"Locks","width":16,"height":16,"duration":1})).unwrap();++ let [a, b, p, m] = ["A", "B", "P", "M"].map(|n| s.execute("layer.newSolid", json!({"name": n})).unwrap()["layer"].as_u64().unwrap());++ s.execute("layer.setSwitch", json!({"layers": [b], "switch": "lock", "value": true})).unwrap();++ let layer = |s: &Session, id: u64| s.active_comp().unwrap().layer(LayerId(id)).unwrap().clone();++ s.execute("layer.setParent", json!({"layers": [a, b], "parent": p})).unwrap();++ s.execute("layer.setTrackMatte", json!({"layers": [a, b], "matte": m, "kind": "preserve"})).unwrap();++ s.execute("layer.trackMatte", json!({"layers": [a, b], "op": "luma"})).unwrap();++ assert_eq!((layer(&s, a).parent, matte_of(&s, a)), (Some(LayerId(p)), Some((m, MatteKind::Luma))));++ assert_eq!((layer(&s, b).parent, matte_of(&s, b)), (None, None), "the locked layer is left as it was");++ for (cmd, p) in [++ ("layer.setParent", json!({"layers": [b], "parent": p})),++ ("layer.setTrackMatte", json!({"layers": [b], "matte": m})),++ ("layer.trackMatte", json!({"layers": [b], "op": "alpha"})),++ ] {++ let (project, revision) = (s.project.clone(), s.revision);++ let err = s.execute(cmd, p).unwrap_err();++ assert!(err.to_string().contains("is locked"), "{cmd}: {err}");++ assert!(Arc::ptr_eq(&project, &s.project) && s.revision == revision, "{cmd} changed nothing");++ }++ }++}diff --cc crates/ui-egui/src/panels/timeline.rsindex c2c37aede,ea18c7f1e..a116ec2a8--- a/crates/ui-egui/src/panels/timeline.rs+++ b/crates/ui-egui/src/panels/timeline.rs@@@ -163,8 -162,9 +163,10 @@@ type PickWhip = (u8, u64, u64, Pos2)const WHIP_PARENT: u8 = 0;const WHIP_EXPR: u8 = 1;const WHIP_PROP: u8 = 2;+const WHIP_MATTE: u8 = 3;+ /// The `egui::Id` under which a pick-whip drag in progress ([`PickWhip`]) is kept during the+ /// drag.fn pick_whip_id() -> egui::Id {egui::Id::unique("tl-pickwhip")}diff --cc crates/ui-egui/src/panels/timeline/tests.rsindex 000000000,0355ea5ed..445068bd4mode 000000,100644..100644--- a/crates/ui-egui/src/panels/timeline/tests.rs+++ b/crates/ui-egui/src/panels/timeline/tests.rs@@@ -1,0 -1,537 +1,537 @@@+ use super::*;++ /// Alt/Option-drag takes the same Project items `layer.replaceSource` does: compositions,+ /// footage and solids, never folders, data files or 3D models.+ #[test]+ fn replace_source_takes_visual_items_only() {+ use effectcraft_engine::color::Label;+ use effectcraft_engine::project::{Comp, Footage, Project, Solid};+ use effectcraft_engine::time::{FrameRate, Tick};+ let mut p = Project::default();+ let l = Label::None;+ let comp = p.add_item("C", l, None, ItemKind::Comp(Comp::new(10, 10, FrameRate::FPS_30, Tick::from_seconds_f64(1.0)).into()));+ let folder = p.add_item("F", l, None, ItemKind::Folder);+ let still = p.add_item("S", l, None, ItemKind::Footage(Footage { kind: FootageKind::Still, ..Default::default() }));+ let data = p.add_item("D", l, None, ItemKind::Footage(Footage { kind: FootageKind::Data, ..Default::default() }));+ let model = p.add_item("M", l, None, ItemKind::Footage(Footage { kind: FootageKind::Model, ..Default::default() }));+ let solid = p.add_item("So", l, None, ItemKind::Solid(Solid { color: [0.0; 3], width: 10, height: 10, pixel_aspect: 1.0 }));+ for (id, ok) in [(comp, true), (still, true), (solid, true), (folder, false), (data, false), (model, false)] {+ assert_eq!(replaceable_item(p.item(id).unwrap()), ok, "{id:?}");+ }+ }++ /// Alt/Cmd-click twirls Audio's Waveform row (not in the property tree) with the rest.+ #[test]+ fn the_waveform_row_twirls_with_its_tree() {+ let mut root = PropGroup::new(1, "", "");+ let mut audio = PropGroup::new(2, "audio", "Audio");+ audio.children.push(PropGroup::new(3, "x", "X").into());+ root.children.push(audio.into());+ let mut uids = vec![];+ walk_groups(&root, &mut uids);+ assert_eq!(uids, vec![2, WAVE_BIT | 2, 3]);+ let mut uids = vec![];+ walk_groups(find_group(&root, 2).unwrap(), &mut uids);+ assert_eq!(uids, vec![WAVE_BIT | 2, 3]);+ }++ /// #710: with Time Display set to Frames the ruler labels are frame numbers (as under the+ /// CTI, from Start Numbering Frames At); otherwise seconds:frames.+ #[test]+ fn ruler_labels_follow_the_time_display_style() {+ use effectcraft_engine::project::{ProjectSettings, TimeDisplayStyle};+ let mut st = ProjectSettings { time_display: TimeDisplayStyle::Timecode, frame_start: 0, ..ProjectSettings::default() };+ assert_eq!(ruler_label(15, 30, &st), "00:15f");+ assert_eq!(ruler_label(45, 30, &st), "01:15f");+ assert_eq!(ruler_label(30 * 3600 + 31, 30, &st), "60:01:01f");+ st.time_display = TimeDisplayStyle::Frames;+ assert_eq!(ruler_label(0, 30, &st), "00000");+ assert_eq!(ruler_label(45, 30, &st), "00045");+ st.frame_start = 1;+ assert_eq!(ruler_label(45, 30, &st), "00046");+ assert_eq!(ruler_label(i64::MAX, 30, &st), format!("{:05}", i64::MAX));+ }++ /// #468: playback pages the view to the CTI; a scrub past either end scrolls that way.+ #[test]+ fn the_view_pages_to_the_cti() {+ assert_eq!(page_to_cti(10.0, 5.0, 60.0, 12.0), 10.0, "in view: unchanged");+ assert_eq!(page_to_cti(10.0, 5.0, 60.0, 16.0), 16.0, "past the right end: the page from the CTI");+ assert_eq!(page_to_cti(10.0, 5.0, 60.0, 3.0), 3.0, "before the start");+ assert_eq!(page_to_cti(10.0, 5.0, 60.0, 58.0), 55.0, "not past the comp's end");+ assert_eq!(page_to_cti(10.0, 80.0, 60.0, 95.0), 0.0);+ assert_eq!(page_to_cti(10.0, f64::NAN, 60.0, 95.0), 10.0);+ assert_eq!(edge_scroll_speed_x(100.0, 500.0, 300.0), 0.0);+ assert!(edge_scroll_speed_x(100.0, 500.0, 501.0) > 0.0 && edge_scroll_speed_x(100.0, 500.0, 99.0) < 0.0);+ assert!(edge_scroll_speed_x(100.0, 500.0, 600.0) > edge_scroll_speed_x(100.0, 500.0, 520.0));+ }++ /// #864: picking only a mode in a layer's Track Matte menu sets a matte (the layer above);+ /// it used to close the menu and change nothing.+ #[test]+ fn a_track_matte_mode_without_a_matte_takes_the_layer_above() {+ let mut s = effectcraft_engine::Session::default();+ s.execute("comp.new", json!({"name": "T", "width": 64, "height": 64, "duration": 1})).unwrap();+ for name in ["Chain Bottom", "Matte", "Chain Top"] {+ s.execute("layer.newSolid", json!({"name": name, "color": "#ffffff", "width": 64, "height": 64})).unwrap();+ }+ let find = |s: &effectcraft_engine::Session, n: &str| s.active_comp().unwrap().layers.iter().find(|l| l.name == n).unwrap().clone();+ let (bottom, matte, top) = (find(&s, "Chain Bottom"), find(&s, "Matte"), find(&s, "Chain Top"));+ let candidates = [top.id, matte.id];+ let pick = |s: &mut effectcraft_engine::Session, name: &str, i: usize, choice: &str| {- let (id, params) = track_matte_pick(&find(s, name), &candidates, i, choice).expect("a menu item is an action");++ let (id, params) = track_matte_pick(&[find(s, name).id.0], &candidates, i, choice).expect("a menu item is an action");+ s.execute(&id, params)+ };+ pick(&mut s, "Chain Bottom", 5, "Alpha Inverted Matte").unwrap();+ let m = find(&s, "Chain Bottom").track_matte.expect("a matte");+ assert_eq!((m.layer, m.kind), (matte.id, MatteKind::AlphaInverted));+ assert!(!find(&s, "Matte").switches.video, "the matte layer is hidden");+ // A mode change keeps the matte layer; a matte change keeps the mode.+ pick(&mut s, "Chain Bottom", 6, "Luma Matte").unwrap();+ assert_eq!(find(&s, "Chain Bottom").track_matte.map(|m| (m.layer, m.kind)), Some((matte.id, MatteKind::Luma)));+ pick(&mut s, "Chain Bottom", 2, "1. Chain Top").unwrap();+ assert_eq!(find(&s, "Chain Bottom").track_matte.map(|m| (m.layer, m.kind)), Some((top.id, MatteKind::Luma)));+ assert!(s.undo());+ assert_eq!(find(&s, "Chain Bottom").track_matte.map(|m| m.layer), Some(matte.id), "one undo step per pick");+ // The top layer has nothing above it: an error for the status bar, not a silent no-op.+ assert!(pick(&mut s, "Chain Top", 5, "Alpha Matte").is_err());+ pick(&mut s, "Chain Bottom", 0, "No Track Matte").unwrap();+ assert!(find(&s, "Chain Bottom").track_matte.is_none());- assert!(track_matte_pick(&bottom, &candidates, 1, "-").is_none(), "a separator does nothing");++ assert!(track_matte_pick(&[bottom.id.0], &candidates, 1, "-").is_none(), "a separator does nothing");+ }++ /// #957: vector footage gets the Continuously Rasterize switch; raster footage does not.+ #[test]+ fn collapse_switch_shows_for_vector_footage_only() {+ use effectcraft_engine::color::Label;+ use effectcraft_engine::project::{Footage, ItemKind, Project};+ let mut p = Project::default();+ let mut layer_for = |name: &str, codec: &str| {+ let footage = Footage { path: name.into(), codec: codec.into(), ..Default::default() };+ let item = p.add_item(name, Label::SeaFoam, None, ItemKind::Footage(footage));+ let comp = Comp::new(64, 36, effectcraft_engine::time::FrameRate::new(30, 1), Tick::from_seconds_f64(1.0));+ effectcraft_engine::project::build::layer(&mut p, &comp, name, LayerSource::Footage { item }, (0, 0), None)+ };+ let svg = layer_for("logo.svg", "SVG");+ let png = layer_for("photo.png", "PNG");+ assert!(collapse_applies(&svg, &p));+ assert!(!collapse_applies(&png, &p));+ }++ /// A comp with two solids; "Box" has an animated Position and a Gaussian Blur.+ fn app() -> EffectcraftApp {+ let mut s = effectcraft_engine::Session::default();+ s.execute("comp.new", json!({"name": "T", "width": 320, "height": 180, "duration": 4})).unwrap();+ s.execute("layer.newSolid", json!({"name": "Plate", "color": "#406080", "width": 320, "height": 180})).unwrap();+ s.execute("layer.newSolid", json!({"name": "Box", "color": "#e04020", "width": 40, "height": 40})).unwrap();+ let comp = s.active_comp().unwrap();+ let bx = comp.layers.iter().find(|l| l.name == "Box").unwrap().id.0;+ s.execute("layer.select", json!({"layers": [bx]})).unwrap();+ s.execute("effect.apply", json!({"effect": "ec.blur.gaussian"})).unwrap();+ let pos = s.active_comp().unwrap().layer(LayerId(bx)).unwrap().transform().unwrap().get("position").unwrap().uid;+ s.execute("prop.toggleAnimation", json!({"layer": bx, "prop": pos})).unwrap();+ EffectcraftApp::new(s)+ }++ fn labels(app: &EffectcraftApp) -> Vec<String> {+ let comp = app.session.active_comp().unwrap().clone();+ build_rows(app, &comp)+ .into_iter()+ .map(|r| {+ let l = comp.layer(r.layer).unwrap();+ match r.kind {+ RowKind::Layer => l.name.clone(),+ RowKind::Group { name, .. } => format!("{}>{name}", " ".repeat(r.depth)),+ RowKind::Prop { uid } => format!("{}{}", " ".repeat(r.depth), l.props.find(uid).unwrap().name),+ _ => "?".into(),+ }+ })+ .collect()+ }++ #[test]+ fn search_filters_layers_and_reveals_matching_properties() {+ let mut app = app();+ app.ui.timeline.search = "opac".into();+ let rows = labels(&app);+ // Both layers have Transform > Opacity; nothing else shows.+ assert_eq!(rows.iter().filter(|r| r.trim() == "Opacity").count(), 2, "{rows:?}");+ assert!(rows.iter().any(|r| r.trim() == ">Transform"), "{rows:?}");+ assert!(!rows.iter().any(|r| r.trim() == "Position"), "{rows:?}");+ // A layer name match shows the layer alone; a group match brings its contents.+ app.ui.timeline.search = "plate".into();+ assert_eq!(labels(&app), vec!["Plate".to_string()]);+ app.ui.timeline.search = "GAUSSIAN".into();+ let rows = labels(&app);+ assert_eq!(rows[0], "Box");+ assert!(rows.iter().any(|r| r.trim() == ">Effects") && rows.iter().any(|r| r.trim() == "Blurriness"), "{rows:?}");+ assert!(!rows.contains(&"Plate".to_string()));+ // Nothing matches → no rows.+ app.ui.timeline.search = "zzz".into();+ assert!(labels(&app).is_empty());+ // Through the command.+ let ctx = egui::Context::default();+ crate::menus::invoke(&mut app, &ctx, "timeline.search", json!({"query": "scale"})).unwrap();+ assert!(labels(&app).iter().any(|r| r.trim() == "Scale"));+ }++ /// A shape group's inner Contents (AE's elided `ADBE Vectors Group`) draws no row: the+ /// search shows the full row hierarchy with the group's items — path, fill and Transform —+ /// listing directly under the group, and the only "Contents" row the layer's own.+ #[test]+ fn shape_group_inner_contents_is_elided() {+ let mut s = effectcraft_engine::Session::default();+ s.execute("comp.new", json!({"name": "T", "width": 320, "height": 180, "duration": 4})).unwrap();+ s.execute("layer.newShape", json!({"kind": "rect"})).unwrap();+ let mut app = EffectcraftApp::new(s);+ app.ui.timeline.search = "rect".into();+ assert_eq!(+ labels(&app),+ [+ "Shape Layer 1",+ " >Contents",+ " >Rectangle 1",+ " >Rectangle Path 1",+ " Size",+ " Position",+ " Roundness",+ " >Fill 1",+ " Composite",+ " Fill Rule",+ " Color",+ " Opacity",+ " >Transform",+ " Anchor Point",+ " Position",+ " Scale",+ " Skew",+ " Skew Axis",+ " Rotation",+ " Opacity",+ ]+ .iter()+ .map(|r| r.to_string())+ .collect::<Vec<_>>()+ );+ }++ #[test]+ fn columns_toggle_and_layout() {+ let mut app = app();+ let tl = &mut app.ui.timeline;+ assert!(column_visible(tl, "switches") && !column_visible(tl, "comment") && !column_visible(tl, "modes"));+ set_column(tl, "comment", true).unwrap();+ set_column(tl, "stretch", true).unwrap();+ set_column(tl, "keys", false).unwrap();+ set_column(tl, "label", false).unwrap();+ set_column(tl, "modes", true).unwrap();+ assert!(tl.show_modes && column_visible(tl, "comment") && !column_visible(tl, "label"));+ assert!(set_column(tl, "name", false).is_err());+ assert!(set_column(tl, "bogus", true).is_err());+ let vis = Vis::of(tl);+ let cw = cols(0.0, 1400.0, vis);+ // Hidden columns take no room; visible ones are in After Effects' order.+ assert_eq!(cw.keys, cw.label);+ assert_eq!(cw.label, cw.num);+ assert!(cw.name < cw.comment && cw.comment < cw.switches && cw.switches < cw.mode && cw.parent < cw.stretch);+ assert_eq!(column_at(&cw, cw.comment + 5.0), Some("comment"));+ assert_eq!(column_at(&cw, cw.name + 5.0), Some("name"));+ assert_eq!(column_at(&cw, cw.stretch + 5.0), Some("stretch"));+ // Through the command (as agents do).+ let ctx = egui::Context::default();+ let r = crate::menus::invoke(&mut app, &ctx, "timeline.column", json!({"column": "duration"})).unwrap();+ assert!(r["columns"].as_array().unwrap().iter().any(|c| c == "duration"));+ crate::menus::invoke(&mut app, &ctx, "timeline.column", json!({"column": "duration", "visible": false})).unwrap();+ assert!(!column_visible(&app.ui.timeline, "duration"));+ crate::menus::invoke(&mut app, &ctx, "timeline.sourceName", json!({})).unwrap();+ assert!(app.ui.timeline.source_name);+ }++ #[test]+ fn reveal_keys_add_with_shift_and_uu_reveals_modified() {+ let mut app = app();+ let ctx = egui::Context::default();+ crate::menus::invoke(&mut app, &ctx, "timeline.reveal.opacity", json!({})).unwrap();+ assert_eq!(app.ui.timeline.reveal, vec!["opacity"]);+ crate::menus::invoke(&mut app, &ctx, "timeline.revealAdd.scale", json!({})).unwrap();+ crate::menus::invoke(&mut app, &ctx, "timeline.revealAdd.effects", json!({})).unwrap();+ assert_eq!(app.ui.timeline.reveal, vec!["opacity", "scale", "effects"]);+ let rows = labels(&app);+ assert!(rows.iter().any(|r| r.trim() == "Scale") && rows.iter().any(|r| r.trim() == "Opacity"), "{rows:?}");+ assert!(rows.iter().any(|r| r.trim() == ">Gaussian Blur"), "{rows:?}");+ // Tree order: Scale before Opacity.+ let si = rows.iter().position(|r| r.trim() == "Scale").unwrap();+ let oi = rows.iter().position(|r| r.trim() == "Opacity").unwrap();+ assert!(si < oi);+ // Shift+S again removes Scale.+ crate::menus::invoke(&mut app, &ctx, "timeline.revealAdd.scale", json!({})).unwrap();+ assert_eq!(app.ui.timeline.reveal, vec!["opacity", "effects"]);+ // U: keyframed properties (Position); UU (twice quickly): every modified property.+ crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();+ let n_keys = app.ui.timeline.reveal_props.len();+ assert_eq!(app.ui.timeline.reveal, vec!["props"]);+ assert!(n_keys >= 1);+ let bx = app.session.state.selected_layers[0].0;+ app.session.execute("prop.set", json!({"layer": bx, "path": "effects/#1/blurriness", "value": 12})).unwrap();+ crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();+ assert!(app.ui.timeline.reveal_props.len() > n_keys, "UU reveals modified properties too");+ }++ #[test]+ fn scroll_to_time_centres_the_current_time_inside_the_comp() {+ assert_eq!(centered_on(4.0, 10.0, 5.0), 3.0);+ // Near the ends the view stops at the comp's start and end.+ assert_eq!(centered_on(4.0, 10.0, 1.0), 0.0);+ assert_eq!(centered_on(4.0, 10.0, 9.5), 6.0);+ // A span longer than the comp, and bad numbers, start at zero.+ assert_eq!(centered_on(20.0, 10.0, 5.0), 0.0);+ assert_eq!(centered_on(f64::NAN, 10.0, 5.0), 0.0);+ }++ /// U and the other reveal shortcuts act on the selected layers only: other layers keep their+ /// twirl state and their own reveal (#160).+ #[test]+ fn reveal_shortcuts_leave_unselected_layers_alone() {+ let mut app = app();+ let ctx = egui::Context::default();+ let comp = app.session.active_comp().unwrap().clone();+ let id = |n: &str| comp.layers.iter().find(|l| l.name == n).unwrap().id.0;+ let (plate, bx) = (id("Plate"), id("Box"));+ let select = |app: &mut EffectcraftApp, l: u64| app.session.execute("layer.select", json!({"layers": [l]})).unwrap();+ // Plate shows Scale (S); then U on Box.+ select(&mut app, plate);+ crate::menus::invoke(&mut app, &ctx, "timeline.reveal.scale", json!({})).unwrap();+ select(&mut app, bx);+ crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();+ let tl = &app.ui.timeline;+ assert!(tl.open_layers.contains(&plate) && tl.open_layers.contains(&bx), "{:?}", tl.open_layers);+ assert_eq!(tl.layer_reveal.get(&plate), Some(&vec!["scale".to_string()]), "Plate keeps its reveal");+ assert_eq!(tl.layer_reveal.get(&bx), Some(&vec!["props".to_string()]));+ let rows = labels(&app);+ let at = |n: &str| rows.iter().position(|r| r == n).unwrap();+ assert_eq!(rows[at("Plate") + 1].trim(), "Scale", "{rows:?}");+ assert_eq!(rows[at("Box") + 1].trim(), "Position", "{rows:?}");+ // UU (modified): the effect's changed parameter only, under the effect twirled open.+ // Then U later: Box shows its keyframed properties only again.+ app.session.execute("prop.set", json!({"layer": bx, "path": "effects/#1/blurriness", "value": 12})).unwrap();+ crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();+ let rows = labels(&app);+ let fx = rows.iter().position(|r| r.trim().ends_with("Gaussian Blur")).unwrap_or_else(|| panic!("UU shows the effect: {rows:?}"));+ assert_eq!(rows[fx + 1].trim(), "Blurriness", "{rows:?}");+ assert!(!rows.iter().any(|r| r.trim() == "Blur Dimensions"), "unchanged parameters stay hidden: {rows:?}");+ // Collapsed and expanded by hand, the effect shows all its parameters; UU filters again.+ let fx_uid = app.session.active_comp().unwrap().layer(LayerId(bx)).unwrap().effects().unwrap().groups().next().unwrap().uid;+ app.ui.timeline.toggle_group(bx, fx_uid);+ assert!(!labels(&app).iter().any(|r| r.trim() == "Blurriness"), "collapsed");+ app.ui.timeline.toggle_group(bx, fx_uid);+ let rows = labels(&app);+ assert!(rows.iter().any(|r| r.trim() == "Blurriness") && rows.iter().any(|r| r.trim() == "Blur Dimensions"), "{rows:?}");+ app.last_reveal = Some(("keyframes".into(), f64::MAX));+ crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();+ assert!(!labels(&app).iter().any(|r| r.trim() == "Blur Dimensions"), "UU again shows the changed ones only");+ app.last_reveal = Some(("keyframes".into(), -10.0));+ crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();+ app.last_reveal = Some(("keyframes".into(), -10.0));+ crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();+ let rows = labels(&app);+ assert!(!rows.iter().any(|r| r.trim() == ">Gaussian Blur") && rows.iter().any(|r| r.trim() == "Position"), "{rows:?}");+ // U again on Box (later than a double press) hides only Box's.+ app.last_reveal = Some(("keyframes".into(), -10.0));+ crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();+ let tl = &app.ui.timeline;+ assert!(!tl.open_layers.contains(&bx) && tl.open_layers.contains(&plate), "{:?}", tl.open_layers);+ // A layer twirled open by hand shows its whole tree, whatever was revealed elsewhere.+ app.session.execute("layer.select", json!({"layers": []})).unwrap();+ app.ui.timeline.open_layers.insert(bx);+ let rows = labels(&app);+ assert!(rows.iter().any(|r| r.trim() == ">Transform"), "{rows:?}");+ }++ /// U and UU show Time Remap on a layer with time remapping enabled.+ #[test]+ fn u_and_uu_reveal_time_remap() {+ let mut s = effectcraft_engine::Session::default();+ let inner = s.execute("comp.new", json!({"name": "Inner", "width": 32, "height": 32, "duration": 2})).unwrap()["comp"].as_u64().unwrap();+ s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "duration": 4})).unwrap();+ let nested = s.execute("layer.addItem", json!({"item": inner})).unwrap()["layer"].as_u64().unwrap();+ let mut app = EffectcraftApp::new(s);+ let ctx = egui::Context::default();+ crate::menus::invoke(&mut app, &ctx, "layer.enableTimeRemap", json!({"layers": [nested]})).unwrap();+ app.session.execute("layer.select", json!({"layers": [nested]})).unwrap();+ for uu in [false, true] {+ app.ui.timeline.layer_reveal.clear();+ app.last_reveal = uu.then(|| ("keyframes".into(), f64::MAX));+ crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();+ assert_eq!(app.ui.timeline.layer_reveal.get(&nested), Some(&vec!["props".to_string()]), "UU: {uu}");+ let rows = labels(&app);+ let at = rows.iter().position(|r| r == "Inner").unwrap();+ assert_eq!(rows[at + 1].trim(), "Time Remap", "UU: {uu}: {rows:?}");+ }+ }++ /// U shows Time Remap while remapping is enabled even after its keys are deleted (#990):+ /// enabling remapping is itself the modification.+ #[test]+ fn u_reveals_keyless_time_remap() {+ let mut s = effectcraft_engine::Session::default();+ let inner = s.execute("comp.new", json!({"name": "Inner", "width": 32, "height": 32, "duration": 2})).unwrap()["comp"].as_u64().unwrap();+ s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "duration": 4})).unwrap();+ let nested = s.execute("layer.addItem", json!({"item": inner})).unwrap()["layer"].as_u64().unwrap();+ let mut app = EffectcraftApp::new(s);+ let ctx = egui::Context::default();+ crate::menus::invoke(&mut app, &ctx, "layer.enableTimeRemap", json!({"layers": [nested]})).unwrap();+ let uid = app.session.active_comp().unwrap().layer(LayerId(nested)).unwrap().props.prop("timeRemap").unwrap().uid;+ for _ in 0..2 {+ let t = app.session.active_comp().unwrap().layer(LayerId(nested)).unwrap().props.prop("timeRemap").unwrap().keys[0].time.seconds();+ app.session.execute("keys.select", json!({"keys": [{"layer": nested, "prop": uid, "time": t}]})).unwrap();+ app.session.execute("edit.clear", json!({})).unwrap();+ }+ assert!(app.session.active_comp().unwrap().layer(LayerId(nested)).unwrap().props.prop("timeRemap").unwrap().keys.is_empty());+ app.session.execute("layer.select", json!({"layers": [nested]})).unwrap();+ crate::menus::invoke(&mut app, &ctx, "anim.reveal", json!({"kind": "keyframes"})).unwrap();+ assert_eq!(app.ui.timeline.layer_reveal.get(&nested), Some(&vec!["props".to_string()]));+ let rows = labels(&app);+ let at = rows.iter().position(|r| r == "Inner").unwrap();+ assert_eq!(rows[at + 1].trim(), "Time Remap", "{rows:?}");+ }++ /// Enabling time remapping twirls the layer open on Time Remap (#157); disabling it reveals+ /// nothing.+ #[test]+ fn enabling_time_remapping_reveals_time_remap() {+ let mut s = effectcraft_engine::Session::default();+ let inner = s.execute("comp.new", json!({"name": "Inner", "width": 32, "height": 32, "duration": 2})).unwrap()["comp"].as_u64().unwrap();+ s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "duration": 4})).unwrap();+ s.execute("layer.newSolid", json!({"name": "Other"})).unwrap();+ let nested = s.execute("layer.addItem", json!({"item": inner})).unwrap()["layer"].as_u64().unwrap();+ let mut app = EffectcraftApp::new(s);+ let ctx = egui::Context::default();+ crate::menus::invoke(&mut app, &ctx, "layer.enableTimeRemap", json!({"layers": [nested]})).unwrap();+ assert_eq!(app.ui.timeline.layer_reveal.get(&nested), Some(&vec!["timeRemap".to_string()]));+ let rows = labels(&app);+ let at = rows.iter().position(|r| r == "Inner").unwrap();+ assert_eq!(rows[at + 1].trim(), "Time Remap", "{rows:?}");+ // Through the selection (the Layer menu), turning it off again: nothing new is revealed.+ app.session.execute("layer.select", json!({"layers": [nested]})).unwrap();+ app.ui.timeline.layer_reveal.clear();+ crate::menus::invoke(&mut app, &ctx, "layer.enableTimeRemap", json!({})).unwrap();+ assert!(app.ui.timeline.layer_reveal.is_empty());+ }++ #[test]+ fn cti_snaps_to_the_nearest_candidate() {+ assert_eq!(snap_time(&[0.0, 1.0, 2.0], 1.04, 0.1), 1.0);+ assert_eq!(snap_time(&[0.0, 1.0, 2.0], 1.5, 0.1), 1.5);+ assert_eq!(snap_time(&[1.0, 1.1], 1.06, 0.1), 1.1);+ let app = app();+ let comp = app.session.active_comp().unwrap().clone();+ let c = snap_candidates(&comp, &build_rows(&app, &comp));+ assert!(c.contains(&comp.duration.seconds()) && c.contains(&0.0));+ }++ /// Every string drawn by one frame of `draw`.+ fn drawn_text(mut draw: impl FnMut(&mut egui::Ui)) -> Vec<String> {+ fn collect(shape: &egui::Shape, out: &mut Vec<String>) {+ match shape {+ egui::Shape::Text(t) => out.push(t.galley.text().to_string()),+ egui::Shape::Vec(v) => v.iter().for_each(|s| collect(s, out)),+ _ => {}+ }+ }+ let ctx = egui::Context::default();+ ctx.run_ui(Default::default(), |ui| draw(ui)).textures_delta.clear();+ let mut frame = ctx.run_ui(Default::default(), |ui| draw(ui));+ frame.textures_delta.clear();+ let mut out = Vec::new();+ frame.shapes.iter().for_each(|c| collect(&c.shape, &mut out));+ out+ }++ /// #1308: the layer context menu draws its items in the interface language, from the menu+ /// bar's rows for the same commands (whose ellipsis is `...`), and its Effects submenu draws+ /// the categories the Effect menu does; the actions it records stay the same.+ #[test]+ fn the_layer_context_menu_draws_in_the_interface_language() {+ let caps = LayerMenuCaps { vector: true, text: false, source: true };+ let (mut auto, mut actions) = (crate::automation::Registry::default(), Vec::new());+ crate::i18n::set_current("zh-hans");+ let menu = drawn_text(|ui| layer_menu(ui, &[7], caps, (&mut auto, "t"), &mut actions));+ let effects = drawn_text(|ui| effects_submenu(ui, &[7], &mut |_: &mut egui::Ui, _: &str, _: &str, _: serde_json::Value| {}));+ crate::i18n::set_current("en");+ let english = drawn_text(|ui| layer_menu(ui, &[7], caps, (&mut auto, "t"), &mut actions));+ for label in ["新建", "图层设置...", "在项目中显示图层源", "从矢量图层创建形状", "预合成...", "重复", "拆分图层", "删除"]+ {+ assert!(menu.iter().any(|t| t == label), "{label} missing from {menu:?}");+ }+ assert!(!menu.iter().any(|t| t.is_ascii()), "English left in {menu:?}");+ assert!(effects.iter().any(|t| t == "模糊和锐化"), "{effects:?}");+ assert!(!effects.iter().any(|t| t == "Blur & Sharpen"), "{effects:?}");+ for label in ["Layer Settings…", "Reveal Layer Source in Project", "Duplicate", "Delete"] {+ assert!(english.iter().any(|t| t == label), "{label} missing from {english:?}");+ }+ assert!(actions.is_empty());+ }++ /// The property context menu draws its items in the interface language too: the commands the+ /// menu bar has from its rows, Reset, Edit Value… and Remove Expression from the panel catalog.+ /// The automation labels stay English.+ #[test]+ fn the_property_context_menu_draws_in_the_interface_language() {+ let mut s = effectcraft_engine::Session::default();+ s.execute("comp.new", json!({"name": "Main", "width": 64, "height": 64, "duration": 4})).unwrap();+ let l = s.execute("layer.newSolid", json!({"name": "Plate", "color": "#406080"})).unwrap()["layer"].as_u64().unwrap();+ let opacity = s.active_comp().unwrap().layer(LayerId(l)).unwrap().props.prop("transform/opacity").unwrap().uid;+ s.execute("prop.setExpression", json!({"layer": l, "prop": opacity})).unwrap();+ let comp = s.active_comp_id().unwrap();+ let layer = s.active_comp().unwrap().layer(LayerId(l)).unwrap().clone();+ let (position, opacity) = (layer.props.prop("transform/position").unwrap(), layer.props.prop("transform/opacity").unwrap());+ let (mut auto, mut actions) = (crate::automation::Registry::default(), Vec::new());+ let mut menu = |language| {+ crate::i18n::set_current(language);+ let mut drawn = drawn_text(|ui| prop_menu(ui, &mut auto, comp, &layer, position, &mut actions));+ drawn.extend(drawn_text(|ui| prop_menu(ui, &mut auto, comp, &layer, opacity, &mut actions)));+ drawn+ };+ let chinese = menu("zh-hans");+ let english = menu("en");+ for label in ["重置", "编辑值…", "单独尺寸", "添加表达式", "移除表达式", "向基本图形添加属性"] {+ assert!(chinese.iter().any(|t| t == label), "{label} missing from {chinese:?}");+ }+ assert!(!chinese.iter().any(|t| t.is_ascii()), "English left in {chinese:?}");+ for label in ["Reset", "Edit Value…", "Separate Dimensions", "Remove Expression", "Add Property to Essential Graphics"] {+ assert!(english.iter().any(|t| t == label), "{label} missing from {english:?}");+ }+ assert!(auto.elements.iter().any(|e| e.label == "Remove Expression"), "the automation label stays English");+ assert!(actions.is_empty());+ }++ /// UI fidelity (M13.5): compact After Effects-like rows and muted label-coloured bars.+ #[test]+ fn rows_and_bars_follow_after_effects_proportions() {+ let t = crate::theme::Tokens::for_kind(crate::theme::ThemeKind::Dark);+ assert_eq!(t.row_h, 19.0);+ let red = t.label(effectcraft_engine::color::Label::Red);+ let bar = bar_color(red, false);+ // Muted: darker and less saturated than the label, still reddish.+ assert!(bar.r() < red.r() && bar.r() > bar.g() + 30 && bar.g() >= red.g().min(0x3a) - 1);+ let sel = bar_color(red, true);+ assert!(sel.r() > bar.r());+ }++ #[test]+ fn disk_bar_range_covers_partial_frames() {+ let clip = Rect::from_min_max(pos2(0.0, 0.0), pos2(2.0, 1.0));+ let tm = TMap { x0: 0.0, start: 10.25, pps: 1.0 };+ assert_eq!(disk_bar_range(&tm, clip, 1.0, 100), 10..13);++ let exact = TMap { start: 10.0, ..tm };+ assert_eq!(disk_bar_range(&exact, clip, 1.0, 100), 10..12);+ let off_comp = TMap { start: 200.0, ..tm };+ assert_eq!(disk_bar_range(&off_comp, clip, 1.0, 100), 100..100);+ assert_eq!(disk_bar_range(&tm, clip, f64::NAN, 100), 0..0);+ assert_eq!(disk_bar_range(&TMap { pps: 0.0, ..tm }, clip, 1.0, 100), 0..0);+ assert_eq!(disk_bar_range(&TMap { start: f64::NAN, ..tm }, clip, 1.0, 100), 0..0);+ assert_eq!(disk_bar_range(&tm, Rect::from_min_max(pos2(2.0, 0.0), pos2(2.0, 1.0)), 1.0, 100), 0..0);+ let above_limit = TMap { start: 100_001.0, ..tm };+ assert_eq!(disk_bar_range(&above_limit, clip, 1.0, i64::MAX), 100_000..100_000);+ }