Merge pull request #33 from phaazon/feature/stroke-bezier

Add Interpolation::StrokeBezier.

.github/workflows/ci.yaml

@@ -7,27 +7,38 @@ jobs:
     steps:
       - uses: actions/checkout@v1
       - name: Build
-        run: cargo build --verbose
+        run: |
+          cargo build --verbose --all-features
       - name: Test
-        run: cargo test --verbose
+        run: |
+          cargo test --verbose --all-features
+
 
   build-windows:
     runs-on: windows-latest
     steps:
       - uses: actions/checkout@v1
       - name: Build
-        run: cargo build --verbose
+        run: |
+          cargo build --verbose --all-features
       - name: Test
-        run: cargo test --verbose
+        run: |
+          cargo test --verbose --all-features
 
   build-macosx:
-    runs-on: macosx-latest
+    runs-on: macOS-latest
     steps:
       - uses: actions/checkout@v1
+      - name: Rust requirements
+        run: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile=minimal
       - name: Build
-        run: cargo build --verbose
+        run: |
+          . ~/.cargo/env
+          cargo build --verbose --all-features
       - name: Test
-        run: cargo test --verbose
+        run: |
+          . ~/.cargo/env
+          cargo test --verbose --all-features
 
   check-readme:
     runs-on: ubuntu-latest

CHANGELOG.md

@@ -1,6 +1,48 @@
+# 2.2.0
+
+> Mon Oct 17th 2019
+
+- Add `Interpolation::StrokeBezier`.
+
+# 2.1.1
+
+> Mon Oct 17th 2019
+
+- Licensing support in the crate.
+
+# 2.1
+
+> Mon Sep 30th 2019
+
+- Add `Spline::sample_with_key` and `Spline::clamped_sample_with_key`. Those methods allow one to
+  perform the regular `Spline::sample` and `Spline::clamped_sample` but also retreive the base
+  key that was used to perform the interpolation. The key can be inspected to get the base time,
+  interpolation, etc. The next key is also returned, if present.
+
+# 2.0.1
+
+> Tue Sep 24th 2019
+
+- Fix the cubic Bézier curve interpolation. The “output” tangent is now taken by mirroring the
+  next key’s tangent around its control point.
+
+# 2.0.0
+
+> Mon Sep 23rd 2019
+
+## Major changes
+
+- Add support for [Bézier curves](https://en.wikipedia.org/wiki/B%C3%A9zier_curve).
+- Because of Bézier curves, the `Interpolation` type now has one more type variable to know how we
+  should interpolate with Bézier.
+
+## Minor changes
+
+- Add `Spline::get`, `Spline::get_mut` and `Spline::replace`.
+
 # 1.0
 
-> Sun Sep 22th 2019
+> Sun Sep 22nd 2019
 
 ## Major changes
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "splines"
-version = "1.0.0"
+version = "2.2.0"
 license = "BSD-3-Clause"
 authors = ["Dimitri Sabadie <dimitri.sabadie@gmail.com>"]
 description = "Spline interpolation made easy"

LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2019, Dimitri Sabadie <dimitri.sabadie@gmail.com>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Dimitri Sabadie <dimitri.sabadie@gmail.com> nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -84,19 +84,21 @@ not. It’s especially important to see how it copes with the documentation.
 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.
+
+[`Interpolation`]: crate::interpolation::Interpolation
 
 <!-- cargo-sync-readme end -->

src/cgmath.rs

@@ -2,7 +2,9 @@ use cgmath::{
   BaseFloat, BaseNum, InnerSpace, Quaternion, Vector1, Vector2, Vector3, Vector4, VectorSpace
 };
 
-use crate::interpolate::{Additive, Interpolate, Linear, One, cubic_hermite_def};
+use crate::interpolate::{
+  Additive, Interpolate, Linear, One, cubic_bezier_def, cubic_hermite_def, quadratic_bezier_def
+};
 
 macro_rules! impl_interpolate_vec {
   ($($t:tt)*) => {
@@ -29,6 +31,16 @@ macro_rules! impl_interpolate_vec {
       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)
       }
+
+      #[inline(always)]
+      fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self {
+        quadratic_bezier_def(a, u, b, t)
+      }
+
+      #[inline(always)]
+      fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self {
+        cubic_bezier_def(a, u, v, b, t)
+      }
     }
   }
 }
@@ -61,4 +73,14 @@ where Self: InnerSpace<Scalar = T>, T: Additive + BaseFloat + One {
   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)
   }
+
+  #[inline(always)]
+  fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self {
+    quadratic_bezier_def(a, u, b, t)
+  }
+
+  #[inline(always)]
+  fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self {
+    cubic_bezier_def(a, u, v, b, t)
+  }
 }

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,34 @@ 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();
+
+  // mirror the “output” tangent based on the next key “input” tangent
+  let v_ = b + b - v;
+
+  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 +256,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)
+      }
     }
   }
 }
@@ -239,6 +281,14 @@ macro_rules! impl_interpolate_via {
       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)
       }
+
+      fn quadratic_bezier(a: Self, u: Self, b: Self, t: $t) -> Self {
+        quadratic_bezier_def(a, u, b, t as $v)
+      }
+
+      fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: $t) -> Self {
+        cubic_bezier_def(a, u, v, b, t as $v)
+      }
     }
   }
 }

src/interpolation.rs

@@ -8,8 +8,8 @@
 #[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
+  /// Hold a [`Key`] until the sampling value passes the normalized step threshold, in which
   /// case the next key is used.
   ///
   /// > Note: if you set the threshold to `0.5`, the first key will be used until half the time
@@ -17,20 +17,48 @@ pub enum Interpolation<T> {
   /// > first key will be kept until the next key. Set it to `0.` and the first key will never be
   /// > used.
   ///
-  /// [`Key<T, _>`]: crate::key::Key
+  /// [`Key`]: crate::key::Key
   Step(T),
   /// Linear interpolation between a key and the next one.
   Linear,
   /// 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.
+  Bezier(V),
+  /// A special Bézier interpolation using an _input tangent_ and an _output tangent_.
+  ///
+  /// With this kind of interpolation, a control point has an input tangent, which has the same role
+  /// as the one defined by [`Interpolation::Bezier`], and an output tangent, which has the same
+  /// role defined by the next key’s [`Interpolation::Bezier`] if present, normally.
+  ///
+  /// What it means is that instead of setting the output tangent as the next key’s Bézier tangent,
+  /// this interpolation mode allows you to manually set the output tangent. That will yield more
+  /// control on the tangents but might generate discontinuities. Use with care.
+  ///
+  /// Stroke Bézier interpolation is always a cubic Bézier interpolation by default.
+  StrokeBezier(V, V),
+  #[doc(hidden)]
+  __NonExhaustive
 }
 
-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,22 @@
 //! 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.
+//!
+//! [`Interpolation`]: crate::interpolation::Interpolation
 
 #![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(not(feature = "std"), feature(alloc))]

src/nalgebra.rs

@@ -3,7 +3,9 @@ use nalgebra::{Scalar, Vector, Vector1, Vector2, Vector3, Vector4, Vector5, Vect
 use num_traits as nt;
 use std::ops::Mul;
 
-use crate::interpolate::{Interpolate, Linear, Additive, One, cubic_hermite_def};
+use crate::interpolate::{
+  Interpolate, Linear, Additive, One, cubic_bezier_def, cubic_hermite_def, quadratic_bezier_def
+};
 
 macro_rules! impl_interpolate_vector {
   ($($t:tt)*) => {
@@ -40,6 +42,16 @@ macro_rules! impl_interpolate_vector {
       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)
       }
+
+      #[inline(always)]
+      fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self {
+        quadratic_bezier_def(a, u, b, t)
+      }
+
+      #[inline(always)]
+      fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self {
+        cubic_bezier_def(a, u, v, b, t)
+      }
     }
   }
 }

src/spline.rs

@@ -69,7 +69,8 @@ impl<T, V> Spline<T, V> {
     self.0.is_empty()
   }
 
-  /// Sample a spline at a given time.
+  /// Sample a spline at a given time, returning the interpolated value along with its associated
+  /// key.
   ///
   /// The current implementation, based on immutability, cannot perform in constant time. This means
   /// that sampling’s processing complexity is currently *O(log n)*. It’s possible to achieve *O(1)*
@@ -83,8 +84,7 @@ impl<T, V> Spline<T, V> {
   /// sampling impossible. For instance, [`Interpolation::CatmullRom`] requires *four* keys. If
   /// you’re near the beginning of the spline or its end, ensure you have enough keys around to make
   /// the sampling.
-  ///
+  pub fn sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
-  pub fn sample(&self, t: T) -> Option<V>
   where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
         V: Interpolate<T> {
     let keys = &self.0;
@@ -93,25 +93,29 @@ impl<T, V> Spline<T, V> {
 
     match cp0.interpolation {
       Interpolation::Step(threshold) => {
-        let cp1 = &keys[i+1];
+        let cp1 = &keys[i + 1];
         let nt = normalize_time(t, cp0, cp1);
-        Some(if nt < threshold { cp0.value } else { cp1.value })
+        let value = if nt < threshold { cp0.value } else { cp1.value };
+
+        Some((value, cp0, Some(cp1)))
       }
 
       Interpolation::Linear => {
-        let cp1 = &keys[i+1];
+        let cp1 = &keys[i + 1];
         let nt = normalize_time(t, cp0, cp1);
+        let value = Interpolate::lerp(cp0.value, cp1.value, nt);
 
-        Some(Interpolate::lerp(cp0.value, cp1.value, nt))
+        Some((value, cp0, Some(cp1)))
       }
 
       Interpolation::Cosine => {
         let two_t = T::one() + T::one();
-        let cp1 = &keys[i+1];
+        let cp1 = &keys[i + 1];
         let nt = normalize_time(t, cp0, cp1);
         let cos_nt = (T::one() - (nt * T::pi()).cos()) / two_t;
+        let value = Interpolate::lerp(cp0.value, cp1.value, cos_nt);
 
-        Some(Interpolate::lerp(cp0.value, cp1.value, cos_nt))
+        Some((value, cp0, Some(cp1)))
       }
 
       Interpolation::CatmullRom => {
@@ -120,18 +124,53 @@ impl<T, V> Spline<T, V> {
         if i == 0 || i >= keys.len() - 2 {
           None
         } else {
-          let cp1 = &keys[i+1];
+          let cp1 = &keys[i + 1];
-          let cpm0 = &keys[i-1];
+          let cpm0 = &keys[i - 1];
-          let cpm1 = &keys[i+2];
+          let cpm1 = &keys[i + 2];
           let nt = normalize_time(t, cp0, cp1);
+          let value = Interpolate::cubic_hermite((cpm0.value, cpm0.t), (cp0.value, cp0.t), (cp1.value, cp1.t), (cpm1.value, cpm1.t), nt);
 
-          Some(Interpolate::cubic_hermite((cpm0.value, cpm0.t), (cp0.value, cp0.t), (cp1.value, cp1.t), (cpm1.value, cpm1.t), nt))
+          Some((value, cp0, Some(cp1)))
         }
       }
+
+      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);
+
+        let value =
+          if let Interpolation::Bezier(v) = cp1.interpolation {
+            Interpolate::cubic_bezier(cp0.value, u, v, cp1.value, nt)
+          } else {
+            Interpolate::quadratic_bezier(cp0.value, u, cp1.value, nt)
+          };
+
+        Some((value, cp0, Some(cp1)))
+      }
+
+      Interpolation::StrokeBezier(input, output) => {
+        let cp1 = &keys[i + 1];
+        let nt = normalize_time(t, cp0, cp1);
+        let value = Interpolate::cubic_bezier(cp0.value, input, output, cp1.value, nt);
+
+        Some((value, cp0, Some(cp1)))
+      }
+
+      Interpolation::__NonExhaustive => unreachable!(),
     }
   }
 
-  /// Sample a spline at a given time with clamping.
+  /// Sample a spline at a given time.
+  ///
+  pub fn sample(&self, t: T) -> Option<V>
+  where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
+        V: Interpolate<T> {
+    self.sample_with_key(t).map(|(v, _, _)| v)
+  }
+
+  /// Sample a spline at a given time with clamping, returning the interpolated value along with its
+  /// associated key.
   ///
   /// # Return
   ///
@@ -141,22 +180,23 @@ impl<T, V> Spline<T, V> {
   /// # Error
   ///
   /// This function returns [`None`] if you have no key.
-  pub fn clamped_sample(&self, t: T) -> Option<V>
+  pub fn clamped_sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
   where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
         V: Interpolate<T> {
     if self.0.is_empty() {
       return None;
     }
 
-    self.sample(t).or_else(move || {
+    self.sample_with_key(t).or_else(move || {
       let first = self.0.first().unwrap();
       if t <= first.t {
-        Some(first.value)
+        let second = if self.0.len() >= 2 { Some(&self.0[1]) } else { None };
+        Some((first.value, &first, second))
       } else {
         let last = self.0.last().unwrap();
 
         if t >= last.t {
-          Some(last.value)
+          Some((last.value, &last, None))
         } else {
           None
         }
@@ -164,6 +204,13 @@ impl<T, V> Spline<T, V> {
     })
   }
 
+  /// Sample a spline at a given time with clamping.
+  pub fn clamped_sample(&self, t: T) -> Option<V>
+  where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
+        V: Interpolate<T> {
+    self.clamped_sample_with_key(t).map(|(v, _, _)| v)
+  }
+
   /// Add a key into the spline.
   pub fn add(&mut self, key: Key<T, V>) where T: PartialOrd {
     self.0.push(key);
@@ -178,6 +225,54 @@ impl<T, V> Spline<T, V> {
       Some(self.0.remove(index))
     }
   }
+
+  /// Update a key and return the key already present.
+  ///
+  /// The key is updated — if present — with the provided function.
+  ///
+  /// # Notes
+  ///
+  /// That function makes sense only if you want to change the interpolator (i.e. [`Key::t`]) of
+  /// your key. If you just want to change the interpolation mode or the carried value, consider
+  /// using the [`Spline::get_mut`] method instead as it will be way faster.
+  pub fn replace<F>(
+    &mut self,
+    index: usize,
+    f: F
+  ) -> Option<Key<T, V>>
+  where
+    F: FnOnce(&Key<T, V>) -> Key<T, V>,
+    T: PartialOrd
+  {
+    let key = self.remove(index)?;
+    self.add(f(&key));
+    Some(key)
+  }
+
+  /// Get a key at a given index.
+  pub fn get(&self, index: usize) -> Option<&Key<T, V>> {
+    self.0.get(index)
+  }
+
+  /// Mutably get a key at a given index.
+  pub fn get_mut(&mut self, index: usize) -> Option<KeyMut<T, V>> {
+    self.0.get_mut(index).map(|key| KeyMut {
+      value: &mut key.value,
+      interpolation: &mut key.interpolation
+    })
+  }
+}
+
+/// A mutable [`Key`].
+///
+/// Mutable keys allow to edit the carried values and the interpolation mode but not the actual
+/// interpolator value as it would invalidate the internal structure of the [`Spline`]. If you
+/// want to achieve this, you’re advised to use [`Spline::replace`].
+pub struct KeyMut<'a, T, V> {
+  /// Carried value.
+  pub value: &'a mut V,
+  /// Interpolation mode to use for that key.
+  pub interpolation: &'a mut Interpolation<T, V>,
 }
 
 // Normalize a time ([0;1]) given two control points.

tests/mod.rs

@@ -16,6 +16,8 @@ fn step_interpolation_f32() {
   assert_eq!(spline.sample(0.9), Some(10.));
   assert_eq!(spline.sample(1.), None);
   assert_eq!(spline.clamped_sample(1.), Some(10.));
+  assert_eq!(spline.sample_with_key(0.2), Some((10., &start, Some(&end))));
+  assert_eq!(spline.clamped_sample_with_key(1.), Some((10., &end, None)));
 }
 
 #[test]
@@ -31,6 +33,8 @@ fn step_interpolation_f64() {
   assert_eq!(spline.sample(0.9), Some(10.));
   assert_eq!(spline.sample(1.), None);
   assert_eq!(spline.clamped_sample(1.), Some(10.));
+  assert_eq!(spline.sample_with_key(0.2), Some((10., &start, Some(&end))));
+  assert_eq!(spline.clamped_sample_with_key(1.), Some((10., &end, None)));
 }
 
 #[test]