remove the interpolation dependency from bevy_math (#15748)

# Objective

- `interpolation` crates provides all the curves functions, but some of
them were wrong
- We have a partial solution where some functions comes from the
external crate, some from bevy_math

## Solution

- Move them all to bevy_math
- Remove the dependency on `interpolation`

## Testing

Playing the `easing_functions` example

![easing-functions](https://github.com/user-attachments/assets/88832f34-4bb3-4dc2-85af-7b9e4fa23e52)

Author: mockersf

crates/bevy_math/Cargo.toml

@@ -21,7 +21,6 @@ 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

@@ -4,7 +4,6 @@
 //! [easing functions]: EaseFunction
 
 use crate::{Dir2, Dir3, Dir3A, Quat, Rot2, VectorSpace};
-use interpolation::Ease as IEase;
 
 use super::{function_curve, Curve, Interval};
 
@@ -219,6 +218,79 @@ mod easing_functions {
         t
     }
 
+    #[inline]
+    pub(crate) fn quadratic_in(t: f32) -> f32 {
+        t.squared()
+    }
+    #[inline]
+    pub(crate) fn quadratic_out(t: f32) -> f32 {
+        1.0 - (1.0 - t).squared()
+    }
+    #[inline]
+    pub(crate) fn quadratic_in_out(t: f32) -> f32 {
+        if t < 0.5 {
+            2.0 * t.squared()
+        } else {
+            1.0 - (-2.0 * t + 2.0).squared() / 2.0
+        }
+    }
+
+    #[inline]
+    pub(crate) fn cubic_in(t: f32) -> f32 {
+        t.cubed()
+    }
+    #[inline]
+    pub(crate) fn cubic_out(t: f32) -> f32 {
+        1.0 - (1.0 - t).cubed()
+    }
+    #[inline]
+    pub(crate) fn cubic_in_out(t: f32) -> f32 {
+        if t < 0.5 {
+            4.0 * t.cubed()
+        } else {
+            1.0 - (-2.0 * t + 2.0).cubed() / 2.0
+        }
+    }
+
+    #[inline]
+    pub(crate) fn quartic_in(t: f32) -> f32 {
+        t * t * t * t
+    }
+    #[inline]
+    pub(crate) fn quartic_out(t: f32) -> f32 {
+        1.0 - (1.0 - t) * (1.0 - t) * (1.0 - t) * (1.0 - t)
+    }
+    #[inline]
+    pub(crate) fn quartic_in_out(t: f32) -> f32 {
+        if t < 0.5 {
+            8.0 * t * t * t * t
+        } else {
+            1.0 - (-2.0 * t + 2.0) * (-2.0 * t + 2.0) * (-2.0 * t + 2.0) * (-2.0 * t + 2.0) / 2.0
+        }
+    }
+
+    #[inline]
+    pub(crate) fn quintic_in(t: f32) -> f32 {
+        t * t * t * t * t
+    }
+    #[inline]
+    pub(crate) fn quintic_out(t: f32) -> f32 {
+        1.0 - (1.0 - t) * (1.0 - t) * (1.0 - t) * (1.0 - t) * (1.0 - t)
+    }
+    #[inline]
+    pub(crate) fn quintic_in_out(t: f32) -> f32 {
+        if t < 0.5 {
+            16.0 * t * t * t * t * t
+        } else {
+            1.0 - (-2.0 * t + 2.0)
+                * (-2.0 * t + 2.0)
+                * (-2.0 * t + 2.0)
+                * (-2.0 * t + 2.0)
+                * (-2.0 * t + 2.0)
+                / 2.0
+        }
+    }
+
     #[inline]
     pub(crate) fn sine_in(t: f32) -> f32 {
         1.0 - ops::cos(t * FRAC_PI_2)
@@ -227,6 +299,44 @@ mod easing_functions {
     pub(crate) fn sine_out(t: f32) -> f32 {
         ops::sin(t * FRAC_PI_2)
     }
+    #[inline]
+    pub(crate) fn sine_in_out(t: f32) -> f32 {
+        -(ops::cos(PI * t) - 1.0) / 2.0
+    }
+
+    #[inline]
+    pub(crate) fn circular_in(t: f32) -> f32 {
+        1.0 - (1.0 - t.squared()).sqrt()
+    }
+    #[inline]
+    pub(crate) fn circular_out(t: f32) -> f32 {
+        (1.0 - (t - 1.0).squared()).sqrt()
+    }
+    #[inline]
+    pub(crate) fn circular_in_out(t: f32) -> f32 {
+        if t < 0.5 {
+            (1.0 - (1.0 - (2.0 * t).squared()).sqrt()) / 2.0
+        } else {
+            ((1.0 - (-2.0 * t + 2.0).squared()).sqrt() + 1.0) / 2.0
+        }
+    }
+
+    #[inline]
+    pub(crate) fn exponential_in(t: f32) -> f32 {
+        ops::powf(2.0, 10.0 * t - 10.0)
+    }
+    #[inline]
+    pub(crate) fn exponential_out(t: f32) -> f32 {
+        1.0 - ops::powf(2.0, -10.0 * t)
+    }
+    #[inline]
+    pub(crate) fn exponential_in_out(t: f32) -> f32 {
+        if t < 0.5 {
+            ops::powf(2.0, 20.0 * t - 10.0) / 2.0
+        } else {
+            (2.0 - ops::powf(2.0, -20.0 * t + 10.0)) / 2.0
+        }
+    }
 
     #[inline]
     pub(crate) fn back_in(t: f32) -> f32 {
@@ -271,6 +381,31 @@ mod easing_functions {
         }
     }
 
+    #[inline]
+    pub(crate) fn bounce_in(t: f32) -> f32 {
+        1.0 - bounce_out(1.0 - t)
+    }
+    #[inline]
+    pub(crate) fn bounce_out(t: f32) -> f32 {
+        if t < 4.0 / 11.0 {
+            (121.0 * t.squared()) / 16.0
+        } else if t < 8.0 / 11.0 {
+            (363.0 / 40.0 * t.squared()) - (99.0 / 10.0 * t) + 17.0 / 5.0
+        } else if t < 9.0 / 10.0 {
+            (4356.0 / 361.0 * t.squared()) - (35442.0 / 1805.0 * t) + 16061.0 / 1805.0
+        } else {
+            (54.0 / 5.0 * t.squared()) - (513.0 / 25.0 * t) + 268.0 / 25.0
+        }
+    }
+    #[inline]
+    pub(crate) fn bounce_in_out(t: f32) -> f32 {
+        if t < 0.5 {
+            (1.0 - bounce_out(1.0 - 2.0 * t)) / 2.0
+        } else {
+            (1.0 + bounce_out(2.0 * t - 1.0)) / 2.0
+        }
+    }
+
     #[inline]
     pub(crate) fn steps(num_steps: usize, t: f32) -> f32 {
         (t * num_steps as f32).round() / num_steps.max(1) as f32
@@ -286,36 +421,36 @@ impl EaseFunction {
     fn eval(&self, t: f32) -> f32 {
         match self {
             EaseFunction::Linear => easing_functions::linear(t),
-            EaseFunction::QuadraticIn => IEase::quadratic_in(t),
-            EaseFunction::QuadraticOut => IEase::quadratic_out(t),
-            EaseFunction::QuadraticInOut => IEase::quadratic_in_out(t),
-            EaseFunction::CubicIn => IEase::cubic_in(t),
-            EaseFunction::CubicOut => IEase::cubic_out(t),
-            EaseFunction::CubicInOut => IEase::cubic_in_out(t),
-            EaseFunction::QuarticIn => IEase::quartic_in(t),
-            EaseFunction::QuarticOut => IEase::quartic_out(t),
-            EaseFunction::QuarticInOut => IEase::quartic_in_out(t),
-            EaseFunction::QuinticIn => IEase::quintic_in(t),
-            EaseFunction::QuinticOut => IEase::quintic_out(t),
-            EaseFunction::QuinticInOut => IEase::quintic_in_out(t),
+            EaseFunction::QuadraticIn => easing_functions::quadratic_in(t),
+            EaseFunction::QuadraticOut => easing_functions::quadratic_out(t),
+            EaseFunction::QuadraticInOut => easing_functions::quadratic_in_out(t),
+            EaseFunction::CubicIn => easing_functions::cubic_in(t),
+            EaseFunction::CubicOut => easing_functions::cubic_out(t),
+            EaseFunction::CubicInOut => easing_functions::cubic_in_out(t),
+            EaseFunction::QuarticIn => easing_functions::quartic_in(t),
+            EaseFunction::QuarticOut => easing_functions::quartic_out(t),
+            EaseFunction::QuarticInOut => easing_functions::quartic_in_out(t),
+            EaseFunction::QuinticIn => easing_functions::quintic_in(t),
+            EaseFunction::QuinticOut => easing_functions::quintic_out(t),
+            EaseFunction::QuinticInOut => easing_functions::quintic_in_out(t),
             EaseFunction::SineIn => easing_functions::sine_in(t),
             EaseFunction::SineOut => easing_functions::sine_out(t),
-            EaseFunction::SineInOut => IEase::sine_in_out(t),
-            EaseFunction::CircularIn => IEase::circular_in(t),
-            EaseFunction::CircularOut => IEase::circular_out(t),
-            EaseFunction::CircularInOut => IEase::circular_in_out(t),
-            EaseFunction::ExponentialIn => IEase::exponential_in(t),
-            EaseFunction::ExponentialOut => IEase::exponential_out(t),
-            EaseFunction::ExponentialInOut => IEase::exponential_in_out(t),
+            EaseFunction::SineInOut => easing_functions::sine_in_out(t),
+            EaseFunction::CircularIn => easing_functions::circular_in(t),
+            EaseFunction::CircularOut => easing_functions::circular_out(t),
+            EaseFunction::CircularInOut => easing_functions::circular_in_out(t),
+            EaseFunction::ExponentialIn => easing_functions::exponential_in(t),
+            EaseFunction::ExponentialOut => easing_functions::exponential_out(t),
+            EaseFunction::ExponentialInOut => easing_functions::exponential_in_out(t),
             EaseFunction::ElasticIn => easing_functions::elastic_in(t),
             EaseFunction::ElasticOut => easing_functions::elastic_out(t),
             EaseFunction::ElasticInOut => easing_functions::elastic_in_out(t),
             EaseFunction::BackIn => easing_functions::back_in(t),
             EaseFunction::BackOut => easing_functions::back_out(t),
             EaseFunction::BackInOut => easing_functions::back_in_out(t),
-            EaseFunction::BounceIn => IEase::bounce_in(t),
-            EaseFunction::BounceOut => IEase::bounce_out(t),
-            EaseFunction::BounceInOut => IEase::bounce_in_out(t),
+            EaseFunction::BounceIn => easing_functions::bounce_in(t),
+            EaseFunction::BounceOut => easing_functions::bounce_out(t),
+            EaseFunction::BounceInOut => easing_functions::bounce_in_out(t),
             EaseFunction::Steps(num_steps) => easing_functions::steps(*num_steps, t),
             EaseFunction::Elastic(omega) => easing_functions::elastic(*omega, t),
         }