Curve-based animation

crates/bevy_animation/src/animatable.rs

@@ -1,6 +1,6 @@
 //! Traits and type for interpolating between values.
 
-use crate::{util, AnimationEvaluationError, Interpolation};
+use crate::util;
 use bevy_color::{Laba, LinearRgba, Oklaba, Srgba, Xyza};
 use bevy_math::*;
 use bevy_reflect::Reflect;
@@ -188,93 +188,11 @@ impl Animatable for Quat {
     }
 }
 
-/// An abstraction over a list of keyframes.
-///
-/// Using this abstraction instead of `Vec<T>` enables more flexibility in how
-/// keyframes are stored. In particular, morph weights use this trait in order
-/// to flatten the keyframes for all morph weights into a single vector instead
-/// of nesting vectors.
-pub(crate) trait GetKeyframe {
-    /// The type of the property to be animated.
-    type Output;
-    /// Retrieves the value of the keyframe at the given index.
-    fn get_keyframe(&self, index: usize) -> Option<&Self::Output>;
-}
-
-/// Interpolates between keyframes and stores the result in `dest`.
-///
-/// This is factored out so that it can be shared between implementations of
-/// [`crate::keyframes::Keyframes`].
-pub(crate) fn interpolate_keyframes<T>(
-    dest: &mut T,
-    keyframes: &(impl GetKeyframe<Output = T> + ?Sized),
-    interpolation: Interpolation,
-    step_start: usize,
-    time: f32,
-    weight: f32,
-    duration: f32,
-) -> Result<(), AnimationEvaluationError>
-where
-    T: Animatable + Clone,
-{
-    let value = match interpolation {
-        Interpolation::Step => {
-            let Some(start_keyframe) = keyframes.get_keyframe(step_start) else {
-                return Err(AnimationEvaluationError::KeyframeNotPresent(step_start));
-            };
-            (*start_keyframe).clone()
-        }
-
-        Interpolation::Linear => {
-            let (Some(start_keyframe), Some(end_keyframe)) = (
-                keyframes.get_keyframe(step_start),
-                keyframes.get_keyframe(step_start + 1),
-            ) else {
-                return Err(AnimationEvaluationError::KeyframeNotPresent(step_start + 1));
-            };
-
-            T::interpolate(start_keyframe, end_keyframe, time)
-        }
-
-        Interpolation::CubicSpline => {
-            let (
-                Some(start_keyframe),
-                Some(start_tangent_keyframe),
-                Some(end_tangent_keyframe),
-                Some(end_keyframe),
-            ) = (
-                keyframes.get_keyframe(step_start * 3 + 1),
-                keyframes.get_keyframe(step_start * 3 + 2),
-                keyframes.get_keyframe(step_start * 3 + 3),
-                keyframes.get_keyframe(step_start * 3 + 4),
-            )
-            else {
-                return Err(AnimationEvaluationError::KeyframeNotPresent(
-                    step_start * 3 + 4,
-                ));
-            };
-
-            interpolate_with_cubic_bezier(
-                start_keyframe,
-                start_tangent_keyframe,
-                end_tangent_keyframe,
-                end_keyframe,
-                time,
-                duration,
-            )
-        }
-    };
-
-    *dest = T::interpolate(dest, &value, weight);
-
-    Ok(())
-}
-
 /// Evaluates a cubic Bézier curve at a value `t`, given two endpoints and the
 /// derivatives at those endpoints.
 ///
 /// The derivatives are linearly scaled by `duration`.
-fn interpolate_with_cubic_bezier<T>(p0: &T, d0: &T, d3: &T, p3: &T, t: f32, duration: f32) -> T
+pub fn interpolate_with_cubic_bezier<T>(p0: &T, d0: &T, d3: &T, p3: &T, t: f32, duration: f32) -> T
 where
     T: Animatable + Clone,
 {