Trait splines::interpolate::Interpolate

pub trait Interpolate<T>: Sized + Copy + Linear<T> {
    fn lerp(a: Self, b: Self, t: T) -> Self;
    fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self;
    fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self;

    fn cubic_hermite(
        _: (Self, T), 
        a: (Self, T), 
        b: (Self, T), 
        _: (Self, T), 
        t: T
    ) -> Self { ... }
}

Keys that can be interpolated in between. Implementing this trait is required to perform sampling on splines.

T is the variable used to sample with. Typical implementations use f32 or f64, but you’re free to use the ones you like. Feel free to have a look at Spline::sample for instance to know which trait your type must implement to be usable.

Required methods

fn lerp(a: Self, b: Self, t: T) -> Self

Linear interpolation.

fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self

Quadratic Bézier interpolation.

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self

Cubic Bézier interpolation.

Loading content...

Provided methods

fn cubic_hermite(
    _: (Self, T),
    a: (Self, T),
    b: (Self, T),
    _: (Self, T),
    t: T
) -> Self

Cubic hermite interpolation.

Default to lerp.

Loading content...

Implementations on Foreign Types

impl<T> Interpolate<T> for Vector1<T> where
    Self: InnerSpace<Scalar = T>,
    T: Additive + BaseFloat + One, 

fn lerp(a: Self, b: Self, t: T) -> Self

fn cubic_hermite(
    x: (Self, T),
    a: (Self, T),
    b: (Self, T),
    y: (Self, T),
    t: T
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self

impl<T> Interpolate<T> for Vector2<T> where
    Self: InnerSpace<Scalar = T>,
    T: Additive + BaseFloat + One, 

fn lerp(a: Self, b: Self, t: T) -> Self

fn cubic_hermite(
    x: (Self, T),
    a: (Self, T),
    b: (Self, T),
    y: (Self, T),
    t: T
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self

impl<T> Interpolate<T> for Vector3<T> where
    Self: InnerSpace<Scalar = T>,
    T: Additive + BaseFloat + One, 

fn lerp(a: Self, b: Self, t: T) -> Self

fn cubic_hermite(
    x: (Self, T),
    a: (Self, T),
    b: (Self, T),
    y: (Self, T),
    t: T
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self

impl<T> Interpolate<T> for Vector4<T> where
    Self: InnerSpace<Scalar = T>,
    T: Additive + BaseFloat + One, 

fn lerp(a: Self, b: Self, t: T) -> Self

fn cubic_hermite(
    x: (Self, T),
    a: (Self, T),
    b: (Self, T),
    y: (Self, T),
    t: T
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self

impl<T> Interpolate<T> for Quaternion<T> where
    Self: InnerSpace<Scalar = T>,
    T: Additive + BaseFloat + One, 

fn lerp(a: Self, b: Self, t: T) -> Self

fn cubic_hermite(
    x: (Self, T),
    a: (Self, T),
    b: (Self, T),
    y: (Self, T),
    t: T
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self

impl Interpolate<f32> for f32

fn lerp(a: Self, b: Self, t: f32) -> Self

fn cubic_hermite(
    x: (Self, f32),
    a: (Self, f32),
    b: (Self, f32),
    y: (Self, f32),
    t: f32
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: f32) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: f32) -> Self

impl Interpolate<f64> for f64

fn lerp(a: Self, b: Self, t: f64) -> Self

fn cubic_hermite(
    x: (Self, f64),
    a: (Self, f64),
    b: (Self, f64),
    y: (Self, f64),
    t: f64
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: f64) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: f64) -> Self

impl Interpolate<f32> for f64

fn lerp(a: Self, b: Self, t: f32) -> Self

fn cubic_hermite(
    (x, xt): (Self, f32),
    (a, at): (Self, f32),
    (b, bt): (Self, f32),
    (y, yt): (Self, f32),
    t: f32
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: f32) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: f32) -> Self

impl Interpolate<f64> for f32

fn lerp(a: Self, b: Self, t: f64) -> Self

fn cubic_hermite(
    (x, xt): (Self, f64),
    (a, at): (Self, f64),
    (b, bt): (Self, f64),
    (y, yt): (Self, f64),
    t: f64
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: f64) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: f64) -> Self

impl<T, V> Interpolate<T> for Vector1<V> where
    Self: Linear<T>,
    T: Additive + One + Mul<T, Output = T>,
    V: One + Zero + Additive + Scalar + ClosedAdd + ClosedMul + ClosedSub + Interpolate<T>, 

fn lerp(a: Self, b: Self, t: T) -> Self

fn cubic_hermite(
    x: (Self, T),
    a: (Self, T),
    b: (Self, T),
    y: (Self, T),
    t: T
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self

impl<T, V> Interpolate<T> for Vector2<V> where
    Self: Linear<T>,
    T: Additive + One + Mul<T, Output = T>,
    V: One + Zero + Additive + Scalar + ClosedAdd + ClosedMul + ClosedSub + Interpolate<T>, 

fn lerp(a: Self, b: Self, t: T) -> Self

fn cubic_hermite(
    x: (Self, T),
    a: (Self, T),
    b: (Self, T),
    y: (Self, T),
    t: T
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self

impl<T, V> Interpolate<T> for Vector3<V> where
    Self: Linear<T>,
    T: Additive + One + Mul<T, Output = T>,
    V: One + Zero + Additive + Scalar + ClosedAdd + ClosedMul + ClosedSub + Interpolate<T>, 

fn lerp(a: Self, b: Self, t: T) -> Self

fn cubic_hermite(
    x: (Self, T),
    a: (Self, T),
    b: (Self, T),
    y: (Self, T),
    t: T
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self

impl<T, V> Interpolate<T> for Vector4<V> where
    Self: Linear<T>,
    T: Additive + One + Mul<T, Output = T>,
    V: One + Zero + Additive + Scalar + ClosedAdd + ClosedMul + ClosedSub + Interpolate<T>, 

fn lerp(a: Self, b: Self, t: T) -> Self

fn cubic_hermite(
    x: (Self, T),
    a: (Self, T),
    b: (Self, T),
    y: (Self, T),
    t: T
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self

impl<T, V> Interpolate<T> for Vector5<V> where
    Self: Linear<T>,
    T: Additive + One + Mul<T, Output = T>,
    V: One + Zero + Additive + Scalar + ClosedAdd + ClosedMul + ClosedSub + Interpolate<T>, 

fn lerp(a: Self, b: Self, t: T) -> Self

fn cubic_hermite(
    x: (Self, T),
    a: (Self, T),
    b: (Self, T),
    y: (Self, T),
    t: T
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self

impl<T, V> Interpolate<T> for Vector6<V> where
    Self: Linear<T>,
    T: Additive + One + Mul<T, Output = T>,
    V: One + Zero + Additive + Scalar + ClosedAdd + ClosedMul + ClosedSub + Interpolate<T>, 

fn lerp(a: Self, b: Self, t: T) -> Self

fn cubic_hermite(
    x: (Self, T),
    a: (Self, T),
    b: (Self, T),
    y: (Self, T),
    t: T
) -> Self

fn quadratic_bezier(a: Self, u: Self, b: Self, t: T) -> Self

fn cubic_bezier(a: Self, u: Self, v: Self, b: Self, t: T) -> Self

Loading content...

Implementors

Loading content...