onedrop_engine/engine/

morph.rs

//! Smart boolean interpolation of motion params across a preset
//! transition.
//!
//! Once both slots' per-frame equations have written fresh values into
//! their respective evaluator contexts, this module pulls the motion
//! params (`zoom` / `rot` / `cx` / `cy` / `sx` / `sy` / `dx` / `dy` /
//! `warp`) out of both contexts, lerps them linearly by the raw
//! transition progress, and pushes the **same** lerped values back into
//! both contexts. The downstream warp executor then sees an identical
//! starting state on both chains — what visually feels like a soft tug
//! between the two presets' compositions.
//!
//! Boolean flags (`wrap`, `darken_center`, `invert`, `brighten`, `darken`,
//! `solarize`) don't lerp meaningfully — they snap from the outgoing
//! preset's value to the incoming one's at 50 % progress.
//!
//! This is what MilkDrop calls "smart boolean interpolation": floats
//! morph, bools switch.

use super::preset_slot::PresetSlot;

/// Continuous motion params that lerp during a transition. Order is
/// load-bearing — [`snapshot_motion`] and [`write_motion`] index into the
/// returned array by position.
const MOTION_VARS: &[&str] = &["zoom", "rot", "cx", "cy", "sx", "sy", "dx", "dy", "warp"];

/// Default fallback per motion var when neither preset wrote it. Matches
/// the defaults that [`super::state_sync::sync_render_state`] applies when
/// reading the same vars out to `RenderState.motion`.
const MOTION_DEFAULTS: &[f64] = &[
    /* zoom */ 1.0, /* rot */ 0.0, /* cx */ 0.5, /* cy */ 0.5,
    /* sx */ 1.0, /* sy */ 1.0, /* dx */ 0.0, /* dy */ 0.0,
    /* warp */ 0.0,
];

/// Bool-ish flags that snap at the 50 % midpoint instead of lerping.
const BOOL_FLAGS: &[&str] = &[
    "wrap",
    "darken_center",
    "invert",
    "brighten",
    "darken",
    "solarize",
];

fn snapshot_motion(slot: &PresetSlot) -> [f64; 9] {
    let ctx = slot.evaluator.context();
    let mut out = [0.0; 9];
    for (i, name) in MOTION_VARS.iter().enumerate() {
        out[i] = ctx.get_var(name).unwrap_or(MOTION_DEFAULTS[i]);
    }
    out
}

fn snapshot_flags(slot: &PresetSlot) -> [f64; 6] {
    let ctx = slot.evaluator.context();
    let mut out = [0.0; 6];
    for (i, name) in BOOL_FLAGS.iter().enumerate() {
        out[i] = ctx.get_var(name).unwrap_or(0.0);
    }
    out
}

fn write_motion_and_flags(slot: &mut PresetSlot, motion: &[f64; 9], flags: &[f64; 6]) {
    let ctx = slot.evaluator.context_mut();
    for (i, name) in MOTION_VARS.iter().enumerate() {
        ctx.set_var(name, motion[i]);
    }
    for (i, name) in BOOL_FLAGS.iter().enumerate() {
        ctx.set_var(name, flags[i]);
    }
}

/// Lerp the motion params between the outgoing preset's slot and the
/// incoming one's, then push the result into **both** evaluator contexts.
///
/// `progress` is the raw `[0, 1]` linear value — passing the eased value
/// would distort the morph asymmetrically against the alpha crossfade.
/// At `progress = 0` both contexts end up with the outgoing preset's
/// motion; at `progress = 1` with the incoming one's; in between, the
/// linear midpoint.
///
/// Boolean flags snap to the incoming preset's value at `progress >= 0.5`,
/// otherwise to the outgoing preset's.
pub(super) fn apply_smart_boolean_interpolation(
    outgoing: &mut PresetSlot,
    incoming: &mut PresetSlot,
    progress: f32,
) {
    let t = progress.clamp(0.0, 1.0) as f64;

    let a = snapshot_motion(outgoing);
    let b = snapshot_motion(incoming);
    let lerped: [f64; 9] = std::array::from_fn(|i| a[i] * (1.0 - t) + b[i] * t);

    let flags = if progress < 0.5 {
        snapshot_flags(outgoing)
    } else {
        snapshot_flags(incoming)
    };

    write_motion_and_flags(outgoing, &lerped, &flags);
    write_motion_and_flags(incoming, &lerped, &flags);
}

#[cfg(test)]
mod tests {
    use super::*;
    use onedrop_eval::MilkEvaluator;

    fn slot_with(motion: &[(&str, f64)], flags: &[(&str, f64)]) -> PresetSlot {
        let mut slot = PresetSlot::default();
        let ctx = slot.evaluator.context_mut();
        for (name, value) in motion {
            ctx.set_var(name, *value);
        }
        for (name, value) in flags {
            ctx.set_var(name, *value);
        }
        slot
    }

    fn read(slot: &PresetSlot, name: &str) -> f64 {
        slot.evaluator.context().get_var(name).unwrap_or(0.0)
    }

    #[test]
    fn progress_zero_keeps_outgoing_motion() {
        let mut a = slot_with(&[("zoom", 2.0), ("rot", 0.5), ("cx", 0.2)], &[]);
        let mut b = slot_with(&[("zoom", 1.0), ("rot", 0.0), ("cx", 0.5)], &[]);
        apply_smart_boolean_interpolation(&mut a, &mut b, 0.0);
        assert!((read(&a, "zoom") - 2.0).abs() < 1e-9);
        assert!(
            (read(&b, "zoom") - 2.0).abs() < 1e-9,
            "both lerped to outgoing"
        );
        assert!((read(&b, "cx") - 0.2).abs() < 1e-9);
    }

    #[test]
    fn progress_one_keeps_incoming_motion() {
        let mut a = slot_with(&[("zoom", 2.0)], &[]);
        let mut b = slot_with(&[("zoom", 1.0)], &[]);
        apply_smart_boolean_interpolation(&mut a, &mut b, 1.0);
        assert!((read(&a, "zoom") - 1.0).abs() < 1e-9);
        assert!((read(&b, "zoom") - 1.0).abs() < 1e-9);
    }

    #[test]
    fn progress_half_lerps_midpoint() {
        let mut a = slot_with(&[("zoom", 0.0), ("dx", 1.0)], &[]);
        let mut b = slot_with(&[("zoom", 4.0), ("dx", 0.0)], &[]);
        apply_smart_boolean_interpolation(&mut a, &mut b, 0.5);
        assert!((read(&a, "zoom") - 2.0).abs() < 1e-9);
        assert!((read(&b, "zoom") - 2.0).abs() < 1e-9);
        assert!((read(&a, "dx") - 0.5).abs() < 1e-9);
        assert!((read(&b, "dx") - 0.5).abs() < 1e-9);
    }

    #[test]
    fn bool_flags_snap_at_midpoint() {
        let mut a = slot_with(&[], &[("wrap", 1.0), ("darken_center", 0.0)]);
        let mut b = slot_with(&[], &[("wrap", 0.0), ("darken_center", 1.0)]);

        // Just below 50 % → outgoing wins.
        apply_smart_boolean_interpolation(&mut a, &mut b, 0.49);
        assert!((read(&a, "wrap") - 1.0).abs() < 1e-9);
        assert!((read(&a, "darken_center") - 0.0).abs() < 1e-9);
        assert!((read(&b, "wrap") - 1.0).abs() < 1e-9);

        // Re-seed and test the other side of the boundary.
        let mut a = slot_with(&[], &[("wrap", 1.0), ("darken_center", 0.0)]);
        let mut b = slot_with(&[], &[("wrap", 0.0), ("darken_center", 1.0)]);
        apply_smart_boolean_interpolation(&mut a, &mut b, 0.5);
        assert!((read(&a, "wrap") - 0.0).abs() < 1e-9);
        assert!((read(&a, "darken_center") - 1.0).abs() < 1e-9);
        assert!((read(&b, "wrap") - 0.0).abs() < 1e-9);
    }

    #[test]
    fn missing_vars_fall_back_to_md2_defaults() {
        // Outgoing seeds nothing → defaults pulled in.
        let mut a = PresetSlot::default();
        let mut b = slot_with(&[("zoom", 5.0)], &[]);
        apply_smart_boolean_interpolation(&mut a, &mut b, 1.0);
        assert!((read(&a, "zoom") - 5.0).abs() < 1e-9);

        // progress=0 with no outgoing zoom → defaults to 1.0 (the MD2
        // unit zoom), so we lerp(1.0, 5.0, 0) = 1.0
        let mut a = PresetSlot::default();
        let mut b = slot_with(&[("zoom", 5.0)], &[]);
        apply_smart_boolean_interpolation(&mut a, &mut b, 0.0);
        assert!((read(&a, "zoom") - 1.0).abs() < 1e-9);
    }

    // Touch MilkEvaluator so it doesn't get flagged unused in this test
    // module — used implicitly via PresetSlot::default().
    #[allow(dead_code)]
    fn _force_use_evaluator() -> MilkEvaluator {
        MilkEvaluator::new()
    }
}