Trait vek::ops::Lerp

pub trait Lerp<Factor = f32>: Sized {
    type Output;
    fn lerp_unclamped(from: Self, to: Self, factor: Factor) -> Self::Output;

    fn lerp_unclamped_precise(
        from: Self, 
        to: Self, 
        factor: Factor
    ) -> Self::Output { ... }
    fn lerp(from: Self, to: 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,
    { ... }
}

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.

Associated Types

type Output

The resulting type after performing the LERP operation.

Required Methods

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.

This would make use of inclusive ranges, but they aren't stable yet.

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

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.

This would make use of inclusive ranges, but they aren't stable yet.

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

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

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

Implementations on Foreign Types

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

fn lerp(from: Self, to: 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, 

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

type Output = f32

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

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

fn lerp(from: Self, to: 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, 

impl Lerp<f64> for f64

type Output = f64

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

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

fn lerp(from: Self, to: 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, 

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

type Output = f64

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

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

fn lerp(from: Self, to: 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, 

impl Lerp<f32> for i8

type Output = i8

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

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

fn lerp(from: Self, to: 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, 

impl Lerp<f64> for i8

type Output = i8

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

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

fn lerp(from: Self, to: 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, 

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

type Output = i8

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

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

impl Lerp<f32> for i16

type Output = i16

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

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

fn lerp(from: Self, to: 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, 

impl Lerp<f64> for i16

type Output = i16

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

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

fn lerp(from: Self, to: 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, 

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

type Output = i16

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

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

fn lerp(from: Self, to: 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, 

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

type Output = i16

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

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

fn lerp(from: Self, to: 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, 

impl Lerp<f32> for i32

type Output = i32

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

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

fn lerp(from: Self, to: 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, 

impl Lerp<f64> for i32

type Output = i32

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

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

fn lerp(from: Self, to: 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, 

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

type Output = i32

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

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

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

type Output = i64

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

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

fn lerp(from: Self, to: 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, 

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

type Output = i64

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

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

fn lerp(from: Self, to: 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, 

impl Lerp<f32> for isize

type Output = isize

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

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

fn lerp(from: Self, to: 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, 

impl Lerp<f64> for isize

type Output = isize

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

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

fn lerp(from: Self, to: 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, 

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

type Output = isize

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

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

impl Lerp<f32> for u8

type Output = u8

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

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

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

type Output = u8

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

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

fn lerp(from: Self, to: 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, 

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

type Output = u8

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

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

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

type Output = u16

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

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

impl Lerp<f32> for u32

type Output = u32

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

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

fn lerp(from: Self, to: 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, 

impl Lerp<f64> for u32

type Output = u32

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

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

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

type Output = u32

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

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

impl Lerp<f64> for u64

type Output = u64

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

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

fn lerp(from: Self, to: 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, 

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

type Output = u64

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

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

fn lerp(from: Self, to: 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, 

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

type Output = u64

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

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

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

fn lerp(from: Self, to: 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, 

Implementors

• impl<T, Factor> Lerp<Factor> for Vec2<T> where
    T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Self;
• impl<'a, T, Factor> Lerp<Factor> for &'a Vec2<T> where
    &'a T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Vec2<T>;
• impl<T, Factor> Lerp<Factor> for Vec3<T> where
    T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Self;
• impl<'a, T, Factor> Lerp<Factor> for &'a Vec3<T> where
    &'a T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Vec3<T>;
• impl<T, Factor> Lerp<Factor> for Vec4<T> where
    T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Self;
• impl<'a, T, Factor> Lerp<Factor> for &'a Vec4<T> where
    &'a T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Vec4<T>;
• impl<T, Factor> Lerp<Factor> for Extent3<T> where
    T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Self;
• impl<'a, T, Factor> Lerp<Factor> for &'a Extent3<T> where
    &'a T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Extent3<T>;
• impl<T, Factor> Lerp<Factor> for Extent2<T> where
    T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Self;
• impl<'a, T, Factor> Lerp<Factor> for &'a Extent2<T> where
    &'a T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Extent2<T>;
• impl<T, Factor> Lerp<Factor> for Rgba<T> where
    T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Self;
• impl<'a, T, Factor> Lerp<Factor> for &'a Rgba<T> where
    &'a T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Rgba<T>;
• impl<T, Factor> Lerp<Factor> for Rgb<T> where
    T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Self;
• impl<'a, T, Factor> Lerp<Factor> for &'a Rgb<T> where
    &'a T: Lerp<Factor, Output = T>,
    Factor: Copy,  type Output = Rgb<T>;
• impl<P, O, S, Factor> Lerp<Factor> for Transform<P, O, S> where
    Factor: Copy + Into<O>,
    P: Lerp<Factor, Output = P>,
    S: Lerp<Factor, Output = S>,
    O: Lerp<O, Output = O> + Float + Sum,  type Output = Self;
• impl<'a, P, O, S, Factor> Lerp<Factor> for &'a Transform<P, O, S> where
    Factor: Copy + Into<O>,
    &'a P: Lerp<Factor, Output = P>,
    &'a S: Lerp<Factor, Output = S>,
    O: Lerp<O, Output = O> + Float + Sum,  type Output = Transform<P, O, S>;
• impl<T, Factor> Lerp<Factor> for Quaternion<T> where
    T: Lerp<Factor, Output = T> + Sum + Float,
    Factor: Copy,  type Output = Self;
• impl<'a, T, Factor> Lerp<Factor> for &'a Quaternion<T> where
    T: Lerp<Factor, Output = T> + Sum + Float,
    Factor: Copy,  type Output = Quaternion<T>;