max/splines
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add Bézier curves.

Browse Source
This commit is contained in:
Dimitri Sabadie 2019-09-23 17:06:32 +02:00
parent e76f18ac5b
commit b05582d653
No known key found for this signature in database
GPG Key ID: 784B10173D70584F
7 changed files with 148 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
.github/workflows/ci.yaml vendored
View File

@ -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

1
Cargo.toml
View File

@ -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"]

79
src/interpolate.rs
View File

@ -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 {
($t:ty, $v:ty) => {
impl Interpolate<$t> for $v {
fn lerp(a: Self, b: Self, t: $t) -> Self {
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 {
cubic_hermite_def((x, xt as $v), (a, at as $v), (b, bt as $v), (y, yt as $v), t as $v)
}
}
}
}
impl_interpolate_via!(f32, f64);
impl_interpolate_via!(f64, f32);
//macro_rules! impl_interpolate_via {
// ($t:ty, $v:ty) => {
// impl Interpolate<$t> for $v {
// fn lerp(a: Self, b: Self, t: $t) -> Self {
// 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 {
// 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)
// }
//
// 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);

25
src/interpolation.rs
View File

@ -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

4
src/key.rs
View File

@ -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 }
}
}

25
src/lib.rs
View File

@ -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.
//! + Enable with the `"impl-cgmath"` feature.
//! - Adds some useful implementations of `Interpolate` for some cgmath types.
//! - Enable with the `"impl-cgmath"` feature.
//! - **[nalgebra](https://crates.io/crates/nalgebra) implementors.**
//! + Adds some useful implementations of `Interpolate` for some nalgebra types.
//! + Enable with the `"impl-nalgebra"` feature.
//! - Adds some useful implementations of `Interpolate` for some nalgebra types.
//! - 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.
//! + Compiling with the standard library is enabled by default.
//! + Use `default-features = []` in your `Cargo.toml` to disable.
//! + Enable explicitly with the `"std"` feature.
//! - 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.
//! - Use `default-features = []` in your `Cargo.toml` to disable.
//! - 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))]

33
src/spline.rs
View File

@ -93,13 +93,13 @@ 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 })
}
Interpolation::Linear => {
let cp1 = &keys[i+1];
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
Some(Interpolate::lerp(cp0.value, cp1.value, nt))
@ -107,7 +107,7 @@ impl<T, V> Spline<T, V> {
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;
@ -120,14 +120,35 @@ impl<T, V> Spline<T, V> {
if i == 0 || i >= keys.len() - 2 {
None
} else {
let cp1 = &keys[i+1];
let cpm0 = &keys[i-1];
let cpm1 = &keys[i+2];
let cp1 = &keys[i + 1];
let cpm0 = &keys[i - 1];
let cpm1 = &keys[i + 2];
let nt = normalize_time(t, cp0, cp1);
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!()
}
}