Add Bézier curves.

.github/workflows/ci.yaml

@@ -7,27 +7,42 @@ jobs:
     steps:
       - uses: actions/checkout@v1
       - name: Build
+        run: |
+          cargo build --verbose
+          cargo build --verbose --features bezier
         run: cargo build --verbose
       - name: Test
-        run: cargo test --verbose
+        run: |
+          cargo test --verbose
+          cargo test --verbose --features bezier
 
   build-windows:
     runs-on: windows-latest
     steps:
       - uses: actions/checkout@v1
       - name: Build
+        run: |
+          cargo build --verbose
+          cargo build --verbose --features bezier
         run: cargo build --verbose
       - name: Test
-        run: cargo test --verbose
+        run: |
+          cargo test --verbose
+          cargo test --verbose --features bezier
 
   build-macosx:
     runs-on: macosx-latest
     steps:
       - uses: actions/checkout@v1
       - name: Build
+        run: |
+          cargo build --verbose
+          cargo build --verbose --features bezier
         run: cargo build --verbose
       - name: Test
-        run: cargo test --verbose
+        run: |
+          cargo test --verbose
+          cargo test --verbose --features bezier
 
   check-readme:
     runs-on: ubuntu-latest

Cargo.toml

@@ -21,6 +21,7 @@ maintenance = { status = "actively-developed" }
 
 [features]
 default = ["std"]
+bezier = []
 impl-cgmath = ["cgmath"]
 impl-nalgebra = ["alga", "nalgebra", "num-traits"]
 serialization = ["serde", "serde_derive"]

src/interpolate.rs

@@ -57,6 +57,12 @@ pub trait Interpolate<T>: Sized + Copy {
   fn cubic_hermite(_: (Self, T), a: (Self, T), b: (Self, T), _: (Self, T), t: T) -> Self {
     Self::lerp(a.0, b.0, t)
   }
+
+  /// Quadratic Bézier interpolation.
+  fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self;
+
+  /// Cubic Bézier interpolation.
+  fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self;
 }
 
 /// Set of types that support additions and subtraction.
@@ -212,6 +218,31 @@ where V: Linear<T>,
   a.0.outer_mul(two_t3 - three_t2 + one_t) + m0.outer_mul(t3 - t2 * two_t + t) + b.0.outer_mul(three_t2 - two_t3) + m1.outer_mul(t3 - t2)
 }
 
+/// Default implementation of [`Interpolate::quadratic_bezier`].
+///
+/// `V` is the value being interpolated. `T` is the sampling value (also sometimes called time).
+pub fn quadratic_bezier_def<V, T>(a: V, u: V, b: V, t: T) -> V
+where V: Linear<T>,
+      T: Additive + Mul<T, Output = T> + One {
+  let one_t = T::one() - t;
+  let one_t_2 = one_t * one_t;
+  u + (a - u).outer_mul(one_t_2) + (b - u).outer_mul(t * t)
+}
+
+/// Default implementation of [`Interpolate::cubic_bezier`].
+///
+/// `V` is the value being interpolated. `T` is the sampling value (also sometimes called time).
+pub fn cubic_bezier_def<V, T>(a: V, u: V, v: V, b: V, t: T) -> V
+where V: Linear<T>,
+      T: Additive + Mul<T, Output = T> + One {
+  let one_t = T::one() - t;
+  let one_t_2 = one_t * one_t;
+  let one_t_3 = one_t_2 * one_t;
+  let three = T::one() + T::one() + T::one();
+
+  a.outer_mul(one_t_3) + u.outer_mul(three * one_t_2 * t) + v.outer_mul(three * one_t * t * t) + b.outer_mul(t * t * t)
+}
+
 macro_rules! impl_interpolate_simple {
   ($t:ty) => {
     impl Interpolate<$t> for $t {
@@ -222,6 +253,14 @@ macro_rules! impl_interpolate_simple {
       fn cubic_hermite(x: (Self, $t), a: (Self, $t), b: (Self, $t), y: (Self, $t), t: $t) -> Self {
         cubic_hermite_def(x, a, b, y, t)
       }
+
+      fn quadratic_bezier(a: Self, u: Self, b: Self, t: $t) -> Self {
+        quadratic_bezier_def(a, u, b, t)
+      }
+
+      fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: $t) -> Self {
+        cubic_bezier_def(a, u, v, b, t)
+      }
     }
   }
 }
@@ -229,19 +268,27 @@ macro_rules! impl_interpolate_simple {
 impl_interpolate_simple!(f32);
 impl_interpolate_simple!(f64);
 
-macro_rules! impl_interpolate_via {
+//macro_rules! impl_interpolate_via {
-  ($t:ty, $v:ty) => {
+//  ($t:ty, $v:ty) => {
-    impl Interpolate<$t> for $v {
+//    impl Interpolate<$t> for $v {
-      fn lerp(a: Self, b: Self, t: $t) -> Self {
+//      fn lerp(a: Self, b: Self, t: $t) -> Self {
-        a * (1. - t as $v) + b * t as $v
+//        a * (1. - t as $v) + b * t as $v
-      }
+//      }
-
+//
-      fn cubic_hermite((x, xt): (Self, $t), (a, at): (Self, $t), (b, bt): (Self, $t), (y, yt): (Self, $t), t: $t) -> Self {
+//      fn cubic_hermite((x, xt): (Self, $t), (a, at): (Self, $t), (b, bt): (Self, $t), (y, yt): (Self, $t), t: $t) -> Self {
-        cubic_hermite_def((x, xt as $v), (a, at as $v), (b, bt as $v), (y, yt as $v), t as $v)
+//        cubic_hermite_def((x, xt as $v), (a, at as $v), (b, bt as $v), (y, yt as $v), t as $v)
-      }
+//      }
-    }
+//
-  }
+//      fn quadratic_bezier(a: Self, u: Self, b: Self, t: $t) -> Self {
-}
+//        $t::quadratic_bezier(a as $t, u as $t, b as $t, t)
-
+//      }
-impl_interpolate_via!(f32, f64);
+//
-impl_interpolate_via!(f64, f32);
+//      fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: $t) -> Self {
+//        $t::cubic_bezier(a as $t, u as $t, v as $t, b as $t, t)
+//      }
+//    }
+//  }
+//}
+//
+//impl_interpolate_via!(f32, f64);
+//impl_interpolate_via!(f64, f32);

src/interpolation.rs

@@ -8,7 +8,7 @@
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
 #[cfg_attr(feature = "serialization", serde(rename_all = "snake_case"))]
-pub enum Interpolation<T> {
+pub enum Interpolation<T, V> {
   /// Hold a [`Key<T, _>`] until the sampling value passes the normalized step threshold, in which
   /// case the next key is used.
   ///
@@ -24,10 +24,29 @@ pub enum Interpolation<T> {
   /// Cosine interpolation between a key and the next one.
   Cosine,
   /// Catmull-Rom interpolation, performing a cubic Hermite interpolation using four keys.
-  CatmullRom
+  CatmullRom,
+  /// Bézier interpolation.
+  ///
+  /// A control point that uses such an interpolation is associated with an extra point. The segmant
+  /// connecting both is called the _tangent_ of this point. The part of the spline defined between
+  /// this control point and the next one will be interpolated across with Bézier interpolation. Two
+  /// cases are possible:
+  ///
+  /// - The next control point also has a Bézier interpolation mode. In this case, its tangent is
+  ///   used for the interpolation process. This is called _cubic Bézier interpolation_ and it
+  ///   kicks ass.
+  /// - The next control point doesn’t have a Bézier interpolation mode set. In this case, the
+  ///   tangent used for the next control point is defined as the segment connecting that control
+  ///   point and the current control point’s associated point. This is called _quadratic Bézer
+  ///   interpolation_ and it kicks ass too, but a bit less than cubic.
+  #[cfg(feature = "bezier")]
+  Bezier(V),
+  #[cfg(not(any(feature = "bezier")))]
+  #[doc(hidden)]
+  _V(std::marker::PhantomData<V>),
 }
 
-impl<T> Default for Interpolation<T> {
+impl<T, V> Default for Interpolation<T, V> {
   /// [`Interpolation::Linear`] is the default.
   fn default() -> Self {
     Interpolation::Linear

src/key.rs

@@ -26,12 +26,12 @@ pub struct Key<T, V> {
   /// Carried value.
   pub value: V,
   /// Interpolation mode.
-  pub interpolation: Interpolation<T>
+  pub interpolation: Interpolation<T, V>
 }
 
 impl<T, V> Key<T, V> {
   /// Create a new key.
-  pub fn new(t: T, value: V, interpolation: Interpolation<T>) -> Self {
+  pub fn new(t: T, value: V, interpolation: Interpolation<T, V>) -> Self {
     Key { t, value, interpolation }
   }
 }

src/lib.rs

@@ -85,20 +85,25 @@
 //! So here’s a list of currently supported features and how to enable them:
 //!
 //!   - **Serialization / deserialization.**
-//!     + This feature implements both the `Serialize` and `Deserialize` traits from `serde` for all
+//!     - This feature implements both the `Serialize` and `Deserialize` traits from `serde` for all
 //!       types exported by this crate.
-//!     + Enable with the `"serialization"` feature.
+//!     - Enable with the `"serialization"` feature.
 //!   - **[cgmath](https://crates.io/crates/cgmath) implementors.**
-//!     + Adds some useful implementations of `Interpolate` for some cgmath types.
+//!     - Adds some useful implementations of `Interpolate` for some cgmath types.
-//!     + Enable with the `"impl-cgmath"` feature.
+//!     - Enable with the `"impl-cgmath"` feature.
 //!   - **[nalgebra](https://crates.io/crates/nalgebra) implementors.**
-//!     + Adds some useful implementations of `Interpolate` for some nalgebra types.
+//!     - Adds some useful implementations of `Interpolate` for some nalgebra types.
-//!     + Enable with the `"impl-nalgebra"` feature.
+//!     - Enable with the `"impl-nalgebra"` feature.
 //!   - **Standard library / no standard library.**
-//!     + It’s possible to compile against the standard library or go on your own without it.
+//!     - It’s possible to compile against the standard library or go on your own without it.
-//!     + Compiling with the standard library is enabled by default.
+//!     - Compiling with the standard library is enabled by default.
-//!     + Use `default-features = []` in your `Cargo.toml` to disable.
+//!     - Use `default-features = []` in your `Cargo.toml` to disable.
-//!     + Enable explicitly with the `"std"` feature.
+//!     - Enable explicitly with the `"std"` feature.
+//!   - **Extra interpolation modes.**
+//!     - In order not to introduce breaking changes, some feature-gates are added to augment the
+//!       [`Interpolation`] enum.
+//!
+//! [`Interpolation`]: crate::interpolation::Interpolation
 
 #![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(not(feature = "std"), feature(alloc))]

src/spline.rs

@@ -128,6 +128,27 @@ impl<T, V> Spline<T, V> {
           Some(Interpolate::cubic_hermite((cpm0.value, cpm0.t), (cp0.value, cp0.t), (cp1.value, cp1.t), (cpm1.value, cpm1.t), nt))
         }
       }
+
+      #[cfg(feature = "bezier")]
+      Interpolation::Bezier(u) => {
+        // We need to check the next control point to see whether we want quadratic or cubic Bezier.
+        let cp1 = &keys[i + 1];
+        let nt = normalize_time(t, cp0, cp1);
+
+        if let Interpolation::Bezier(v) = cp1.interpolation {
+          Some(Interpolate::cubic_bezier(cp0.value, u, v, cp1.value, nt))
+          //let one_nt = T::one() - nt;
+          //let one_nt_2 = one_nt * one_nt;
+          //let one_nt_3 = one_nt_2 * one_nt;
+          //let three_one_nt_2 = one_nt_2 + one_nt_2 + one_nt_2; // one_nt_2 * 3
+          //let r = cp0.value * one_nt_3;
+        } else {
+          Some(Interpolate::quadratic_bezier(cp0.value, u, cp1.value, nt))
+        }
+      }
+
+      #[cfg(not(any(feature = "bezier")))]
+      Interpolation::_V(_) => unreachable!()
     }
   }