monolith

/// A CSS-style cubic bezier from (0, 0) to (1, 1) with control points

/// (x1, y1) and (x2, y2). The x coordinate is time, y is progress.

#[derive(Clone, Copy, Debug, PartialEq)]

pub struct CubicBezier {

    pub x1: f64,

    pub y1: f64,

    pub x2: f64,

    pub y2: f64,

}

impl CubicBezier {

    pub const LINEAR: Self = Self::new(0.0, 0.0, 1.0, 1.0);

    pub const EASE: Self = Self::new(0.45, 0.0, 0.2, 1.0);

    pub const fn new(x1: f64, y1: f64, x2: f64, y2: f64) -> Self {

        Self { x1, y1, x2, y2 }

    }

    /// Whether x is monotonic, which every valid easing curve needs.

    pub fn is_valid(&self) -> bool {

        (0.0..=1.0).contains(&self.x1) && (0.0..=1.0).contains(&self.x2)

    }

    /// Progress at normalized time `t`, clamped to the phase.

    pub fn sample(&self, t: f64) -> f64 {

        if t <= 0.0 {

            return 0.0;

        }

        if t >= 1.0 {

            return 1.0;

        }

        let u = self.solve_x(t);

        poly(self.y1, self.y2, u)

    }

    /// Initial slope, d(progress)/d(time) at t = 0.

    pub fn initial_slope(&self) -> f64 {

        if self.x1 == 0.0 {

            return if self.y1 == 0.0 { 0.0 } else { f64::INFINITY };

        }

        self.y1 / self.x1

    }

    /// The same curve, starting at `slope` instead of its own initial slope.

    ///

    /// The first control point's height is clamped to 1. A cubic bezier stays

    /// inside the convex hull of its control points, so with both heights in

    /// [0, 1] the curve can never overshoot its target.

    pub fn with_initial_slope(&self, slope: f64) -> Self {

        let x1 = if self.x1 > 0.0 { self.x1 } else { 0.3 };

        let y1 = (x1 * slope.max(0.0)).min(1.0);

        Self::new(x1, y1, self.x2, self.y2)

    }

    fn solve_x(&self, t: f64) -> f64 {

        let mut u = t;

        for _ in 0..8 {

            let err = poly(self.x1, self.x2, u) - t;

            if err.abs() < 1e-9 {

                return u;

            }

            let d = poly_derivative(self.x1, self.x2, u);

            if d.abs() < 1e-9 {

                break;

            }

            u = (u - err / d).clamp(0.0, 1.0);

        }

        let (mut lo, mut hi) = (0.0, 1.0);

        u = t;

        for _ in 0..60 {

            if poly(self.x1, self.x2, u) < t {

                lo = u;

            } else {

                hi = u;

            }

            u = (lo + hi) / 2.0;

        }

        u

    }

}

fn poly(p1: f64, p2: f64, u: f64) -> f64 {

    let c = 3.0 * p1;

    let b = 3.0 * (p2 - p1) - c;

    let a = 1.0 - c - b;

    ((a * u + b) * u + c) * u

}

fn poly_derivative(p1: f64, p2: f64, u: f64) -> f64 {

    let c = 3.0 * p1;

    let b = 3.0 * (p2 - p1) - c;

    let a = 1.0 - c - b;

    (3.0 * a * u + 2.0 * b) * u + c

}

#[cfg(test)]

mod tests {

    use super::*;

    use proptest::prelude::*;

    #[test]

    fn matched_slope_is_honoured() {

        let c = CubicBezier::EASE.with_initial_slope(2.0);

        assert!((c.initial_slope() - 2.0).abs() < 1e-9);

        let dt = 1e-4;

        assert!((c.sample(dt) / dt - 2.0).abs() < 0.05);

    }

    proptest! {

        #[test]

        fn never_overshoots(slope in 0.0f64..50.0, t in 0.0f64..=1.0) {

            let c = CubicBezier::EASE.with_initial_slope(slope);

            let p = c.sample(t);

            prop_assert!((-1e-9..=1.0 + 1e-9).contains(&p));

        }

        #[test]

        fn monotonic(x1 in 0.0f64..=1.0, y1 in 0.0f64..=1.0, x2 in 0.0f64..=1.0, y2 in 0.0f64..=1.0, t in 0.0f64..0.99) {

            let c = CubicBezier::new(x1, y1, x2, y2);

            prop_assert!(c.sample(t + 0.01) >= c.sample(t) - 1e-6);

        }

    }

}