Trait vek::ops::Lerp

source ·

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

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

    // Provided methods
    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§

source

type Output

The resulting type after performing the LERP operation.

Required Methods§

source

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

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§

source

fn lerp_unclamped_inclusive_range( range: RangeInclusive<Self>, factor: Factor ) -> Self::Output

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

source

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

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);

source

fn lerp_unclamped_precise_inclusive_range( range: RangeInclusive<Self>, factor: Factor ) -> Self::Output

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

source

fn lerp(from: Self, to: Self, factor: Factor) -> Self::Outputwhere Factor: Clamp + Zero + One,

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);

source

fn lerp_inclusive_range( range: RangeInclusive<Self>, factor: Factor ) -> Self::Outputwhere Factor: Clamp + Zero + One,

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

source

fn lerp_precise(from: Self, to: Self, factor: Factor) -> Self::Outputwhere Factor: Clamp + Zero + One,

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);

source

fn lerp_precise_inclusive_range( range: RangeInclusive<Self>, factor: Factor ) -> Self::Outputwhere Factor: Clamp + Zero + One,

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

Trait vek::ops::Lerp

Required Associated Types§

type Output

Required Methods§

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

Provided Methods§

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::Outputwhere Factor: Clamp + Zero + One,

fn lerp_inclusive_range( range: RangeInclusive<Self>, factor: Factor ) -> Self::Outputwhere Factor: Clamp + Zero + One,

fn lerp_precise(from: Self, to: Self, factor: Factor) -> Self::Outputwhere Factor: Clamp + Zero + One,

fn lerp_precise_inclusive_range( range: RangeInclusive<Self>, factor: Factor ) -> Self::Outputwhere Factor: Clamp + Zero + One,

Implementations on Foreign Types§

impl<'a> Lerp<f64> for &'a i32

type Output = i32

fn lerp_unclamped_precise(from: Self, to: Self, factor: f64) -> i32

fn lerp_unclamped(from: Self, to: Self, factor: f64) -> i32

impl<'a> Lerp<f32> for &'a u32

type Output = u32

fn lerp_unclamped_precise(from: Self, to: Self, factor: f32) -> u32

fn lerp_unclamped(from: Self, to: Self, factor: f32) -> u32

impl Lerp<f64> for u16

type Output = u16

fn lerp_unclamped_precise(from: Self, to: Self, factor: f64) -> Self

fn lerp_unclamped(from: Self, to: Self, factor: f64) -> Self

impl<'a> Lerp<f64> for &'a u16

type Output = u16

fn lerp_unclamped_precise(from: Self, to: Self, factor: f64) -> u16

fn lerp_unclamped(from: Self, to: Self, factor: f64) -> u16

impl<'a> Lerp<f64> for &'a usize

type Output = usize

fn lerp_unclamped_precise(from: Self, to: Self, factor: f64) -> usize

fn lerp_unclamped(from: Self, to: Self, factor: f64) -> usize

impl<'a> Lerp<f64> for &'a i8

type Output = i8

fn lerp_unclamped_precise(from: Self, to: Self, factor: f64) -> i8

fn lerp_unclamped(from: Self, to: Self, factor: f64) -> i8

impl Lerp<f32> for u64

type Output = u64

fn lerp_unclamped_precise(from: Self, to: Self, factor: f32) -> Self

fn lerp_unclamped(from: Self, to: Self, factor: f32) -> Self

impl Lerp<f32> for f32

type Output = f32

fn lerp_unclamped_precise(from: Self, to: Self, factor: Self) -> Self

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

impl Lerp<f32> for u16

type Output = u16

fn lerp_unclamped_precise(from: Self, to: Self, factor: f32) -> Self

fn lerp_unclamped(from: Self, to: Self, factor: f32) -> Self

impl Lerp<f64> for u8

type Output = u8

fn lerp_unclamped_precise(from: Self, to: Self, factor: f64) -> Self

fn lerp_unclamped(from: Self, to: Self, factor: f64) -> Self

impl<'a> Lerp<f64> for &'a isize

type Output = isize

fn lerp_unclamped_precise(from: Self, to: Self, factor: f64) -> isize

fn lerp_unclamped(from: Self, to: Self, factor: f64) -> isize

impl Lerp<f32> for i64

type Output = i64

fn lerp_unclamped_precise(from: Self, to: Self, factor: f32) -> Self

fn lerp_unclamped(from: Self, to: Self, factor: f32) -> Self

impl Lerp<f32> for usize

type Output = usize

fn lerp_unclamped_precise(from: Self, to: Self, factor: f32) -> Self

fn lerp_unclamped(from: Self, to: Self, factor: f32) -> Self

impl Lerp<f64> for i64

type Output = i64

fn lerp_unclamped_precise(from: Self, to: Self, factor: f64) -> Self

fn lerp_unclamped(from: Self, to: Self, factor: f64) -> Self

impl<'a> Lerp<f32> for &'a usize

type Output = usize

fn lerp_unclamped_precise(from: Self, to: Self, factor: f32) -> usize

fn lerp_unclamped(from: Self, to: Self, factor: f32) -> usize

impl Lerp<f64> for usize

type Output = usize

fn lerp_unclamped_precise(from: Self, to: Self, factor: f64) -> Self

fn lerp_unclamped(from: Self, to: Self, factor: f64) -> Self

impl<'a> Lerp<f64> for &'a u64

type Output = u64