Trait vek::ops::Lerp

source · 
pub trait Lerp<Factor = f32>: Sized {
    type Output;

    fn lerp_unclamped(from: Self, to: Self, factor: Factor) -> Self::Output;

    fn lerp_unclamped_inclusive_range(
        range: RangeInclusive<Self>,
        factor: Factor
    ) -> Self::Output { ... }
    fn lerp_unclamped_precise(
        from: Self,
        to: Self,
        factor: Factor
    ) -> Self::Output { ... }
    fn lerp_unclamped_precise_inclusive_range(
        range: RangeInclusive<Self>,
        factor: Factor
    ) -> Self::Output { ... }
    fn lerp(from: Self, to: Self, factor: Factor) -> Self::Output
    where
        Factor: Clamp + Zero + One,
    { ... }
    fn lerp_inclusive_range(
        range: RangeInclusive<Self>,
        factor: Factor
    ) -> Self::Output
    where
        Factor: Clamp + Zero + One,
    { ... }
    fn lerp_precise(from: Self, to: Self, factor: Factor) -> Self::Output
    where
        Factor: Clamp + Zero + One,
    { ... }
    fn lerp_precise_inclusive_range(
        range: RangeInclusive<Self>,
        factor: Factor
    ) -> Self::Output
    where
        Factor: Clamp + Zero + One,
    { ... }
}
Expand description

A value that can be linearly interpolated.

Note that, like standard operators, this can be implement for T and &T. You would make the difference like so:

use vek::ops::Lerp;

let a = Lerp::lerp(0, 10, 0.5_f32);
let b = Lerp::lerp(&0, &10, 0.5_f32);
let c = i32::lerp(0, 10, 0.5_f32);
let d = <&i32>::lerp(&0, &10, 0.5_f32);
assert_eq!(a, b);
assert_eq!(a, c);
assert_eq!(a, d);

This is made possible thanks to the explicit Output type. Therefore, it’s also convenient for GameState structures, which you might prefer to interpolate by reference instead of consuming them. The interpolation of two &GameStates would produce a new GameState value.

use vek::{Lerp, Vec3};

/// A data-heavy structure that represents a current game state.
/// It's neither Copy and nor even Clone!
struct GameState {
    pub camera_position: Vec3<f32>,
    // ... obviously a lot of other members following ...
}
// We can select the Progress type. I chose f64; the default is f32.
impl<'a> Lerp<f64> for &'a GameState {
    type Output = GameState;
    fn lerp_unclamped(a: Self, b: Self, t: f64) -> GameState {
        GameState {
            camera_position: Lerp::lerp(a.camera_position, b.camera_position, t as f32),
            // ... etc for all relevant members...
        }
    }
}
let a = GameState { camera_position: Vec3::zero() };
let b = GameState { camera_position: Vec3::unit_x() };
let c = Lerp::lerp(&a, &b, 0.5);
// Hurray! We've got an interpolated state without consuming the two previous ones.

Required Associated Types§

The resulting type after performing the LERP operation.

Required Methods§

Returns the linear interpolation of from to to with factor unconstrained, using the supposedly fastest but less precise implementation.

A possible implementation is from + factor * (to - from), a.k.a factor.mul_add(to - from, from).

use vek::ops::Lerp;

assert_eq!(Lerp::lerp_unclamped(10, 20, -1.0_f32),  0);
assert_eq!(Lerp::lerp_unclamped(10, 20, -0.5_f32),  5);
assert_eq!(Lerp::lerp_unclamped(10, 20,  0.0_f32), 10);
assert_eq!(Lerp::lerp_unclamped(10, 20,  0.5_f32), 15);
assert_eq!(Lerp::lerp_unclamped(10, 20,  1.0_f32), 20);
assert_eq!(Lerp::lerp_unclamped(10, 20,  1.5_f32), 25);

Provided Methods§

Version of lerp_unclamped() that used a single RangeInclusive parameter instead of two values.

Returns the linear interpolation of from to to with factor unconstrained, using a possibly slower but more precise operation.

A possible implementation is from*(1-factor) + to*factor, a.k.a from.mul_add(1-factor, to*factor).

use vek::ops::Lerp;

assert_eq!(Lerp::lerp_unclamped_precise(10, 20, -1.0_f32),  0);
assert_eq!(Lerp::lerp_unclamped_precise(10, 20, -0.5_f32),  5);
assert_eq!(Lerp::lerp_unclamped_precise(10, 20,  0.0_f32), 10);
assert_eq!(Lerp::lerp_unclamped_precise(10, 20,  0.5_f32), 15);
assert_eq!(Lerp::lerp_unclamped_precise(10, 20,  1.0_f32), 20);
assert_eq!(Lerp::lerp_unclamped_precise(10, 20,  1.5_f32), 25);

Version of lerp_unclamped_precise() that used a single RangeInclusive parameter instead of two values.

Alias to lerp_unclamped which constrains factor to be between 0 and 1 (inclusive).

use vek::ops::Lerp;

assert_eq!(Lerp::lerp(10, 20, -1.0_f32), 10);
assert_eq!(Lerp::lerp(10, 20, -0.5_f32), 10);
assert_eq!(Lerp::lerp(10, 20,  0.0_f32), 10);
assert_eq!(Lerp::lerp(10, 20,  0.5_f32), 15);
assert_eq!(Lerp::lerp(10, 20,  1.0_f32), 20);
assert_eq!(Lerp::lerp(10, 20,  1.5_f32), 20);

Version of lerp() that used a single RangeInclusive parameter instead of two values.

Alias to lerp_unclamped_precise which constrains factor to be between 0 and 1 (inclusive).

use vek::ops::Lerp;

assert_eq!(Lerp::lerp_precise(10, 20, -1.0_f32), 10);
assert_eq!(Lerp::lerp_precise(10, 20, -0.5_f32), 10);
assert_eq!(Lerp::lerp_precise(10, 20,  0.0_f32), 10);
assert_eq!(Lerp::lerp_precise(10, 20,  0.5_f32), 15);
assert_eq!(Lerp::lerp_precise(10, 20,  1.0_f32), 20);
assert_eq!(Lerp::lerp_precise(10, 20,  1.5_f32), 20);

Version of lerp_precise() that used a single RangeInclusive parameter instead of two values.

Implementations on Foreign Types§

Implementors§

LERP on a Transform is defined as LERP-ing between the positions and scales, and performing SLERP between the orientations.

LERP on a Transform is defined as LERP-ing between the positions and scales, and performing SLERP between the orientations.

The Lerp implementation for quaternion is the “Normalized LERP”.

The Lerp implementation for quaternion is the “Normalized LERP”.

LERP on a Transform is defined as LERP-ing between the positions and scales, and performing SLERP between the orientations.

LERP on a Transform is defined as LERP-ing between the positions and scales, and performing SLERP between the orientations.

The Lerp implementation for quaternion is the “Normalized LERP”.

The Lerp implementation for quaternion is the “Normalized LERP”.