fix(encode): apply the transition easing to progress

Refs #220

Author: LeadcodeDev

crates/rustmotion/src/encode/video/tasks.rs

@@ -1,3 +1,4 @@
+use crate::engine::animator::ease;
 use crate::engine::transition::{apply_transition, camera_pan_transition, TransitionOptions};
 use crate::error::{Result, RustmotionError};
 use crate::schema::{
@@ -296,6 +297,7 @@ pub fn render_frame_task_scaled(
             // Rationale: the transition is the "entry" of scene_b; its post-effects
             // (e.g. vignette) should appear on the blended frames to avoid a
             // jarring pop when the transition ends and Normal frames begin.
+            let progress = eased_transition_progress(progress, easing);
             let mut composited = apply_transition(
                 &frame_a,
                 &frame_b,
@@ -360,7 +362,7 @@ pub fn render_frame_task_scaled(
             transition_type,
             options,
             transition_duration,
-            easing: _,
+            easing,
         } => {
             let scenario_time = *global_frame as f64 / config.fps as f64;
             let scaled_w = (config.width as f32 * scale_factor) as u32;
@@ -372,6 +374,7 @@ pub fn render_frame_task_scaled(
             // does not.
             let progress =
                 view_transition_progress(*frame_in_transition, *transition_duration, fps);
+            let progress = eased_transition_progress(progress, easing);
 
             let view_a = &scenario.views[*view_a_idx];
             let view_b = &scenario.views[*view_b_idx];
@@ -427,6 +430,18 @@ fn transition_progress(frame_in_transition: u32, transition_duration: f64, fps:
     frame_in_transition as f64 / transition_frames.saturating_sub(1).max(1) as f64
 }
 
+/// Reshapes a transition's raw linear `progress` by its declared
+/// `transition.easing` before it reaches `apply_transition`, which composites
+/// pixels at exactly the fraction it's handed and has no notion of easing on
+/// its own. Every transition arm that calls `apply_transition` needs this —
+/// `SlideTransition`'s `CameraPan` case is the one exception, since it never
+/// reaches `apply_transition` at all: it hands its own `easing` straight into
+/// `camera_pan_transition`, which applies it internally, so routing it
+/// through here first would ease that progress twice.
+fn eased_transition_progress(progress: f64, easing: &EasingType) -> f64 {
+    ease(progress, easing)
+}
+
 /// Frame index within a *view* transition → progress in the OPEN interval
 /// `(0.0, 1.0)`, excluding both endpoints.
 ///

crates/rustmotion/tests/audit_ws_c.rs

@@ -154,3 +154,145 @@ fn atempo_guard_rejects_non_positive_and_non_finite_rates_without_hanging() {
         }
     }
 }
+
+// ─── A transition's declared easing must actually reshape its progress ────
+//
+// `transition_progress`/`view_transition_progress` hand a raw *linear*
+// fraction to `apply_transition`, which composites pixels at exactly the
+// fraction it's given — it has no notion of the scenario's declared
+// `transition.easing` on its own. Before this fix, that raw linear fraction
+// reached `apply_transition` unmodified for every transition type except
+// `camera_pan` (which threads easing through a different function,
+// `camera_pan_transition`, that already applies it internally), so
+// `"easing": "ease_in"`/`"ease_out"` on a `fade`, wipe, iris, or a
+// between-view transition was silently a no-op.
+//
+// A `fade` between a solid-black and a solid-white full-canvas frame turns
+// this into an exact, predictable pixel value: at the frame whose *linear*
+// position in the transition is precisely 0.5, an eased blend must land at
+// `255 * ease(0.5)`, not at the unequal, easing-blind `255 * 0.5 = 128`.
+// `ease_in_cubic(0.5) = 0.125` and `ease_out_cubic(0.5) = 0.875` are both far
+// enough from `0.5` that no rendering noise/antialiasing could produce a
+// false pass.
+
+fn center_pixel_red(rgba: &[u8], width: u32, height: u32) -> u8 {
+    let idx = ((height / 2 * width + width / 2) * 4) as usize;
+    rgba[idx]
+}
+
+#[test]
+fn a_fade_transitions_easing_reshapes_its_progress_not_just_camera_pan() {
+    let width = 64u32;
+    let height = 64u32;
+    let fps = 11u32;
+
+    for (easing, expected_u8) in [("ease_in", 32u8), ("ease_out", 224u8)] {
+        let json = format!(
+            r##"{{"video": {{"width": {width}, "height": {height}, "fps": {fps}}},
+            "scenes": [
+                {{"duration": 1.0, "children": [
+                    {{"type": "shape", "shape": "rect", "fill": "#000000",
+                      "position": "absolute", "x": 0, "y": 0,
+                      "style": {{"width": {width}, "height": {height}}}}}
+                ]}},
+                {{"duration": 1.0,
+                  "transition": {{"type": "fade", "duration": 1.0, "easing": "{easing}"}},
+                  "children": [
+                    {{"type": "shape", "shape": "rect", "fill": "#ffffff",
+                      "position": "absolute", "x": 0, "y": 0,
+                      "style": {{"width": {width}, "height": {height}}}}}
+                ]}}
+            ]}}"##
+        );
+        let scenario = rustmotion::loader::load_scenario_from_source(None, Some(&json))
+            .expect("load");
+
+        let tasks = rustmotion::encode::video::build_frame_tasks(&scenario);
+        let target = tasks
+            .iter()
+            .find(|t| {
+                matches!(
+                    t,
+                    rustmotion::encode::video::FrameTask::SlideTransition {
+                        frame_in_transition: 5,
+                        ..
+                    }
+                )
+            })
+            .unwrap_or_else(|| panic!("{easing}: expected a mid-transition frame at index 5"));
+
+        let rgba =
+            rustmotion::encode::video::render_frame_task(&scenario.video, &scenario, target)
+                .unwrap_or_else(|e| panic!("{easing}: render failed: {e}"));
+        let red = center_pixel_red(&rgba, width, height);
+
+        assert!(
+            (red as i32 - expected_u8 as i32).abs() <= 4,
+            "{easing}: at the transition's linear midpoint, the eased blend must land near \
+             {expected_u8}, got {red}"
+        );
+        assert!(
+            (red as i32 - 128).abs() > 20,
+            "{easing}: {red} is too close to 128 — the raw, unequal linear-progress blend an \
+             easing-blind composite would produce"
+        );
+    }
+}
+
+#[test]
+fn a_between_view_fade_transitions_easing_reshapes_its_progress() {
+    let width = 64u32;
+    let height = 64u32;
+    let fps = 11u32;
+
+    let json = format!(
+        r##"{{"video": {{"width": {width}, "height": {height}, "fps": {fps}}},
+        "composition": [
+            {{"type": "slide", "scenes": [
+                {{"duration": 1.0, "children": [
+                    {{"type": "shape", "shape": "rect", "fill": "#000000",
+                      "position": "absolute", "x": 0, "y": 0,
+                      "style": {{"width": {width}, "height": {height}}}}}
+                ]}}
+            ]}},
+            {{"type": "slide",
+              "transition": {{"type": "fade", "duration": 1.0, "easing": "ease_in"}},
+              "scenes": [
+                {{"duration": 1.0, "children": [
+                    {{"type": "shape", "shape": "rect", "fill": "#ffffff",
+                      "position": "absolute", "x": 0, "y": 0,
+                      "style": {{"width": {width}, "height": {height}}}}}
+                ]}}
+            ]}}
+        ]}}"##
+    );
+    let scenario = rustmotion::loader::load_scenario_from_source(None, Some(&json)).expect("load");
+
+    let tasks = rustmotion::encode::video::build_frame_tasks(&scenario);
+    let target = tasks
+        .iter()
+        .find(|t| {
+            matches!(
+                t,
+                rustmotion::encode::video::FrameTask::ViewTransition {
+                    frame_in_transition: 5,
+                    ..
+                }
+            )
+        })
+        .expect("expected a mid-view-transition frame at index 5");
+
+    let rgba = rustmotion::encode::video::render_frame_task(&scenario.video, &scenario, target)
+        .expect("render");
+    let red = center_pixel_red(&rgba, width, height);
+
+    assert!(
+        (red as i32 - 32).abs() <= 4,
+        "ease_in at the view transition's linear midpoint must land near 32, got {red}"
+    );
+    assert!(
+        (red as i32 - 128).abs() > 20,
+        "{red} is too close to 128 — the raw, unequal linear-progress blend an easing-blind \
+         composite would produce"
+    );
+}