From 47051fcb82bbd89e316c4ddf2347a59cfdea3d29 Mon Sep 17 00:00:00 2001
From: Kristian Myram <kristian.myram@gmail.com>
Date: Mon, 12 Oct 2026 18:32:28 +0200
Subject: [PATCH 1/9] #1010: keep a parented camera's or light's Point of
 Interest in place

Parenting a camera or light (layer.setParent, compensate on) now re-expresses its Position and
Point of Interest in the new parent's space, like the other 3D layers. The 3D loop in parent_fixes
skipped cameras and lights, so their positions stayed in the old space and the camera moved by the
null's offset. Orientation is still left as authored; a later commit re-expresses it.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
---
 crates/engine/src/commands/layer.rs | 14 +++++++++++---
 crates/engine/src/tests_rig3d.rs    | 23 +++++++++++++++++++++++
 2 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/crates/engine/src/commands/layer.rs b/crates/engine/src/commands/layer.rs
index d4cf1d90d..5396df6b7 100644
--- a/crates/engine/src/commands/layer.rs
+++ b/crates/engine/src/commands/layer.rs
@@ -591,7 +591,8 @@ pub(crate) struct ParentFix {
     rotation: f64,
     /// Multiply Scale.
     scale: [f64; 2],
-    /// 3D AV layers retain their world-space anchor, including Z.
+    /// 3D AV layers retain their world-space anchor, including Z. Cameras and lights also
+    /// re-express their Point of Interest.
     position_3d: Option<effectcraft_geom::Mat4>,
     /// A uniform relative parent transform can preserve static Orientation and Scale.
     pose_3d: Option<([f64; 3], f64)>,
@@ -626,7 +627,8 @@ impl ParentFix {
                     }
                 }
             }
-            if let Some(pr) = tr.get_mut("position") {
+            // Position and a camera's or light's Point of Interest are both points in the parent's space.
+            let map_point = |pr: &mut effectcraft_project::Property| {
                 pr.value = map_position(&pr.value);
                 for key in &mut pr.keys {
                     key.value = map_position(&key.value);
@@ -646,6 +648,12 @@ impl ParentFix {
                         }
                     }
                 }
+            };
+            if let Some(pr) = tr.get_mut("position") {
+                map_point(pr);
+            }
+            if let Some(pr) = tr.get_mut("poi") {
+                map_point(pr);
             }
             if let Some((orientation, factor)) = self.pose_3d {
                 if let Some(pr) = tr.get_mut("orientation") {
@@ -793,7 +801,7 @@ pub(crate) fn parent_fixes(s: &Session, cid: ItemId, ids: &[LayerId], parent: Op
         })
     };
     if let Some(inv) = space_3d(parent).inverse().filter(|m| m.0.iter().flatten().all(|v| v.is_finite())) {
-        for layer in comp.layers.iter().filter(|l| ids.contains(&l.id) && l.is_3d() && !l.is_camera() && !l.is_light() && l.parent != parent) {
+        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| {
diff --git a/crates/engine/src/tests_rig3d.rs b/crates/engine/src/tests_rig3d.rs
index d3b965107..2027f4a05 100644
--- a/crates/engine/src/tests_rig3d.rs
+++ b/crates/engine/src/tests_rig3d.rs
@@ -207,6 +207,29 @@ fn control_light_with_camera_follows_and_releases() {
     assert!(s.execute("light.controlWithCamera", json!({"layers": [cam]})).is_err());
 }
 
+/// Parenting keeps a camera where it is (After Effects' Parent & Link): Position and Point of
+/// Interest are re-expressed in the null's space, so the frame does not move.
+#[test]
+fn parented_camera_keeps_its_frame_under_an_offset_null() {
+    let mut s = session();
+    let cam = camera(&mut s);
+    let (eye0, f0) = frame(&s, cam);
+    let nul = s.execute("layer.newNull", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/position", "value": [100, 60, 0]})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [cam], "parent": nul})).unwrap();
+    let (eye1, f1) = frame(&s, cam);
+    assert!((eye1 - eye0).length() < 1e-6 && (f1 - f0).length() < 1e-6, "{eye0:?} {eye1:?}");
+    // The null's origin is Position minus its default anchor (50, 50): (50, 10) in the comp.
+    let c = layer_in(&s, cid(&s), cam);
+    assert!(close3(v3(&c, "transform/position"), [270.0, 170.0, -800.0], 1e-6), "{:?}", v3(&c, "transform/position"));
+    assert!(close3(v3(&c, "transform/poi"), [270.0, 170.0, 0.0], 1e-6), "{:?}", v3(&c, "transform/poi"));
+    // Moving the null carries the camera and keeps its aim.
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/position", "value": [140, 90, 0]})).unwrap();
+    let (eye2, f2) = frame(&s, cam);
+    assert!((eye2 - (eye0 + vec3(40.0, 30.0, 0.0))).length() < 1e-6, "{eye2:?}");
+    assert!((f2 - f0).length() < 1e-6, "{f2:?}");
+}
+
 // ---------------------------------------------------------------- from 3D model
 
 struct DiskModels;

From bb2153f112ead1c1c10e8c6246d70b663d8adcdf Mon Sep 17 00:00:00 2001
From: Kristian Myram <kristian.myram@gmail.com>
Date: Mon, 12 Oct 2026 18:37:05 +0200
Subject: [PATCH 2/9] #1010: recover a static Orientation's Y angle without
 losing precision near gimbal lock

uniform_parent_pose took the Y angle from asin, which loses precision within about 1e-6 degrees of
+-90. The Y angle now comes from atan2 on cos(Y), as the X and Z angles already do. The gimbal
branch and the principal-range output are unchanged.

A new test parents a static Orientation with Y 1e-6 degrees off gimbal lock under a uniform
parent. Its largest corner displacement was 3.3e-8 px before this change and 1.5e-14 px after.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
---
 crates/engine/src/commands/layer.rs          |  7 +++---
 crates/engine/tests/parenting_3d_position.rs | 23 ++++++++++++++++++++
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/crates/engine/src/commands/layer.rs b/crates/engine/src/commands/layer.rs
index 5396df6b7..c225612c3 100644
--- a/crates/engine/src/commands/layer.rs
+++ b/crates/engine/src/commands/layer.rs
@@ -751,9 +751,10 @@ fn uniform_parent_pose(m: effectcraft_geom::Mat4, orientation: [f64; 3]) -> Opti
         return Some((orientation, factor));
     }
     let r = (rotation * Mat4::orientation(Vec3::from(orientation))).0;
-    let sy = (-r[2][0]).clamp(-1.0, 1.0);
-    let y = sy.asin();
-    let (x, z) = if (1.0 - sy * sy).sqrt() > 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) };
+    // 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))
 }
 
diff --git a/crates/engine/tests/parenting_3d_position.rs b/crates/engine/tests/parenting_3d_position.rs
index 8c06cf8ad..6bf0c4ff1 100644
--- a/crates/engine/tests/parenting_3d_position.rs
+++ b/crates/engine/tests/parenting_3d_position.rs
@@ -383,6 +383,29 @@ fn parenting_static_orientation_handles_signed_uniform_scale_and_gimbal_order()
     assert!(max_corners < 1e-8 && max_pixels < 2e-5, "static uniform pose must use the existing Euler order including signed scale and gimbal angles");
 }
 
+/// A static Orientation just off gimbal lock (Y within 1e-6 degrees of ±90) keeps its world pose
+/// under a uniform parent. Recovering Euler angles from the matrix must not lose precision there.
+#[test]
+fn parenting_static_orientation_is_exact_just_off_gimbal_lock() {
+    let mut max_corners = 0.0f64;
+    for factor in [120.0, -120.0] {
+        for y in [90.0 - 1e-6, -90.0 + 1e-6] {
+            let (mut s, p, c) = fixture(true, true);
+            set(&mut s, p, "transform/orientation", json!([0.0, 0.0, 0.0]));
+            set(&mut s, p, "transform/rotationX", json!(0.0));
+            set(&mut s, p, "transform/rotationY", json!(0.0));
+            set(&mut s, p, "transform/rotation", json!(42.0));
+            set(&mut s, p, "transform/scale", json!([factor, factor, factor]));
+            set(&mut s, c, "transform/orientation", json!([23.0, y, -37.0]));
+            set(&mut s, c, "transform/scale", json!([200.0, 160.0, 150.0]));
+            let before = world(&s, c, Tick::ZERO);
+            parent(&mut s, c, Some(p), true);
+            max_corners = max_corners.max(displacement(before, world(&s, c, Tick::ZERO)));
+        }
+    }
+    assert!(max_corners < 1e-9, "a static Orientation near gimbal lock must keep its world pose: corners {max_corners}");
+}
+
 #[test]
 fn parenting_animated_orientation_and_nonuniform_parent_keep_authored_pose_boundary() {
     for animated in [true, false] {

From 114c4797639eaf657e879dada91738b8cd72e76b Mon Sep 17 00:00:00 2001
From: Kristian Myram <kristian.myram@gmail.com>
Date: Mon, 12 Oct 2026 18:40:39 +0200
Subject: [PATCH 3/9] #1010: keep a rotated null's effect on a camera's or
 light's static Orientation

Parenting a camera or light to a rotated uniform null now re-expresses its static Orientation, so a
one-node light or camera keeps its direction. A two-node camera or light also keeps its roll: its
Orientation is re-expressed against its new aim (aim_correction), so Up does not drift. Keyed
Orientation is still left as authored; a later commit re-expresses it.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
---
 crates/engine/src/commands/layer.rs | 116 +++++++++++++++++++++-------
 crates/engine/src/tests_rig3d.rs    |  54 ++++++++++++-
 2 files changed, 142 insertions(+), 28 deletions(-)

diff --git a/crates/engine/src/commands/layer.rs b/crates/engine/src/commands/layer.rs
index c225612c3..0e76b9d0c 100644
--- a/crates/engine/src/commands/layer.rs
+++ b/crates/engine/src/commands/layer.rs
@@ -594,8 +594,17 @@ pub(crate) struct ParentFix {
     /// 3D AV layers retain their world-space anchor, including Z. Cameras and lights also
     /// re-express their Point of Interest.
     position_3d: Option<effectcraft_geom::Mat4>,
-    /// A uniform relative parent transform can preserve static Orientation and Scale.
-    pose_3d: Option<([f64; 3], f64)>,
+    /// A uniform relative parent transform re-expresses static Orientation and Scale.
+    pose_3d: Option<Pose3d>,
+}
+
+/// A uniform relative parent transform, as it applies to a 3D layer's Orientation and Scale.
+#[derive(Clone, Copy)]
+struct Pose3d {
+    /// Rotation that Orientation is re-expressed under: `Orientation' = correction * Orientation`.
+    correction: effectcraft_geom::Mat4,
+    /// Uniform scale factor, multiplied into Scale (negative for a mirrored parent).
+    factor: f64,
 }
 
 impl ParentFix {
@@ -605,7 +614,7 @@ impl ParentFix {
         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 position_speed = uniform_rotation(m).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])
@@ -655,11 +664,12 @@ impl ParentFix {
             if let Some(pr) = tr.get_mut("poi") {
                 map_point(pr);
             }
-            if let Some((orientation, factor)) = self.pose_3d {
+            if let Some(pose) = self.pose_3d {
                 if let Some(pr) = tr.get_mut("orientation") {
-                    pr.value = KV::Vec3(orientation);
+                    pr.value = KV::Vec3(reexpress_static(pose.correction, pr.value.as_vec3()));
                 }
                 if let Some(pr) = tr.get_mut("scale") {
+                    let factor = pose.factor;
                     let scaled = |value: &KV| KV::Vec3(value.as_vec3().map(|v| v * factor));
                     pr.value = scaled(&pr.value);
                     for key in &mut pr.keys {
@@ -722,13 +732,10 @@ impl ParentFix {
     }
 }
 
-/// 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;
-    }
+/// The rotation and signed scale factor of a uniform parent transform's linear part (negative for a
+/// mirrored parent). `None` for a non-uniform or degenerate transform.
+fn uniform_rotation(m: effectcraft_geom::Mat4) -> Option<(effectcraft_geom::Mat4, f64)> {
+    use effectcraft_geom::{Mat4, vec3};
     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);
@@ -747,15 +754,47 @@ fn uniform_parent_pose(m: effectcraft_geom::Mat4, orientation: [f64; 3]) -> Opti
             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;
+    Some((rotation, factor))
+}
+
+/// Euler Orientation (degrees, Rz * Ry * Rx) of `correction * Orientation(orientation)`.
+fn euler_of(correction: effectcraft_geom::Mat4, orientation: [f64; 3]) -> [f64; 3] {
+    use effectcraft_geom::{Mat4, Vec3};
+    let r = (correction * 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))
+    [x.to_degrees(), y.to_degrees(), z.to_degrees()]
+}
+
+/// Static Orientation re-expressed as `correction * Orientation`. An identity correction keeps the
+/// authored values unchanged.
+fn reexpress_static(correction: effectcraft_geom::Mat4, orientation: [f64; 3]) -> [f64; 3] {
+    if (0..4).all(|row| (0..4).all(|col| (correction.0[row][col] - if row == col { 1.0 } else { 0.0 }).abs() < 1e-12)) {
+        return orientation;
+    }
+    euler_of(correction, orientation)
+}
+
+/// Correction for a two-node rig's Orientation: after a uniform parent change its aim is
+/// `rotation * aim`, so the roll is re-expressed against that aim. `None` for a degenerate aim.
+fn aim_correction(rotation: effectcraft_geom::Mat4, aim: [f64; 3]) -> Option<effectcraft_geom::Mat4> {
+    use effectcraft_geom::vec3;
+    use effectcraft_render::three_d::camera::basis_rotation;
+    let [x, y, z] = aim;
+    let length = (x * x + y * y + z * z).sqrt();
+    if !length.is_finite() || length <= 1e-9 {
+        return None;
+    }
+    let dir = vec3(x / length, y / length, z / length);
+    let turned = rotation.apply_vec(dir);
+    // A view along the up axis has no roll to keep, and its basis is undefined.
+    if 1.0 - dir.y * dir.y < 1e-12 || 1.0 - turned.y * turned.y < 1e-12 {
+        return None;
+    }
+    let up = vec3(0.0, 1.0, 0.0);
+    Some(basis_rotation(turned, up).transpose() * rotation * basis_rotation(dir, up))
 }
 
 /// A parent change retains 2D transforms and the world-space anchor of 3D AV layers. Position is
@@ -807,23 +846,46 @@ pub(crate) fn parent_fixes(s: &Session, cid: ItemId, ids: &[LayerId], parent: Op
             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")?;
+                    // Cameras and lights have no Scale; their Orientation is re-expressed alone.
+                    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.
+                    // Auto-orient replaces Orientation, except a two-node rig, whose roll is
+                    // re-expressed against its new aim.
+                    let two_node = (layer.is_camera() || layer.is_light()) && effectcraft_render::three_d::camera::is_two_node(layer);
                     if !orientation.keys.is_empty()
                         || orientation.expr.is_some()
-                        || scale.expr.is_some()
-                        || layer.auto_orient != effectcraft_project::AutoOrient::Off
+                        || scale.is_some_and(|scale| scale.expr.is_some())
+                        || (layer.auto_orient != effectcraft_project::AutoOrient::Off && !two_node)
                     {
                         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)
+                    let (rotation, factor) = uniform_rotation(m)?;
+                    let correction = if two_node {
+                        // A mirrored parent flips the aim, which this correction does not model.
+                        if factor <= 0.0 {
+                            return None;
+                        }
+                        let (w, h) = (comp.width as f64, comp.height as f64);
+                        let pos = ectx.v3(layer, tr, "position", [w / 2.0, h / 2.0, -1000.0]);
+                        let poi = ectx.v3(layer, tr, "poi", [w / 2.0, h / 2.0, 0.0]);
+                        aim_correction(rotation, [poi[0] - pos[0], poi[1] - pos[1], poi[2] - pos[2]])?
+                    } else {
+                        rotation
+                    };
+                    if !correction.0.iter().flatten().all(|v| v.is_finite()) || !orientation.value.as_vec3().iter().all(|v| v.is_finite()) {
+                        return None;
+                    }
+                    if let Some(scale) = scale {
+                        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().all(|key| key.in_ease.iter().chain(&key.out_ease).all(|ease| (ease.speed * factor).is_finite()));
+                        if !values_finite || !speeds_finite {
+                            return None;
+                        }
+                    }
+                    Some(Pose3d { correction, factor })
                 });
                 fixes.push(ParentFix { layer: layer.id, m: effectcraft_geom::Mat3::IDENTITY, rotation: 0.0, scale: [1.0; 2], position_3d: Some(m), pose_3d });
             }
diff --git a/crates/engine/src/tests_rig3d.rs b/crates/engine/src/tests_rig3d.rs
index 2027f4a05..6a13d8679 100644
--- a/crates/engine/src/tests_rig3d.rs
+++ b/crates/engine/src/tests_rig3d.rs
@@ -7,7 +7,7 @@ use std::sync::Arc;
 use effectcraft_geom::{Vec3, vec3};
 use effectcraft_keyframe::Value as KV;
 use effectcraft_project::{Footage, FootageKind, GroupKind, ItemId, Layer, LayerId, LayerSource, LightKind, Project};
-use effectcraft_render::three_d::camera::layer_frame;
+use effectcraft_render::three_d::camera::{is_two_node, layer_frame};
 use effectcraft_render::{EvalCtx, FootageSource, RenderOpts};
 use effectcraft_time::{FrameRate, Tick};
 use serde_json::{Value, json};
@@ -230,6 +230,58 @@ fn parented_camera_keeps_its_frame_under_an_offset_null() {
     assert!((f2 - f0).length() < 1e-6, "{f2:?}");
 }
 
+/// World (eye, forward, down) of a layer in the active comp at time `t`.
+fn frame_at(s: &Session, id: u64, t: Tick) -> (Vec3, Vec3, Vec3) {
+    let c = cid(s);
+    let comp = s.project.comp(c).unwrap();
+    let ctx = EvalCtx { project: &s.project, comp_id: c, comp, time: t, expr: None, footage: None };
+    layer_frame(&ctx, comp.layer(LayerId(id)).unwrap())
+}
+
+/// Whether two frames agree on eye, forward and down.
+fn frames_match(a: (Vec3, Vec3, Vec3), b: (Vec3, Vec3, Vec3)) -> bool {
+    (a.0 - b.0).length() < 1e-6 && (a.1 - b.1).length() < 1e-6 && (a.2 - b.2).length() < 1e-6
+}
+
+/// A 3D null off-centre in the comp, with an Orientation and a Z rotation.
+fn rotated_null(s: &mut Session, orientation: [f64; 3], turn: f64) -> u64 {
+    let nul = s.execute("layer.newNull", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("layer.setSwitch", json!({"layers": [nul], "switch": "threeD", "value": true})).unwrap();
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/position", "value": [100, 60, 40]})).unwrap();
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/orientation", "value": orientation})).unwrap();
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/rotation", "value": turn})).unwrap();
+    nul
+}
+
+/// A two-node camera under a rotated null keeps its eye, aim and roll: its Orientation is
+/// re-expressed against the new aim, so Up does not drift.
+#[test]
+fn two_node_camera_under_rotated_null_keeps_its_roll() {
+    let mut s = session();
+    let cam = camera(&mut s);
+    s.execute("prop.set", json!({"layer": cam, "path": "transform/rotation", "value": 25})).unwrap();
+    assert!(is_two_node(&layer_in(&s, cid(&s), cam)));
+    let before = frame_at(&s, cam, Tick::ZERO);
+    let nul = rotated_null(&mut s, [20.0, -35.0, 60.0], 30.0);
+    s.execute("layer.setParent", json!({"layers": [cam], "parent": nul})).unwrap();
+    let after = frame_at(&s, cam, Tick::ZERO);
+    assert!(frames_match(before, after), "{before:?} {after:?}");
+}
+
+#[test]
+fn parented_point_light_keeps_its_direction_under_a_rotated_null() {
+    let mut s = session();
+    let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": light, "path": "transform/orientation", "value": [30, 0, 0]})).unwrap();
+    let (eye0, f0) = frame(&s, light);
+    let nul = s.execute("layer.newNull", json!({})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/position", "value": [100, 60, 0]})).unwrap();
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/rotation", "value": 30})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
+    let (eye1, f1) = frame(&s, light);
+    assert!((eye1 - eye0).length() < 1e-6 && (f1 - f0).length() < 1e-6, "{eye0:?} {eye1:?} {f0:?} {f1:?}");
+}
+
 // ---------------------------------------------------------------- from 3D model
 
 struct DiskModels;

From 707161bc631d68db5da6181c6e78b8ce4250dae7 Mon Sep 17 00:00:00 2001
From: Kristian Myram <kristian.myram@gmail.com>
Date: Mon, 12 Oct 2026 18:43:16 +0200
Subject: [PATCH 4/9] #1010: re-express keyed Orientation per key under a
 rotated uniform parent

Parenting a 3D layer under a rotated uniform parent now re-expresses keyed Orientation at every key,
not only the static value. A Z-only correction shifts Z exactly, so the paths between keys stay
exact. Other corrections keep each key's authored turns, so the Euler values stay continuous. This
changes keyed 3D layers under any rotated uniform parent, not only cameras and lights.

The boundary test now sets the non-uniform parent before the animated and static cases, so both
keep their authored pose.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
---
 crates/engine/src/commands/layer.rs          | 83 +++++++++++++++-----
 crates/engine/src/tests_rig3d.rs             | 18 +++++
 crates/engine/tests/parenting_3d_position.rs | 25 +++++-
 3 files changed, 106 insertions(+), 20 deletions(-)

diff --git a/crates/engine/src/commands/layer.rs b/crates/engine/src/commands/layer.rs
index 0e76b9d0c..8222ad34e 100644
--- a/crates/engine/src/commands/layer.rs
+++ b/crates/engine/src/commands/layer.rs
@@ -666,7 +666,7 @@ impl ParentFix {
             }
             if let Some(pose) = self.pose_3d {
                 if let Some(pr) = tr.get_mut("orientation") {
-                    pr.value = KV::Vec3(reexpress_static(pose.correction, pr.value.as_vec3()));
+                    reexpress_orientation(pose.correction, pr);
                 }
                 if let Some(pr) = tr.get_mut("scale") {
                     let factor = pose.factor;
@@ -757,10 +757,15 @@ fn uniform_rotation(m: effectcraft_geom::Mat4) -> Option<(effectcraft_geom::Mat4
     Some((rotation, factor))
 }
 
-/// Euler Orientation (degrees, Rz * Ry * Rx) of `correction * Orientation(orientation)`.
-fn euler_of(correction: effectcraft_geom::Mat4, orientation: [f64; 3]) -> [f64; 3] {
-    use effectcraft_geom::{Mat4, Vec3};
-    let r = (correction * Mat4::orientation(Vec3::from(orientation))).0;
+/// The turn (degrees) of a rotation about Z alone, or `None` for any other rotation.
+fn z_only_turn(correction: effectcraft_geom::Mat4) -> Option<f64> {
+    let m = correction.0;
+    let about_z = [m[0][2], m[1][2], m[2][0], m[2][1]].iter().all(|v| v.abs() < 1e-9) && (m[2][2] - 1.0).abs() < 1e-9;
+    about_z.then(|| m[1][0].atan2(m[0][0]).to_degrees())
+}
+
+/// ZYX Euler angles in degrees of a row-major rotation (`Rz * Ry * Rx`), safe at gimbal lock.
+fn euler_zyx(r: [[f64; 4]; 4]) -> [f64; 3] {
     // 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);
@@ -768,13 +773,55 @@ fn euler_of(correction: effectcraft_geom::Mat4, orientation: [f64; 3]) -> [f64;
     [x.to_degrees(), y.to_degrees(), z.to_degrees()]
 }
 
-/// Static Orientation re-expressed as `correction * Orientation`. An identity correction keeps the
-/// authored values unchanged.
-fn reexpress_static(correction: effectcraft_geom::Mat4, orientation: [f64; 3]) -> [f64; 3] {
-    if (0..4).all(|row| (0..4).all(|col| (correction.0[row][col] - if row == col { 1.0 } else { 0.0 }).abs() < 1e-12)) {
-        return orientation;
+/// The equivalent ZYX Euler triple nearest `reference`: each axis moved by whole turns, or the
+/// `(x + 180, 180 - y, z + 180)` form when that is nearer.
+fn nearest_euler(euler: [f64; 3], reference: [f64; 3]) -> [f64; 3] {
+    let near = |v: [f64; 3]| -> [f64; 3] { std::array::from_fn(|i| v[i] + ((reference[i] - v[i]) / 360.0).round() * 360.0) };
+    let natural = near(euler);
+    let flipped = near([euler[0] + 180.0, 180.0 - euler[1], euler[2] + 180.0]);
+    let distance = |v: [f64; 3]| v.iter().zip(reference.iter()).map(|(a, b)| (a - b).powi(2)).sum::<f64>();
+    if distance(flipped) < distance(natural) { flipped } else { natural }
+}
+
+/// The Euler Orientation of `correction * Orientation(o)`, in the form nearest `reference`.
+fn reexpress_euler(correction: effectcraft_geom::Mat4, o: [f64; 3], reference: [f64; 3]) -> [f64; 3] {
+    let world = correction * effectcraft_geom::Mat4::orientation(effectcraft_geom::Vec3::from(o));
+    nearest_euler(euler_zyx(world.0), reference)
+}
+
+/// Re-expresses Orientation (the value and every key) as `correction * Orientation`. A Z-only
+/// correction shifts Z exactly, so the keys and the paths between them stay exact. Other
+/// corrections keep each key's authored turns, so the Euler values stay continuous.
+fn reexpress_orientation(correction: effectcraft_geom::Mat4, pr: &mut effectcraft_project::Property) {
+    if let Some(turn) = z_only_turn(correction) {
+        // No turn (an identity correction) leaves every authored value as it is.
+        if turn.abs() <= 1e-12 {
+            return;
+        }
+        let shift = |value: &KV| {
+            let [x, y, z] = value.as_vec3();
+            KV::Vec3([x, y, z + turn])
+        };
+        pr.value = shift(&pr.value);
+        for key in &mut pr.keys {
+            key.value = shift(&key.value);
+        }
+        return;
+    }
+    let value = pr.value.as_vec3();
+    pr.value = KV::Vec3(reexpress_euler(correction, value, value));
+    let mut prev: Option<([f64; 3], [f64; 3])> = None;
+    for key in &mut pr.keys {
+        let o = key.value.as_vec3();
+        // Each key keeps the authored change from the previous key on top of its converted value.
+        let reference = match prev {
+            Some((before, after)) => [after[0] + o[0] - before[0], after[1] + o[1] - before[1], after[2] + o[2] - before[2]],
+            None => o,
+        };
+        let n = reexpress_euler(correction, o, reference);
+        key.value = KV::Vec3(n);
+        prev = Some((o, n));
     }
-    euler_of(correction, orientation)
 }
 
 /// Correction for a two-node rig's Orientation: after a uniform parent change its aim is
@@ -848,13 +895,10 @@ pub(crate) fn parent_fixes(s: &Session, cid: ItemId, ids: &[LayerId], parent: Op
                     let orientation = tr.get("orientation")?;
                     // Cameras and lights have no Scale; their Orientation is re-expressed alone.
                     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.
-                    // Auto-orient replaces Orientation, except a two-node rig, whose roll is
-                    // re-expressed against its new aim.
+                    // Expression-driven values stay authored. Auto-orient replaces Orientation, except
+                    // a two-node rig, whose roll is re-expressed against its new aim.
                     let two_node = (layer.is_camera() || layer.is_light()) && effectcraft_render::three_d::camera::is_two_node(layer);
-                    if !orientation.keys.is_empty()
-                        || orientation.expr.is_some()
+                    if orientation.expr.is_some()
                         || scale.is_some_and(|scale| scale.expr.is_some())
                         || (layer.auto_orient != effectcraft_project::AutoOrient::Off && !two_node)
                     {
@@ -873,7 +917,10 @@ pub(crate) fn parent_fixes(s: &Session, cid: ItemId, ids: &[LayerId], parent: Op
                     } else {
                         rotation
                     };
-                    if !correction.0.iter().flatten().all(|v| v.is_finite()) || !orientation.value.as_vec3().iter().all(|v| v.is_finite()) {
+                    let orientation_finite = std::iter::once(&orientation.value)
+                        .chain(orientation.keys.iter().map(|key| &key.value))
+                        .all(|value| value.as_vec3().iter().all(|v| v.is_finite()));
+                    if !correction.0.iter().flatten().all(|v| v.is_finite()) || !orientation_finite {
                         return None;
                     }
                     if let Some(scale) = scale {
diff --git a/crates/engine/src/tests_rig3d.rs b/crates/engine/src/tests_rig3d.rs
index 6a13d8679..87bb98699 100644
--- a/crates/engine/src/tests_rig3d.rs
+++ b/crates/engine/src/tests_rig3d.rs
@@ -282,6 +282,24 @@ fn parented_point_light_keeps_its_direction_under_a_rotated_null() {
     assert!((eye1 - eye0).length() < 1e-6 && (f1 - f0).length() < 1e-6, "{eye0:?} {eye1:?} {f0:?} {f1:?}");
 }
 
+/// Keyed Orientation is re-expressed at each key under a rotated null, so the light keeps its
+/// direction at every key.
+#[test]
+fn keyed_orientation_is_re_expressed_at_each_key_under_a_rotated_null() {
+    let mut s = session();
+    let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+    for (time, value) in [(0.0, json!([-8.0, 12.0, -13.0])), (1.0, json!([5.0, 18.0, 14.0]))] {
+        s.execute("prop.addKey", json!({"layer": light, "path": "transform/orientation", "time": time, "value": value})).unwrap();
+    }
+    let keys = [Tick::ZERO, Tick::from_seconds_f64(1.0)];
+    let before = keys.map(|t| frame_at(&s, light, t));
+    let nul = rotated_null(&mut s, [20.0, -35.0, 60.0], 30.0);
+    s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
+    for (t, b) in keys.into_iter().zip(before) {
+        assert!(frames_match(b, frame_at(&s, light, t)), "keyed Orientation keeps the light's direction at each key");
+    }
+}
+
 // ---------------------------------------------------------------- from 3D model
 
 struct DiskModels;
diff --git a/crates/engine/tests/parenting_3d_position.rs b/crates/engine/tests/parenting_3d_position.rs
index 6bf0c4ff1..3737d16e2 100644
--- a/crates/engine/tests/parenting_3d_position.rs
+++ b/crates/engine/tests/parenting_3d_position.rs
@@ -410,12 +410,12 @@ fn parenting_static_orientation_is_exact_just_off_gimbal_lock() {
 fn parenting_animated_orientation_and_nonuniform_parent_keep_authored_pose_boundary() {
     for animated in [true, false] {
         let (mut s, p, c) = fixture(true, true);
+        // A non-uniform parent has no uniform pose to re-express, animated or not.
+        set(&mut s, p, "transform/scale", json!([120.0, 100.0, 80.0]));
         if animated {
             for (time, value) in [(0.0, json!([-8.0, 12.0, -13.0])), (1.0, json!([5.0, 18.0, 14.0]))] {
                 command(&mut s, "prop.addKey", json!({"layer":c,"path":"transform/orientation","time":time,"value":value}));
             }
-        } else {
-            set(&mut s, p, "transform/scale", json!([120.0, 100.0, 80.0]));
         }
         let layer = s.active_comp().unwrap().layer(LayerId(c)).unwrap();
         let orientation = layer.props.prop("transform/orientation").unwrap().clone();
@@ -430,6 +430,27 @@ fn parenting_animated_orientation_and_nonuniform_parent_keep_authored_pose_bound
     }
 }
 
+/// Keyed Orientation under a uniform parent is re-expressed at every key, so the child's world pose
+/// and pixels stay put at every time (the parent is Z-only, so the paths between keys stay exact too).
+#[test]
+fn parenting_uniform_parent_re_expresses_keyed_orientation() {
+    for factor in [120.0, -120.0] {
+        let (mut s, p, c) = fixture(true, false);
+        set(&mut s, p, "transform/rotation", json!(42.0));
+        set(&mut s, p, "transform/scale", json!([factor, factor, factor]));
+        for (time, value) in [(0.0, json!([-8.0, 12.0, -13.0])), (1.0, json!([5.0, 18.0, 14.0]))] {
+            command(&mut s, "prop.addKey", json!({"layer":c,"path":"transform/orientation","time":time,"value":value}));
+        }
+        let times = [0.0, 0.25, 0.5, 0.75, 1.0].map(Tick::from_seconds_f64);
+        let before = times.map(|t| world(&s, c, t));
+        let images = times.map(|t| cpu(&s, t));
+        parent(&mut s, c, Some(p), true);
+        let error = times.into_iter().zip(before).map(|(t, b)| displacement(b, world(&s, c, t))).fold(0.0, f64::max);
+        let pixels = times.into_iter().zip(&images).map(|(t, i)| diff(i, &cpu(&s, t))).fold(0.0, f32::max);
+        assert!(error < 1e-8 && pixels < 2e-5, "keyed Orientation under a uniform parent (factor {factor}): corners {error}, pixels {pixels}");
+    }
+}
+
 /// Position's temporal speed is measured along its spatial path, in parent-space units.
 #[test]
 fn parenting_uniform_parent_preserves_eased_position_at_quarter_times_and_undo() {

From 95f2f3ec5528fd2d51716cd48fd043480c4a245f Mon Sep 17 00:00:00 2001
From: Kristian Myram <kristian.myram@gmail.com>
Date: Tue, 13 Oct 2026 02:52:08 +0200
Subject: [PATCH 5/9] #1010: leave keyed Orientation authored under a tilted
 parent

Euler angles are blended between keys, so re-expressing only the key values cannot keep the motion
between them under a tilted parent. Keyed Orientation is now re-expressed only for a Z-only
correction, which shifts Z exactly at every time; static Orientation is unchanged.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/engine/src/commands/layer.rs | 23 ++++++++-------------
 crates/engine/src/tests_rig3d.rs    | 32 +++++++++++++++++++++--------
 2 files changed, 32 insertions(+), 23 deletions(-)

diff --git a/crates/engine/src/commands/layer.rs b/crates/engine/src/commands/layer.rs
index 8222ad34e..7208c1ff1 100644
--- a/crates/engine/src/commands/layer.rs
+++ b/crates/engine/src/commands/layer.rs
@@ -789,9 +789,10 @@ fn reexpress_euler(correction: effectcraft_geom::Mat4, o: [f64; 3], reference: [
     nearest_euler(euler_zyx(world.0), reference)
 }
 
-/// Re-expresses Orientation (the value and every key) as `correction * Orientation`. A Z-only
-/// correction shifts Z exactly, so the keys and the paths between them stay exact. Other
-/// corrections keep each key's authored turns, so the Euler values stay continuous.
+/// Re-expresses Orientation as `correction * Orientation`. A Z-only correction shifts Z exactly in the
+/// value and every key, so the paths between keys stay exact too. Any other correction is applied
+/// only to a static value (`parent_fixes` leaves keyed Orientation alone then): Euler angles are
+/// blended between keys, which no re-expression of the keys can reproduce.
 fn reexpress_orientation(correction: effectcraft_geom::Mat4, pr: &mut effectcraft_project::Property) {
     if let Some(turn) = z_only_turn(correction) {
         // No turn (an identity correction) leaves every authored value as it is.
@@ -810,18 +811,6 @@ fn reexpress_orientation(correction: effectcraft_geom::Mat4, pr: &mut effectcraf
     }
     let value = pr.value.as_vec3();
     pr.value = KV::Vec3(reexpress_euler(correction, value, value));
-    let mut prev: Option<([f64; 3], [f64; 3])> = None;
-    for key in &mut pr.keys {
-        let o = key.value.as_vec3();
-        // Each key keeps the authored change from the previous key on top of its converted value.
-        let reference = match prev {
-            Some((before, after)) => [after[0] + o[0] - before[0], after[1] + o[1] - before[1], after[2] + o[2] - before[2]],
-            None => o,
-        };
-        let n = reexpress_euler(correction, o, reference);
-        key.value = KV::Vec3(n);
-        prev = Some((o, n));
-    }
 }
 
 /// Correction for a two-node rig's Orientation: after a uniform parent change its aim is
@@ -923,6 +912,10 @@ pub(crate) fn parent_fixes(s: &Session, cid: ItemId, ids: &[LayerId], parent: Op
                     if !correction.0.iter().flatten().all(|v| v.is_finite()) || !orientation_finite {
                         return None;
                     }
+                    // Keys can only follow a Z-only correction exactly; otherwise they stay authored.
+                    if !orientation.keys.is_empty() && z_only_turn(correction).is_none() {
+                        return None;
+                    }
                     if let Some(scale) = scale {
                         let values_finite = std::iter::once(&scale.value)
                             .chain(scale.keys.iter().map(|key| &key.value))
diff --git a/crates/engine/src/tests_rig3d.rs b/crates/engine/src/tests_rig3d.rs
index 87bb98699..ecae51cb1 100644
--- a/crates/engine/src/tests_rig3d.rs
+++ b/crates/engine/src/tests_rig3d.rs
@@ -282,22 +282,38 @@ fn parented_point_light_keeps_its_direction_under_a_rotated_null() {
     assert!((eye1 - eye0).length() < 1e-6 && (f1 - f0).length() < 1e-6, "{eye0:?} {eye1:?} {f0:?} {f1:?}");
 }
 
-/// Keyed Orientation is re-expressed at each key under a rotated null, so the light keeps its
-/// direction at every key.
+/// Keyed Orientation under a Z-only turn is shifted exactly, so the light keeps its direction at
+/// every time, between the keys too.
 #[test]
-fn keyed_orientation_is_re_expressed_at_each_key_under_a_rotated_null() {
+fn keyed_orientation_under_a_z_turn_keeps_the_direction_at_every_time() {
     let mut s = session();
     let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
     for (time, value) in [(0.0, json!([-8.0, 12.0, -13.0])), (1.0, json!([5.0, 18.0, 14.0]))] {
         s.execute("prop.addKey", json!({"layer": light, "path": "transform/orientation", "time": time, "value": value})).unwrap();
     }
-    let keys = [Tick::ZERO, Tick::from_seconds_f64(1.0)];
-    let before = keys.map(|t| frame_at(&s, light, t));
+    let times = [0.0, 0.25, 0.5, 0.75, 1.0].map(Tick::from_seconds_f64);
+    let before = times.map(|t| frame_at(&s, light, t));
+    let nul = rotated_null(&mut s, [0.0, 0.0, 0.0], 30.0);
+    s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
+    for (t, b) in times.into_iter().zip(before) {
+        assert!(frames_match(b, frame_at(&s, light, t)), "a Z-only turn keeps the light's direction");
+    }
+}
+
+/// Under a tilted null the keys cannot follow exactly (Euler angles are blended between them), so
+/// keyed Orientation stays as authored rather than changing the motion between the keys.
+#[test]
+fn keyed_orientation_under_a_tilted_null_stays_authored() {
+    let mut s = session();
+    let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+    for (time, value) in [(0.0, json!([-8.0, 12.0, -13.0])), (1.0, json!([5.0, 18.0, 14.0]))] {
+        s.execute("prop.addKey", json!({"layer": light, "path": "transform/orientation", "time": time, "value": value})).unwrap();
+    }
+    let keys_before = layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().keys.iter().map(|k| k.value.as_vec3()).collect::<Vec<_>>();
     let nul = rotated_null(&mut s, [20.0, -35.0, 60.0], 30.0);
     s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
-    for (t, b) in keys.into_iter().zip(before) {
-        assert!(frames_match(b, frame_at(&s, light, t)), "keyed Orientation keeps the light's direction at each key");
-    }
+    let keys_after = layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().keys.iter().map(|k| k.value.as_vec3()).collect::<Vec<_>>();
+    assert_eq!(keys_before, keys_after);
 }
 
 // ---------------------------------------------------------------- from 3D model

From e78f115d71ca5ab4ec9fc4e073836cb3cb445ccc Mon Sep 17 00:00:00 2001
From: Kristian Myram <kristian.myram@gmail.com>
Date: Tue, 13 Oct 2026 02:57:25 +0200
Subject: [PATCH 6/9] #1010: add keys so keyed Orientation follows a tilted
 parent between the keys

Under a tilted parent, the converted keys alone give a different path between them, since Euler
angles are blended. Keys are now added wherever the blend drifts more than 0.05 degrees from the
exact rotation (halving each segment, at most 10 times and 4096 keys). The segments become straight
blends with the original easing baked in; hold segments are kept.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 crates/engine/src/commands/layer.rs | 95 ++++++++++++++++++++++++++---
 crates/engine/src/tests_rig3d.rs    | 31 ++++++----
 2 files changed, 107 insertions(+), 19 deletions(-)

diff --git a/crates/engine/src/commands/layer.rs b/crates/engine/src/commands/layer.rs
index 7208c1ff1..c112a4912 100644
--- a/crates/engine/src/commands/layer.rs
+++ b/crates/engine/src/commands/layer.rs
@@ -789,10 +789,48 @@ fn reexpress_euler(correction: effectcraft_geom::Mat4, o: [f64; 3], reference: [
     nearest_euler(euler_zyx(world.0), reference)
 }
 
+/// Largest angle (degrees) a baked Orientation may drift from the exact rotation between its keys.
+const BAKE_TOLERANCE_DEGREES: f64 = 0.05;
+/// How many times a segment may be halved while baking, and the most keys a property may end up with.
+const BAKE_MAX_DEPTH: u32 = 10;
+const BAKE_MAX_KEYS: usize = 4096;
+
+/// The angle (degrees) between two rotations.
+fn rotation_angle(a: effectcraft_geom::Mat4, b: effectcraft_geom::Mat4) -> f64 {
+    let trace: f64 = (0..3).flat_map(|i| (0..3).map(move |j| (i, j))).map(|(i, j)| a.0[i][j] * b.0[i][j]).sum();
+    ((trace - 1.0) / 2.0).clamp(-1.0, 1.0).acos().to_degrees()
+}
+
+/// Adds keys between `(ta, ea)` and `(tb, eb)` (already converted) wherever the straight Euler blend
+/// between them drifts from `correction * Orientation(authored)` by more than the tolerance.
+fn bake_between(
+    correction: effectcraft_geom::Mat4,
+    authored: &effectcraft_project::Property,
+    (ta, ea): (Tick, [f64; 3]),
+    (tb, eb): (Tick, [f64; 3]),
+    depth: u32,
+    out: &mut Vec<effectcraft_keyframe::Keyframe>,
+) {
+    use effectcraft_geom::{Mat4, Vec3};
+    if depth == 0 || tb.0 - ta.0 < 2 || out.len() >= BAKE_MAX_KEYS {
+        return;
+    }
+    let tm = Tick(ta.0 + (tb.0 - ta.0) / 2);
+    let blend = [(ea[0] + eb[0]) / 2.0, (ea[1] + eb[1]) / 2.0, (ea[2] + eb[2]) / 2.0];
+    let exact = correction * Mat4::orientation(Vec3::from(authored.value_at(tm).as_vec3()));
+    if rotation_angle(Mat4::orientation(Vec3::from(blend)), exact) <= BAKE_TOLERANCE_DEGREES {
+        return;
+    }
+    let em = nearest_euler(euler_zyx(exact.0), blend);
+    bake_between(correction, authored, (ta, ea), (tm, em), depth - 1, out);
+    out.push(effectcraft_keyframe::Keyframe::new(tm, KV::Vec3(em)));
+    bake_between(correction, authored, (tm, em), (tb, eb), depth - 1, out);
+}
+
 /// Re-expresses Orientation as `correction * Orientation`. A Z-only correction shifts Z exactly in the
-/// value and every key, so the paths between keys stay exact too. Any other correction is applied
-/// only to a static value (`parent_fixes` leaves keyed Orientation alone then): Euler angles are
-/// blended between keys, which no re-expression of the keys can reproduce.
+/// value and every key. For any other correction a static value is converted directly; keys are
+/// converted, and keys are added between them wherever the Euler blend between two keys would drift
+/// from the exact rotation (the segments become linear, with the original easing baked in).
 fn reexpress_orientation(correction: effectcraft_geom::Mat4, pr: &mut effectcraft_project::Property) {
     if let Some(turn) = z_only_turn(correction) {
         // No turn (an identity correction) leaves every authored value as it is.
@@ -811,6 +849,53 @@ fn reexpress_orientation(correction: effectcraft_geom::Mat4, pr: &mut effectcraf
     }
     let value = pr.value.as_vec3();
     pr.value = KV::Vec3(reexpress_euler(correction, value, value));
+    if pr.keys.is_empty() {
+        return;
+    }
+    let authored = pr.clone();
+    // Each key keeps the authored change from the previous key on top of its converted value.
+    let mut converted: Vec<[f64; 3]> = vec![];
+    let mut prev: Option<([f64; 3], [f64; 3])> = None;
+    for key in &authored.keys {
+        let o = key.value.as_vec3();
+        let reference = match prev {
+            Some((before, after)) => [after[0] + o[0] - before[0], after[1] + o[1] - before[1], after[2] + o[2] - before[2]],
+            None => o,
+        };
+        let n = reexpress_euler(correction, o, reference);
+        converted.push(n);
+        prev = Some((o, n));
+    }
+    use effectcraft_keyframe::Interp;
+    let mut keys: Vec<effectcraft_keyframe::Keyframe> = vec![];
+    let mut after_baked_segment = false;
+    for (i, key) in authored.keys.iter().enumerate() {
+        let mut k = key.clone();
+        k.value = KV::Vec3(converted[i]);
+        if after_baked_segment {
+            k.in_interp = Interp::Linear;
+            k.in_ease.clear();
+            k.auto_bezier = false;
+            k.continuous = false;
+        }
+        after_baked_segment = false;
+        let segment = authored.keys.get(i + 1).filter(|_| key.out_interp != Interp::Hold);
+        let mut between = vec![];
+        if let Some(next) = segment {
+            bake_between(correction, &authored, (key.time, converted[i]), (next.time, converted[i + 1]), BAKE_MAX_DEPTH, &mut between);
+            // An eased segment, or one that gained keys, becomes a run of straight blends.
+            if !between.is_empty() || key.out_interp != Interp::Linear || next.in_interp != Interp::Linear {
+                k.out_interp = Interp::Linear;
+                k.out_ease.clear();
+                k.auto_bezier = false;
+                k.continuous = false;
+                after_baked_segment = true;
+            }
+        }
+        keys.push(k);
+        keys.extend(between);
+    }
+    pr.keys = keys;
 }
 
 /// Correction for a two-node rig's Orientation: after a uniform parent change its aim is
@@ -912,10 +997,6 @@ pub(crate) fn parent_fixes(s: &Session, cid: ItemId, ids: &[LayerId], parent: Op
                     if !correction.0.iter().flatten().all(|v| v.is_finite()) || !orientation_finite {
                         return None;
                     }
-                    // Keys can only follow a Z-only correction exactly; otherwise they stay authored.
-                    if !orientation.keys.is_empty() && z_only_turn(correction).is_none() {
-                        return None;
-                    }
                     if let Some(scale) = scale {
                         let values_finite = std::iter::once(&scale.value)
                             .chain(scale.keys.iter().map(|key| &key.value))
diff --git a/crates/engine/src/tests_rig3d.rs b/crates/engine/src/tests_rig3d.rs
index ecae51cb1..d867337ac 100644
--- a/crates/engine/src/tests_rig3d.rs
+++ b/crates/engine/src/tests_rig3d.rs
@@ -300,20 +300,27 @@ fn keyed_orientation_under_a_z_turn_keeps_the_direction_at_every_time() {
     }
 }
 
-/// Under a tilted null the keys cannot follow exactly (Euler angles are blended between them), so
-/// keyed Orientation stays as authored rather than changing the motion between the keys.
+/// Under a tilted null the keys alone cannot follow (Euler angles are blended between them), so keys are
+/// added between them: the light keeps its direction within a small angle at every time.
 #[test]
-fn keyed_orientation_under_a_tilted_null_stays_authored() {
-    let mut s = session();
-    let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
-    for (time, value) in [(0.0, json!([-8.0, 12.0, -13.0])), (1.0, json!([5.0, 18.0, 14.0]))] {
-        s.execute("prop.addKey", json!({"layer": light, "path": "transform/orientation", "time": time, "value": value})).unwrap();
+fn keyed_orientation_under_a_tilted_null_follows_between_the_keys() {
+    {
+        let mut s = session();
+        let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+        for (time, value) in [(0.0, json!([-8.0, 12.0, -13.0])), (1.5, json!([50.0, 118.0, 74.0]))] {
+            s.execute("prop.addKey", json!({"layer": light, "path": "transform/orientation", "time": time, "value": value})).unwrap();
+        }
+        let times = [0.0, 0.2, 0.5, 0.9, 1.3, 1.5].map(Tick::from_seconds_f64);
+        let before = times.map(|t| frame_at(&s, light, t));
+        let nul = rotated_null(&mut s, [20.0, -35.0, 60.0], 30.0);
+        s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
+        for (t, b) in times.into_iter().zip(before) {
+            let a = frame_at(&s, light, t);
+            // 0.05 degrees is about 9e-4 of a radian on a unit vector.
+            assert!((a.0 - b.0).length() < 1e-6 && (a.1 - b.1).length() < 2e-3, "at {t:?}: {:?} vs {:?}", a.1, b.1);
+        }
+        assert!(layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().keys.len() > 2, "keys were added between the two");
     }
-    let keys_before = layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().keys.iter().map(|k| k.value.as_vec3()).collect::<Vec<_>>();
-    let nul = rotated_null(&mut s, [20.0, -35.0, 60.0], 30.0);
-    s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
-    let keys_after = layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().keys.iter().map(|k| k.value.as_vec3()).collect::<Vec<_>>();
-    assert_eq!(keys_before, keys_after);
 }
 
 // ---------------------------------------------------------------- from 3D model

From f64cd5ce381e3d7e1863eef2ce3599f3a6e262a0 Mon Sep 17 00:00:00 2001
From: Kristian Myram <kristian.myram@gmail.com>
Date: Sat, 17 Oct 2026 20:44:28 +0000
Subject: [PATCH 7/9] 1010: preserve easing while baking parented Orientation

---
 crates/engine/src/commands/layer.rs | 10 +++++++++-
 crates/engine/src/tests_rig3d.rs    | 21 +++++++++++++++++++++
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/crates/engine/src/commands/layer.rs b/crates/engine/src/commands/layer.rs
index 123a81471..e26f0279b 100644
--- a/crates/engine/src/commands/layer.rs
+++ b/crates/engine/src/commands/layer.rs
@@ -818,7 +818,15 @@ fn bake_between(
     let tm = Tick(ta.0 + (tb.0 - ta.0) / 2);
     let blend = [(ea[0] + eb[0]) / 2.0, (ea[1] + eb[1]) / 2.0, (ea[2] + eb[2]) / 2.0];
     let exact = correction * Mat4::orientation(Vec3::from(authored.value_at(tm).as_vec3()));
-    if rotation_angle(Mat4::orientation(Vec3::from(blend)), exact) <= BAKE_TOLERANCE_DEGREES {
+    // Symmetric easing crosses the straight blend at its midpoint. Check both sides too before
+    // accepting a segment whose original easing will be replaced with a linear blend.
+    let quarter = (tb.0 - ta.0) / 4;
+    if [Tick(ta.0 + quarter), tm, Tick(tb.0 - quarter)].into_iter().all(|t| {
+        let u = (t.0 - ta.0) as f64 / (tb.0 - ta.0) as f64;
+        let linear = std::array::from_fn(|i| ea[i] + (eb[i] - ea[i]) * u);
+        let target = correction * Mat4::orientation(Vec3::from(authored.value_at(t).as_vec3()));
+        rotation_angle(Mat4::orientation(Vec3::from(linear)), target) <= BAKE_TOLERANCE_DEGREES
+    }) {
         return;
     }
     let em = nearest_euler(euler_zyx(exact.0), blend);
diff --git a/crates/engine/src/tests_rig3d.rs b/crates/engine/src/tests_rig3d.rs
index d867337ac..595d3d7c5 100644
--- a/crates/engine/src/tests_rig3d.rs
+++ b/crates/engine/src/tests_rig3d.rs
@@ -325,6 +325,27 @@ fn keyed_orientation_under_a_tilted_null_follows_between_the_keys() {
 
 // ---------------------------------------------------------------- from 3D model
 
+/// Easy Ease agrees with a straight blend at the midpoint, but not at the quarter points.
+#[test]
+fn eased_orientation_under_x_parent_keeps_motion_between_keys() {
+    let mut s = session();
+    let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+    for (time, value) in [(0.0, json!([0.0, 0.0, 0.0])), (1.0, json!([90.0, 0.0, 0.0]))] {
+        s.execute("prop.addKey", json!({"layer": light, "path": "transform/orientation", "time": time, "value": value})).unwrap();
+    }
+    let uid = layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().uid;
+    s.execute("keys.select", json!({"keys": [{"layer": light, "prop": uid, "time": 0.0}, {"layer": light, "prop": uid, "time": 1.0}]})).unwrap();
+    s.execute("keys.easyEase", json!({})).unwrap();
+    let times: Vec<_> = (0..=100).map(|i| Tick::from_seconds_f64(i as f64 / 100.0)).collect();
+    let before: Vec<_> = times.iter().map(|t| frame_at(&s, light, *t)).collect();
+    let parent = rotated_null(&mut s, [30.0, 0.0, 0.0], 0.0);
+    s.execute("layer.setParent", json!({"layers": [light], "parent": parent})).unwrap();
+    for (t, b) in times.into_iter().zip(before) {
+        let a = frame_at(&s, light, t);
+        assert!((a.0 - b.0).length() < 1e-6 && (a.1 - b.1).length() < 1e-3, "at {t:?}: {:?} vs {:?}", a.1, b.1);
+    }
+}
+
 struct DiskModels;
 
 impl FootageSource for DiskModels {

From b0be02fff41049603e422b82493525a039daaf1c Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 29 Oct 2026 11:52:23 +0000
Subject: [PATCH 8/9] 1010: cap baked Orientation keys per property; leave
 one-node rigs under a mirrored parent as authored

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RDvxCS8xcR28VArjzn1x7U
---
 crates/engine/src/cmd/layer/parent.rs | 25 +++++++++++++----
 crates/engine/src/tests/rig3d.rs      | 39 +++++++++++++++++++++++++++
 2 files changed, 59 insertions(+), 5 deletions(-)

diff --git a/crates/engine/src/cmd/layer/parent.rs b/crates/engine/src/cmd/layer/parent.rs
index 64195d646..dd4c842a2 100644
--- a/crates/engine/src/cmd/layer/parent.rs
+++ b/crates/engine/src/cmd/layer/parent.rs
@@ -220,17 +220,19 @@ fn rotation_angle(a: effectcraft_geom::Mat4, b: effectcraft_geom::Mat4) -> f64 {
 }
 
 /// Adds keys between `(ta, ea)` and `(tb, eb)` (already converted) wherever the straight Euler blend
-/// between them drifts from `correction * Orientation(authored)` by more than the tolerance.
+/// between them drifts from `correction * Orientation(authored)` by more than the tolerance. `out`
+/// never grows past `budget` keys: what the whole property may still add, not what one segment may.
 fn bake_between(
     correction: effectcraft_geom::Mat4,
     authored: &effectcraft_project::Property,
     (ta, ea): (Tick, [f64; 3]),
     (tb, eb): (Tick, [f64; 3]),
     depth: u32,
+    budget: usize,
     out: &mut Vec<effectcraft_keyframe::Keyframe>,
 ) {
     use effectcraft_geom::{Mat4, Vec3};
-    if depth == 0 || tb.0 - ta.0 < 2 || out.len() >= BAKE_MAX_KEYS {
+    if depth == 0 || tb.0 - ta.0 < 2 || out.len() >= budget {
         return;
     }
     let tm = Tick(ta.0 + (tb.0 - ta.0) / 2);
@@ -248,9 +250,12 @@ fn bake_between(
         return;
     }
     let em = nearest_euler(euler_zyx(exact.0), blend);
-    bake_between(correction, authored, (ta, ea), (tm, em), depth - 1, out);
+    bake_between(correction, authored, (ta, ea), (tm, em), depth - 1, budget, out);
+    if out.len() >= budget {
+        return;
+    }
     out.push(effectcraft_keyframe::Keyframe::new(tm, KV::Vec3(em)));
-    bake_between(correction, authored, (tm, em), (tb, eb), depth - 1, out);
+    bake_between(correction, authored, (tm, em), (tb, eb), depth - 1, budget, out);
 }
 
 /// Re-expresses Orientation as `correction * Orientation`. A Z-only correction shifts Z exactly in the
@@ -308,7 +313,10 @@ fn reexpress_orientation(correction: effectcraft_geom::Mat4, pr: &mut effectcraf
         let segment = authored.keys.get(i + 1).filter(|_| key.out_interp != Interp::Hold);
         let mut between = vec![];
         if let Some(next) = segment {
-            bake_between(correction, &authored, (key.time, converted[i]), (next.time, converted[i + 1]), BAKE_MAX_DEPTH, &mut between);
+            // What the whole property may still add: the keys it will have already (the ones written
+            // and the authored ones still to come) count against the cap.
+            let budget = BAKE_MAX_KEYS.saturating_sub(keys.len() + authored.keys.len() - i);
+            bake_between(correction, &authored, (key.time, converted[i]), (next.time, converted[i + 1]), BAKE_MAX_DEPTH, budget, &mut between);
             // An eased segment, or one that gained keys, becomes a run of straight blends.
             if !between.is_empty() || key.out_interp != Interp::Linear || next.in_interp != Interp::Linear {
                 k.out_interp = Interp::Linear;
@@ -391,6 +399,13 @@ pub(crate) fn parent_fixes(s: &Session, cid: ItemId, ids: &[LayerId], parent: Op
     if let Some(inv) = space_3d(parent).inverse().filter(|m| m.0.iter().flatten().all(|v| v.is_finite())) {
         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);
+            // A one-node camera or light has no Scale to carry a mirror, and its frame (forward and
+            // down) would come out reversed: compensate none of it, so Position and Orientation stay
+            // as authored instead of half-following the parent.
+            let rig = layer.is_camera() || layer.is_light();
+            if rig && !effectcraft_render::three_d::camera::is_two_node(layer) && uniform_rotation(m).is_some_and(|(_, factor)| factor <= 0.0) {
+                continue;
+            }
             if m.0.iter().flatten().all(|v| v.is_finite()) {
                 let pose_3d = layer.transform().and_then(|tr| {
                     let orientation = tr.get("orientation")?;
diff --git a/crates/engine/src/tests/rig3d.rs b/crates/engine/src/tests/rig3d.rs
index 059e74fbc..0fef2434c 100644
--- a/crates/engine/src/tests/rig3d.rs
+++ b/crates/engine/src/tests/rig3d.rs
@@ -333,6 +333,45 @@ fn keyed_orientation_under_a_tilted_null_follows_between_the_keys() {
     }
 }
 
+/// A one-node light parented under a mirrored null (Z scale -100%) keeps the Position and
+/// Orientation it was authored with: it has no Scale to carry the mirror, so none of it is
+/// compensated rather than reversing its frame (a half-compensated light would point backwards).
+#[test]
+fn one_node_light_under_a_mirrored_null_keeps_its_authored_values() {
+    let mut s = session();
+    let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+    s.execute("prop.set", json!({"layer": light, "path": "transform/orientation", "value": [30, 0, 0]})).unwrap();
+    let before = layer_in(&s, cid(&s), light);
+    let nul = rotated_null(&mut s, [0.0, 0.0, 0.0], 0.0);
+    s.execute("prop.set", json!({"layer": nul, "path": "transform/scale", "value": [100, 100, -100]})).unwrap();
+    s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
+    let after = layer_in(&s, cid(&s), light);
+    assert_eq!(after.parent, Some(LayerId(nul)));
+    assert_eq!(v3(&after, "transform/position"), v3(&before, "transform/position"));
+    assert_eq!(v3(&after, "transform/orientation"), v3(&before, "transform/orientation"));
+}
+
+/// The cap on keys added by baking is for the whole Orientation property, not for each segment:
+/// many strongly eased segments under a tilted parent stay within it.
+#[test]
+fn baked_orientation_keys_are_capped_across_the_whole_property() {
+    let mut s = session();
+    let light = s.execute("layer.newLight", json!({"kind": "Point", "position": [320, 180, -500]})).unwrap()["layer"].as_u64().unwrap();
+    let count = 120;
+    for i in 0..count {
+        let swing = if i % 2 == 0 { json!([0.0, 0.0, 0.0]) } else { json!([170.0, 60.0, 120.0]) };
+        s.execute("prop.addKey", json!({"layer": light, "path": "transform/orientation", "time": i as f64 * 0.05, "value": swing})).unwrap();
+    }
+    let uid = layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().uid;
+    let keys: Vec<_> = (0..count).map(|i| json!({"layer": light, "prop": uid, "time": i as f64 * 0.05})).collect();
+    s.execute("keys.select", json!({"keys": keys})).unwrap();
+    s.execute("keys.easyEase", json!({})).unwrap();
+    let nul = rotated_null(&mut s, [20.0, -35.0, 60.0], 30.0);
+    s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
+    let n = layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().keys.len();
+    assert!(n <= 4096, "{n} keys: the cap is for the property, not per segment");
+}
+
 // ---------------------------------------------------------------- from 3D model
 
 /// Easy Ease agrees with a straight blend at the midpoint, but not at the quarter points.

From 77050532a4ed0b49d48ba9e90a64f2c007068fb7 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Thu, 29 Oct 2026 13:50:56 +0000
Subject: [PATCH 9/9] 1010: keep authored easing on segments the baking cap
 leaves unchecked

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RDvxCS8xcR28VArjzn1x7U
---
 crates/engine/src/cmd/layer/parent.rs | 6 +++++-
 crates/engine/src/tests/rig3d.rs      | 5 +++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/crates/engine/src/cmd/layer/parent.rs b/crates/engine/src/cmd/layer/parent.rs
index dd4c842a2..8b345a95f 100644
--- a/crates/engine/src/cmd/layer/parent.rs
+++ b/crates/engine/src/cmd/layer/parent.rs
@@ -317,8 +317,12 @@ fn reexpress_orientation(correction: effectcraft_geom::Mat4, pr: &mut effectcraf
             // and the authored ones still to come) count against the cap.
             let budget = BAKE_MAX_KEYS.saturating_sub(keys.len() + authored.keys.len() - i);
             bake_between(correction, &authored, (key.time, converted[i]), (next.time, converted[i + 1]), BAKE_MAX_DEPTH, budget, &mut between);
+            // With the cap reached the segment can't be checked or subdivided: it keeps its authored easing between
+            // the converted keys, rather than becoming a straight blend that was never checked against the original.
+            if between.len() >= budget {
+                between.clear();
             // An eased segment, or one that gained keys, becomes a run of straight blends.
-            if !between.is_empty() || key.out_interp != Interp::Linear || next.in_interp != Interp::Linear {
+            } else if !between.is_empty() || key.out_interp != Interp::Linear || next.in_interp != Interp::Linear {
                 k.out_interp = Interp::Linear;
                 k.out_ease.clear();
                 k.auto_bezier = false;
diff --git a/crates/engine/src/tests/rig3d.rs b/crates/engine/src/tests/rig3d.rs
index 0fef2434c..4c7c4edab 100644
--- a/crates/engine/src/tests/rig3d.rs
+++ b/crates/engine/src/tests/rig3d.rs
@@ -370,6 +370,11 @@ fn baked_orientation_keys_are_capped_across_the_whole_property() {
     s.execute("layer.setParent", json!({"layers": [light], "parent": nul})).unwrap();
     let n = layer_in(&s, cid(&s), light).props.prop("transform/orientation").unwrap().keys.len();
     assert!(n <= 4096, "{n} keys: the cap is for the property, not per segment");
+    // the segments the cap left unchecked keep their authored easing instead of turning into straight blends
+    let orientation = layer_in(&s, cid(&s), light);
+    let keys = &orientation.props.prop("transform/orientation").unwrap().keys;
+    let last = keys.iter().rev().nth(1).expect("the penultimate key");
+    assert_ne!(last.out_interp, effectcraft_keyframe::Interp::Linear, "the last segment keeps its authored easing");
 }
 
 // ---------------------------------------------------------------- from 3D model