Add hermite interpolation as an option

Author: pragmatrix

animation/src/animated.rs

@@ -1,4 +1,7 @@
-use std::time::Duration;
+use std::{
+    ops::{Add, Mul},
+    time::Duration,
+};
 
 use parking_lot::Mutex;
 
@@ -9,7 +12,7 @@ use crate::{AnimationCoordinator, BlendedAnimation, Interpolatable, Interpolatio
 /// `Animated` implicitly supports animation blending. New animations added are combined with the
 /// trajectory of previous animations.
 #[derive(Debug)]
-pub struct Animated<T: Send> {
+pub struct Animated<T: Interpolatable + Send> {
     coordinator: AnimationCoordinator,
     /// The current value and the current state of the animation.
     ///
@@ -38,7 +41,7 @@ impl<T: Interpolatable + Send> Animated<T> {
         duration: Duration,
         interpolation: Interpolation,
     ) where
-        T: 'static + PartialEq,
+        T: 'static + PartialEq + Add<Output = T> + Mul<f64, Output = T>,
     {
         let mut inner = self.inner.lock();
         if *inner.final_value() == target_value {
@@ -59,7 +62,7 @@ impl<T: Interpolatable + Send> Animated<T> {
     /// current value, if it is currently not animating.
     pub fn animate(&mut self, target_value: T, duration: Duration, interpolation: Interpolation)
     where
-        T: 'static,
+        T: 'static + Add<Output = T> + Mul<f64, Output = T>,
     {
         let instant = self.coordinator.allocate_animation_time(duration);
 
@@ -93,7 +96,10 @@ impl<T: Interpolatable + Send> Animated<T> {
     /// The current value of this animated value.
     ///
     /// If an animation is active, this computes the current value from the animation.
-    pub fn value(&self) -> T {
+    pub fn value(&self) -> T
+    where
+        T: Add<Output = T> + Mul<f64, Output = T>,
+    {
         let mut inner = self.inner.lock();
         if inner.animation.is_active() {
             let instant = self.coordinator.current_cycle_time();
@@ -134,15 +140,15 @@ impl<T: Interpolatable + Send> Animated<T> {
 #[derive(Debug)]
 struct AnimatedInner<T>
 where
-    T: Send,
+    T: Interpolatable + Send,
 {
     /// The current value.
     value: T,
     /// The currently running animations.
     animation: BlendedAnimation<T>,
 }
 
-impl<T: Send> AnimatedInner<T> {
+impl<T: Interpolatable + Send> AnimatedInner<T> {
     pub fn final_value(&self) -> &T {
         self.animation.final_value().unwrap_or(&self.value)
     }

animation/src/blended.rs

@@ -0,0 +1,87 @@
+use std::{
+    ops::{Add, Mul},
+    time::Duration,
+};
+
+use crate::{time::Instant, Interpolatable, Interpolation};
+
+mod hermite;
+mod linear;
+
+pub use hermite::Hermite;
+pub use linear::Linear;
+
+#[derive(Debug)]
+pub enum BlendedAnimation<T: Interpolatable> {
+    Linear(Linear<T>),
+    Hermite(Hermite<T>),
+}
+
+impl<T: Interpolatable> Default for BlendedAnimation<T> {
+    fn default() -> Self {
+        Self::Linear(Linear::default())
+    }
+}
+
+impl<T: Interpolatable> BlendedAnimation<T> {
+    pub fn animate_to(
+        &mut self,
+        current_value: T,
+        current_time: Instant,
+        to: T,
+        duration: Duration,
+        interpolation: Interpolation,
+    ) where
+        T: Add<Output = T> + Mul<f64, Output = T>,
+    {
+        match self {
+            Self::Linear(inner) => {
+                inner.animate_to(current_value, current_time, to, duration, interpolation)
+            }
+            Self::Hermite(inner) => {
+                // Hermite ignores the interpolation parameter - it uses velocity continuity
+                inner.animate_to(current_value, current_time, to, duration)
+            }
+        }
+    }
+
+    pub fn is_active(&self) -> bool {
+        match self {
+            Self::Linear(inner) => inner.is_active(),
+            Self::Hermite(inner) => inner.is_active(),
+        }
+    }
+
+    pub fn final_value(&self) -> Option<&T> {
+        match self {
+            Self::Linear(inner) => inner.final_value(),
+            Self::Hermite(inner) => inner.final_value(),
+        }
+    }
+
+    pub fn end(&mut self) -> Option<T> {
+        match self {
+            Self::Linear(inner) => inner.end(),
+            Self::Hermite(inner) => inner.end(),
+        }
+    }
+
+    pub fn count(&self) -> usize {
+        match self {
+            Self::Linear(inner) => inner.count(),
+            Self::Hermite(inner) => inner.count(),
+        }
+    }
+}
+
+impl<T> BlendedAnimation<T>
+where
+    T: Interpolatable + Add<Output = T> + Mul<f64, Output = T>,
+{
+    pub fn proceed(&mut self, instant: Instant) -> Option<T> {
+        match self {
+            Self::Linear(inner) => inner.proceed(instant),
+            Self::Hermite(inner) => inner.proceed(instant),
+        }
+    }
+}

animation/src/blended/hermite.rs

@@ -0,0 +1,207 @@
+use std::{
+    ops::{Add, Mul},
+    time::Duration,
+};
+
+use crate::{time::Instant, Interpolatable};
+
+#[derive(Debug)]
+pub struct Hermite<T> {
+    animation: Option<Animation<T>>,
+}
+
+impl<T> Default for Hermite<T> {
+    fn default() -> Self {
+        Self { animation: None }
+    }
+}
+
+impl<T> Hermite<T> {
+    /// Any animation active?
+    pub fn is_active(&self) -> bool {
+        self.animation.is_some()
+    }
+
+    /// The final value if all animations ran through, or `None` if animations are not active.
+    pub fn final_value(&self) -> Option<&T> {
+        self.animation.as_ref().map(|a| &a.to)
+    }
+
+    pub fn count(&self) -> usize {
+        if self.animation.is_some() {
+            1
+        } else {
+            0
+        }
+    }
+
+    pub fn end(&mut self) -> Option<T> {
+        self.animation.take().map(|a| a.to)
+    }
+}
+
+impl<T> Hermite<T>
+where
+    T: Interpolatable + Add<Output = T> + Mul<f64, Output = T>,
+{
+    /// Adds an animation with hermite interpolation that maintains velocity continuity.
+    ///
+    /// The new animation replaces any existing animation, computing the current velocity
+    /// to ensure smooth transition. This creates velocity-continuous motion where each
+    /// new animation takes over seamlessly from the previous one.
+    pub fn animate_to(
+        &mut self,
+        current_value: T,
+        current_time: Instant,
+        to: T,
+        duration: Duration,
+    ) {
+        let from_tangent = if let Some(ref animation) = self.animation {
+            // Compute velocity from existing animation at current time
+            let velocity = animation.velocity_at(current_time);
+            // Scale velocity by new duration to get tangent
+            velocity * duration.as_secs_f64()
+        } else {
+            // No existing animation, start with CubicOut-like initial velocity
+            // CubicOut has derivative of 3 at t=0, so initial tangent = 3 * (to - from)
+            let delta = to.clone() + (current_value.clone() * -1.0);
+            delta * 3.0
+        };
+
+        // End with zero velocity (decelerates to stop)
+        let to_tangent = to.clone() * 0.0;
+
+        self.animation = Some(Animation {
+            from: current_value,
+            to,
+            from_tangent,
+            to_tangent,
+            start_time: current_time,
+            duration,
+        });
+    }
+
+    /// Proceed with the animation.
+    ///
+    /// Returns a computed current value at the instant, or None if there is no animation active.
+    pub fn proceed(&mut self, instant: Instant) -> Option<T> {
+        let animation = self.animation.as_ref()?;
+        let t = animation.t_at(instant);
+
+        // If animation is complete, clear it
+        if t >= 1.0 {
+            let final_value = animation.to.clone();
+            self.animation = None;
+            return Some(final_value);
+        }
+
+        Some(animation.value_at_t(t))
+    }
+}
+
+#[derive(Debug)]
+struct Animation<T> {
+    from: T,
+    to: T,
+    from_tangent: T,
+    to_tangent: T,
+    start_time: Instant,
+    duration: Duration,
+}
+
+impl<T> Animation<T>
+where
+    T: Add<Output = T> + Mul<f64, Output = T> + Clone,
+{
+    fn t_at(&self, instant: Instant) -> f64 {
+        if instant < self.start_time {
+            return 0.0;
+        }
+
+        let end_time = self.start_time + self.duration;
+        if instant >= end_time {
+            return 1.0;
+        }
+
+        let t = (instant - self.start_time).as_secs_f64() / self.duration.as_secs_f64();
+
+        if t >= 1.0 || !t.is_finite() {
+            return 1.0;
+        }
+
+        debug_assert!(t >= 0.0);
+        t
+    }
+
+    fn value_at_t(&self, t: f64) -> T {
+        if t <= 0.0 {
+            return self.from.clone();
+        }
+        if t >= 1.0 {
+            return self.to.clone();
+        }
+
+        hermite_interpolate(
+            &self.from,
+            &self.to,
+            &self.from_tangent,
+            &self.to_tangent,
+            t,
+        )
+    }
+
+    /// Compute the velocity (derivative) at a given instant.
+    ///
+    /// Returns velocity in units per second.
+    fn velocity_at(&self, instant: Instant) -> T {
+        let t = self.t_at(instant);
+
+        // If before or after animation, velocity is zero
+        if t <= 0.0 || t >= 1.0 {
+            return self.from.clone() * 0.0;
+        }
+
+        // Derivative of hermite interpolation:
+        // h'(t) = (6t²-6t)·p₀ + (3t²-4t+1)·m₀ + (-6t²+6t)·p₁ + (3t²-2t)·m₁
+        let t2 = t * t;
+
+        let dh00 = 6.0 * t2 - 6.0 * t;
+        let dh10 = 3.0 * t2 - 4.0 * t + 1.0;
+        let dh01 = -6.0 * t2 + 6.0 * t;
+        let dh11 = 3.0 * t2 - 2.0 * t;
+
+        let term0 = self.from.clone() * dh00;
+        let term1 = self.from_tangent.clone() * dh10;
+        let term2 = self.to.clone() * dh01;
+        let term3 = self.to_tangent.clone() * dh11;
+
+        let derivative = term0 + term1 + term2 + term3;
+
+        // Convert from derivative with respect to normalized t to velocity (units/second)
+        derivative * (1.0 / self.duration.as_secs_f64())
+    }
+}
+
+/// Cubic hermite interpolation using only Add and Mul<f64> operations.
+///
+/// Formula: h(t) = (2t³-3t²+1)·p₀ + (t³-2t²+t)·m₀ + (-2t³+3t²)·p₁ + (t³-t²)·m₁
+fn hermite_interpolate<T>(p0: &T, p1: &T, m0: &T, m1: &T, t: f64) -> T
+where
+    T: Add<Output = T> + Mul<f64, Output = T> + Clone,
+{
+    let t2 = t * t;
+    let t3 = t2 * t;
+
+    // Hermite basis functions
+    let h00 = 2.0 * t3 - 3.0 * t2 + 1.0;
+    let h10 = t3 - 2.0 * t2 + t;
+    let h01 = -2.0 * t3 + 3.0 * t2;
+    let h11 = t3 - t2;
+
+    let term0 = p0.clone() * h00;
+    let term1 = m0.clone() * h10;
+    let term2 = p1.clone() * h01;
+    let term3 = m1.clone() * h11;
+
+    term0 + term1 + term2 + term3
+}

animation/src/blended_animation.rs animation/src/blended/linear.rsanimation/src/blended_animation.rs renamed to animation/src/blended/linear.rs

@@ -3,19 +3,19 @@ use std::time::Duration;
 use crate::{time::Instant, Ease, Interpolatable, Interpolation};
 
 #[derive(Debug)]
-pub struct BlendedAnimation<T> {
+pub struct Linear<T> {
     animations: Vec<Animation<T>>,
 }
 
-impl<T> Default for BlendedAnimation<T> {
+impl<T> Default for Linear<T> {
     fn default() -> Self {
         Self {
             animations: Default::default(),
         }
     }
 }
 
-impl<T> BlendedAnimation<T> {
+impl<T> Linear<T> {
     /// Adds an animation on top of the stack of animations to blend.
     ///
     /// This animation is initially set up at 0% from the current value and then reaches 100% at end

animation/src/lib.rs

@@ -1,12 +1,12 @@
 mod animated;
-mod blended_animation;
+mod blended;
 mod coordinator;
 mod interpolatable;
 mod interpolation;
 mod time_scale;
 
 pub use animated::*;
-pub use blended_animation::*;
+pub use blended::*;
 pub use coordinator::*;
 pub use interpolatable::*;
 pub use interpolation::*;