EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Rotation tool: keep counting past a full turn, as in After Effects
Themolxe9c8d703a7f1
diff --git a/crates/ui-egui/src/panels/viewer.rs b/crates/ui-egui/src/panels/viewer.rsindex cbb842d91..fe583c8ce 100644--- a/crates/ui-egui/src/panels/viewer.rs+++ b/crates/ui-egui/src/panels/viewer.rs@@ -91,7 +91,11 @@ enum Gesture {Rotate {layer: LayerId,center: Pos2,- start_angle: f64,+ /// The pointer's angle about the centre on the last frame (degrees, as atan2 gives it).+ last_angle: f64,+ /// The turn so far, summed frame by frame so it keeps counting past a full revolution in+ /// either direction (After Effects: 1x +0.0°, −1x −90.0°…) instead of wrapping at ±180°.+ turned: f64,start_rot: f64,/// The other selected layers and their rotations: they turn by the same angle.others: Vec<(LayerId, f64)>,@@ -447,6 +451,26 @@ fn snap_handle(f: [f64; 2], h: [f64; 2], a: [f64; 2], l2c: &Mat3, axes: [bool; 2[0, 1].map(|k| if axes[k] && h[k].abs() > 1e-9 { q[k] / h[k] } else { f[k] })}+/// The turn from angle `from` to angle `to` (degrees), wrapped to (−180°, 180°]: the shortest way+/// round, so summing it frame by frame follows the pointer across atan2's ±180° seam and past full+/// revolutions. Non-finite input turns by nothing.+fn turn_delta(from: f64, to: f64) -> f64 {+ let d = to - from;+ if !d.is_finite() {+ return 0.0;+ }+ let w = (d + 180.0).rem_euclid(360.0) - 180.0;+ if w <= -180.0 { w + 360.0 } else { w }+}++/// The Rotation tool's value: the rotation as the drag began plus the turn so far (which may span+/// revolutions), snapped to 45° steps with Shift.+fn rotate_value(start_rot: f64, turned: f64, shift: bool) -> f64 {+ let r = start_rot + turned;+ let r = if r.is_finite() { r } else { start_rot };+ if shift { (r / 45.0).round() * 45.0 } else { r }+}+/// A drag `d` (comp pixels), kept to the axis it moves along most when `shift` is held.fn one_axis(d: [f64; 2], shift: bool) -> [f64; 2] {if !shift {@@ -1368,7 +1392,8 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {Gesture::Rotate {layer: l,center,- start_angle: ((pos.y - center.y) as f64).atan2((pos.x - center.x) as f64).to_degrees(),+ last_angle: ((pos.y - center.y) as f64).atan2((pos.x - center.x) as f64).to_degrees(),+ turned: 0.0,start_rot: rot,others,}@@ -1570,12 +1595,14 @@ pub fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, rect: Rect) {let _ = app.session.execute("prop.set", json!({"layer": lid.0, "path": "transform/scale", "value": v, "merge": merge}));}}- Gesture::Rotate { layer, center, start_angle, start_rot, others } => {+ Gesture::Rotate { layer, center, last_angle, turned, start_rot, others } => {+ // Count the turn incrementally: the absolute angle wraps at ±180°, so writing it+ // straight would jump a revolution back each time the pointer went round.let ang = ((pos.y - center.y) as f64).atan2((pos.x - center.x) as f64).to_degrees();- let mut r = start_rot + (ang - start_angle);- if mods.shift {- r = (r / 45.0).round() * 45.0;- }+ let turned = turned + turn_delta(last_angle, ang);+ ui.data_mut(|dd| dd.insert_temp(gid, Gesture::Rotate { layer, center, last_angle: ang, turned, start_rot, others: others.clone() }));+ // Shift snaps the accumulated value (so 405° snaps to 1x +45°, not to 45°).+ let r = rotate_value(start_rot, turned, mods.shift);let _ = app.session.execute("prop.set", json!({"layer": layer.0, "path": "transform/rotation", "value": r, "merge": merge}));for (lid, r0) in others {let _ =@@ -2611,6 +2638,48 @@ mod tests {use super::*;use effectcraft_engine::geom::{Mat4, vec3};+ /// The Rotation tool counts past a full turn in both directions, as in After Effects: the+ /// pointer going round the anchor 1.5 turns clockwise gives 540°, then back 2 turns gives+ /// −180°, with no jump where atan2 wraps from 180° to −180°.+ #[test]+ fn rotate_tool_accumulates_revolutions() {+ // Screen y points down, so a growing atan2 angle is clockwise on screen.+ let drag = |start: f64, steps: &[f64]| {+ let (mut last, mut turned, mut out) = (start, 0.0, vec![]);+ for &a in steps {+ // atan2's range: (−180°, 180°].+ let a = (a + 180.0).rem_euclid(360.0) - 180.0;+ turned += turn_delta(last, a);+ last = a;+ out.push(turned);+ }+ (last, turned, out)+ };+ let cw: Vec<f64> = (1..=54).map(|i| i as f64 * 10.0).collect();+ let (last, turned, seq) = drag(0.0, &cw);+ assert!((turned - 540.0).abs() < 1e-9, "{turned}");+ assert!(seq.windows(2).all(|w| (w[1] - w[0] - 10.0).abs() < 1e-9), "no jump: {seq:?}");+ assert!((rotate_value(0.0, turned, false) - 540.0).abs() < 1e-9);+ let ccw: Vec<f64> = (1..=72).map(|i| 540.0 - i as f64 * 10.0).collect();+ let (_, back, seq) = drag(last, &ccw);+ assert!(seq.windows(2).all(|w| (w[1] - w[0] + 10.0).abs() < 1e-9), "no jump: {seq:?}");+ let total = turned + back;+ assert!((total + 180.0).abs() < 1e-9, "{total}");+ assert!((rotate_value(30.0, total, false) + 150.0).abs() < 1e-9);+ // Shift snaps the accumulated value, not a wrapped one.+ assert_eq!(rotate_value(0.0, 400.0, true), 405.0);+ assert_eq!(rotate_value(0.0, -400.0, true), -405.0);+ // Across the seam: 170° → −170° is +20°, and back is −20°; exactly half a turn is +180°.+ assert!((turn_delta(170.0, -170.0) - 20.0).abs() < 1e-9);+ assert!((turn_delta(-170.0, 170.0) + 20.0).abs() < 1e-9);+ assert_eq!(turn_delta(0.0, 180.0), 180.0);+ assert_eq!(turn_delta(0.0, -180.0), 180.0);+ // Never crash or poison the value on non-finite input.+ assert_eq!(turn_delta(f64::NAN, 10.0), 0.0);+ assert_eq!(turn_delta(0.0, f64::INFINITY), 0.0);+ assert_eq!(rotate_value(15.0, f64::NAN, false), 15.0);+ }+/// #882: the frame's corner sits on a physical pixel at any display scaling, so 100 % maps/// comp pixels 1:1 onto screen pixels.#[test]diff --git a/crates/ui-egui/tests/ui_viewer.rs b/crates/ui-egui/tests/ui_viewer.rsindex 07036ca81..3022cb8a6 100644--- a/crates/ui-egui/tests/ui_viewer.rs+++ b/crates/ui-egui/tests/ui_viewer.rs@@ -2088,3 +2088,49 @@ fn fit_up_to_100_follows_the_maximized_panel() {h.run_steps(3);assert!((rect(&h, "viewer.comp").width() - 640.0 / ppp).abs() < 0.01);}++/// The Rotation tool keeps counting past a full turn, as in After Effects: going round the anchor+/// 1.5 turns clockwise gives 540° (1x +180.0°), going back 2 turns gives −180°, with no jump a+/// revolution back where the pointer crosses the left of the anchor. One drag is one undo step.+#[test]+fn rotate_tool_counts_revolutions_both_ways() {+ let mut h = harness();+ let box_id = h.state().session.active_comp().unwrap().layers[0].id;+ h.state_mut().session.execute("layer.select", json!({"layers": [box_id.0]})).unwrap();+ h.state_mut().ui.tool = Tool::Rotate;+ h.run_steps(2);+ let rotation = |h: &Harness<'_, EffectcraftApp>| {+ h.state().session.active_comp().unwrap().layer(box_id).unwrap().props.prop("transform/rotation").unwrap().value.as_f64()+ };+ let center = screen(&h, [320.0, 180.0]);+ // Inside the 80 px box, so the drag starts on it (not on the Plate behind).+ let r = (screen(&h, [350.0, 180.0]) - center).x;+ let at = |deg: f64| center + vec2((deg.to_radians().cos() as f32) * r, (deg.to_radians().sin() as f32) * r);+ let undo_before = h.state().session.history.undo.len();+ // Press on the box, right of its anchor; then go round in 10° steps.+ let press = center + vec2(r * 0.3, 0.0);+ h.input_mut().events.push(Event::PointerMoved(press));+ h.input_mut().events.push(Event::PointerButton { pos: press, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });+ h.step();+ let mut seen = vec![];+ let mut walk = |h: &mut Harness<'_, EffectcraftApp>, degs: Vec<f64>| {+ for d in degs {+ h.input_mut().events.push(Event::PointerMoved(at(d)));+ h.step();+ seen.push(rotation(h));+ }+ };+ walk(&mut h, (0..=54).map(|i| i as f64 * 10.0).collect());+ // The gesture applies the previous frame's pointer: hold a frame.+ h.step();+ let cw = rotation(&h);+ assert!((cw - 540.0).abs() < 1.0, "1.5 turns clockwise: {cw}");+ walk(&mut h, (1..=72).map(|i| 540.0 - i as f64 * 10.0).collect());+ let end = at(-180.0);+ h.input_mut().events.push(Event::PointerButton { pos: end, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });+ h.run_steps(2);+ let ccw = rotation(&h);+ assert!((ccw + 180.0).abs() < 1.0, "back two turns: {ccw}");+ assert!(seen.windows(2).all(|w| (w[1] - w[0]).abs() <= 20.0), "no jump: {seen:?}");+ assert_eq!(h.state().session.history.undo.len(), undo_before + 1, "one drag, one undo step");+}