Add most common interpolations (#15675)

# Objective

- Followup for #14788 
- Support most usual ease function

## Solution

- Use the crate
[`interpolation`](https://docs.rs/interpolation/0.3.0/interpolation/trait.Ease.html)
which has them all
- it's already used by bevy_easings, bevy_tweening, be_tween,
bevy_tweening_captured, bevy_enoki, kayak_ui in the Bevy ecosystem for
various easing/tweening/interpolation

crates/bevy_math/Cargo.toml

@@ -21,6 +21,7 @@ rand = { version = "0.8", features = [
 ], default-features = false, optional = true }
 rand_distr = { version = "0.4.3", optional = true }
 smallvec = { version = "1.11" }
+interpolation = "0.3"
 
 bevy_reflect = { path = "../bevy_reflect", version = "0.15.0-dev", features = [
  "glam",

crates/bevy_math/src/curve/easing.rs

@@ -5,6 +5,7 @@ use crate::{
  ops::{self, FloatPow},
  VectorSpace,
 };
+use interpolation::Ease;
 
 use super::{Curve, FunctionCurve, Interval};
 
@@ -84,6 +85,51 @@ where
 }
 
 impl EasingCurve<f32, FunctionCurve<f32, fn(f32) -> f32>> {
+ /// A [`Curve`] mapping the [unit interval] to itself.
+ ///
+ /// [unit interval]: `Interval::UNIT`
+ pub fn ease(function: EaseFunction) -> Self {
+ Self {
+ start: 0.0,
+ end: 1.0,
+ easing: FunctionCurve::new(
+ Interval::UNIT,
+ match function {
+ EaseFunction::QuadraticIn => Ease::quadratic_in,
+ EaseFunction::QuadraticOut => Ease::quadratic_out,
+ EaseFunction::QuadraticInOut => Ease::quadratic_in_out,
+ EaseFunction::CubicIn => Ease::cubic_in,
+ EaseFunction::CubicOut => Ease::cubic_out,
+ EaseFunction::CubicInOut => Ease::cubic_in_out,
+ EaseFunction::QuarticIn => Ease::quartic_in,
+ EaseFunction::QuarticOut => Ease::quartic_out,
+ EaseFunction::QuarticInOut => Ease::quartic_in_out,
+ EaseFunction::QuinticIn => Ease::quintic_in,
+ EaseFunction::QuinticOut => Ease::quintic_out,
+ EaseFunction::QuinticInOut => Ease::quintic_in_out,
+ EaseFunction::SineIn => Ease::sine_in,
+ EaseFunction::SineOut => Ease::sine_out,
+ EaseFunction::SineInOut => Ease::sine_in_out,
+ EaseFunction::CircularIn => Ease::circular_in,
+ EaseFunction::CircularOut => Ease::circular_out,
+ EaseFunction::CircularInOut => Ease::circular_in_out,
+ EaseFunction::ExponentialIn => Ease::exponential_in,
+ EaseFunction::ExponentialOut => Ease::exponential_out,
+ EaseFunction::ExponentialInOut => Ease::exponential_in_out,
+ EaseFunction::ElasticIn => Ease::elastic_in,
+ EaseFunction::ElasticOut => Ease::elastic_out,
+ EaseFunction::ElasticInOut => Ease::elastic_in_out,
+ EaseFunction::BackIn => Ease::back_in,
+ EaseFunction::BackOut => Ease::back_out,
+ EaseFunction::BackInOut => Ease::back_in_out,
+ EaseFunction::BounceIn => Ease::bounce_in,
+ EaseFunction::BounceOut => Ease::bounce_out,
+ EaseFunction::BounceInOut => Ease::bounce_in_out,
+ },
+ ),
+ }
+ }
+
  /// A [`Curve`] mapping the [unit interval] to itself.
  ///
  /// Quadratic easing functions can have exactly one critical point. This is a point on the function
@@ -92,7 +138,7 @@ impl EasingCurve<f32, FunctionCurve<f32, fn(f32) -> f32>> {
  ///
  /// It uses the function `f(t) = t²`
  ///
- /// [unit domain]: `Interval::UNIT`
+ /// [unit interval]: `Interval::UNIT`
  /// [`t = 1`]: `Self::quadratic_ease_out`
  pub fn quadratic_ease_in() -> Self {
  Self {
@@ -110,7 +156,7 @@ impl EasingCurve<f32, FunctionCurve<f32, fn(f32) -> f32>> {
  ///
  /// It uses the function `f(t) = 1 - (1 - t)²`
  ///
- /// [unit domain]: `Interval::UNIT`
+ /// [unit interval]: `Interval::UNIT`
  /// [`t = 0`]: `Self::quadratic_ease_in`
  pub fn quadratic_ease_out() -> Self {
  fn f(t: f32) -> f32 {
@@ -132,7 +178,7 @@ impl EasingCurve<f32, FunctionCurve<f32, fn(f32) -> f32>> {
  ///
  /// It uses the function `f(t) = t² * (3 - 2t)`
  ///
- /// [unit domain]: `Interval::UNIT`
+ /// [unit interval]: `Interval::UNIT`
  /// [sigmoid function]: https://en.wikipedia.org/wiki/Sigmoid_function
  /// [smoothstep function]: https://en.wikipedia.org/wiki/Smoothstep
  pub fn smoothstep() -> Self {
@@ -150,7 +196,7 @@ impl EasingCurve<f32, FunctionCurve<f32, fn(f32) -> f32>> {
  ///
  /// It uses the function `f(t) = t`
  ///
- /// [unit domain]: `Interval::UNIT`
+ /// [unit interval]: `Interval::UNIT`
  pub fn identity() -> Self {
  Self {
  start: 0.0,
@@ -219,7 +265,7 @@ where
 /// - for `n >= 2` the curve has a start segment and an end segment of length `1 / (2 * n)` and in
 /// between there are `n - 1` segments of length `1 / n`
 ///
-/// [unit domain]: `Interval::UNIT`
+/// [unit interval]: `Interval::UNIT`
 /// [`constant_curve(Interval::UNIT, 0.0)`]: `crate::curve::constant_curve`
 #[derive(Clone, Debug)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
@@ -265,7 +311,7 @@ impl StepCurve {
 ///
 /// parametrized by `omega`
 ///
-/// [unit domain]: `Interval::UNIT`
+/// [unit interval]: `Interval::UNIT`
 /// [smoothstep function]: https://en.wikipedia.org/wiki/Smoothstep
 /// [spring-mass-system]: https://notes.yvt.jp/Graphics/Easing-Functions/#elastic-easing
 #[derive(Clone, Debug)]
@@ -296,3 +342,81 @@ impl ElasticCurve {
  Self { omega }
  }
 }
+
+/// Curve functions over the [unit interval], commonly used for easing transitions.
+///
+/// [unit interval]: `Interval::UNIT`
+#[derive(Debug, Copy, Clone, PartialEq)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "bevy_reflect", derive(bevy_reflect::Reflect))]
+pub enum EaseFunction {
+ /// `f(t) = t²`
+ QuadraticIn,
+ /// `f(t) = -(t * (t - 2.0))`
+ QuadraticOut,
+ /// Behaves as `EaseFunction::QuadraticIn` for t < 0.5 and as `EaseFunction::QuadraticOut` for t >= 0.5
+ QuadraticInOut,
+
+ /// `f(t) = t³`
+ CubicIn,
+ /// `f(t) = (t - 1.0)³ + 1.0`
+ CubicOut,
+ /// Behaves as `EaseFunction::CubicIn` for t < 0.5 and as `EaseFunction::CubicOut` for t >= 0.5
+ CubicInOut,
+
+ /// `f(t) = t⁴`
+ QuarticIn,
+ /// `f(t) = (t - 1.0)³ * (1.0 - t) + 1.0`
+ QuarticOut,
+ /// Behaves as `EaseFunction::QuarticIn` for t < 0.5 and as `EaseFunction::QuarticOut` for t >= 0.5
+ QuarticInOut,
+
+ /// `f(t) = t⁵`
+ QuinticIn,
+ /// `f(t) = (t - 1.0)⁵ + 1.0`
+ QuinticOut,
+ /// Behaves as `EaseFunction::QuinticIn` for t < 0.5 and as `EaseFunction::QuinticOut` for t >= 0.5
+ QuinticInOut,
+
+ /// `f(t) = sin((t - 1.0) * π / 2.0) + 1.0`
+ SineIn,
+ /// `f(t) = sin(t * π / 2.0)`
+ SineOut,
+ /// Behaves as `EaseFunction::SineIn` for t < 0.5 and as `EaseFunction::SineOut` for t >= 0.5
+ SineInOut,
+
+ /// `f(t) = 1.0 - sqrt(1.0 - t²)`
+ CircularIn,
+ /// `f(t) = sqrt((2.0 - t) * t)`
+ CircularOut,
+ /// Behaves as `EaseFunction::CircularIn` for t < 0.5 and as `EaseFunction::CircularOut` for t >= 0.5
+ CircularInOut,
+
+ /// `f(t) = 2.0.powf(10.0 * (t - 1.0))`
+ ExponentialIn,
+ /// `f(t) = 1.0 - 2.0.powf(-10.0 * t)`
+ ExponentialOut,
+ /// Behaves as `EaseFunction::ExponentialIn` for t < 0.5 and as `EaseFunction::ExponentialOut` for t >= 0.5
+ ExponentialInOut,
+
+ /// `f(t) = sin(13.0 * π / 2.0 * t) * 2.0.powf(10.0 * (t - 1.0))`
+ ElasticIn,
+ /// `f(t) = sin(-13.0 * π / 2.0 * (t + 1.0)) * 2.0.powf(-10.0 * t) + 1.0`
+ ElasticOut,
+ /// Behaves as `EaseFunction::ElasticIn` for t < 0.5 and as `EaseFunction::ElasticOut` for t >= 0.5
+ ElasticInOut,
+
+ /// `f(t) = t³ - t * sin(t * π)`
+ BackIn,
+ /// `f(t) = 1.0 - (1.0 - t)³ - t * sin((1.0 - t) * π))`
+ BackOut,
+ /// Behaves as `EaseFunction::BackIn` for t < 0.5 and as `EaseFunction::BackOut` for t >= 0.5
+ BackInOut,
+
+ /// bouncy at the start!
+ BounceIn,
+ /// bouncy at the end!
+ BounceOut,
+ /// Behaves as `EaseFunction::BounceIn` for t < 0.5 and as `EaseFunction::BounceOut` for t >= 0.5
+ BounceInOut,
+}