Trait 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::Output
where 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::Output
where 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::Output
where 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::Output
where Factor: Clamp + Zero + One,

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

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Trait LerpCopy item path

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,

Dyn Compatibility§

Implementations on Foreign Types§

impl Lerp for f32

type Output = f32

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

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

impl Lerp for i8

type Output = i8

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

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

impl Lerp for i16

type Output = i16

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

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

impl Lerp for i32

type Output = i32

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

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

impl Lerp for i64

type Output = i64

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

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

impl Lerp for isize

type Output = isize

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

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

impl Lerp for u8

type Output = u8

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

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

impl Lerp for u16

type Output = u16

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

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

impl Lerp for u32

type Output = u32

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

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

impl Lerp for u64

type Output = u64

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

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

impl Lerp for usize

type Output = usize

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

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

impl Lerp for Path

type Output = Path

fn lerp_unclamped(from: Path, to: Path, factor: f32) -> <Path as Lerp>::Output

impl Lerp<f64> for f64

type Output = f64

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

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

impl Lerp<f64> for i8

type Output = i8

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

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

impl Lerp<f64> for i16

type Output = i16

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

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

impl Lerp<f64> for i32

type Output = i32

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

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

impl Lerp<f64> for i64

type Output = i64

Trait Lerp

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,