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 &GameState
s 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
Required Methods
fn lerp_unclamped(from: Self, to: Self, factor: Factor) -> Self::Output
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
fn lerp_unclamped_inclusive_range(
range: RangeInclusive<Self>,
factor: Factor
) -> Self::Output
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.
fn lerp_unclamped_precise(from: Self, to: Self, factor: Factor) -> Self::Output
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);
fn lerp_unclamped_precise_inclusive_range(
range: RangeInclusive<Self>,
factor: Factor
) -> Self::Output
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.
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_inclusive_range(
range: RangeInclusive<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,
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);
fn lerp_precise_inclusive_range(
range: RangeInclusive<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,
Version of lerp_precise()
that used a single RangeInclusive
parameter instead of two values.
Implementations on Foreign Types
sourceimpl Lerp<f32> for f32
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
sourceimpl<'a> Lerp<f32> for &'a f32
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
sourceimpl Lerp<f64> for f64
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
sourceimpl<'a> Lerp<f64> for &'a f64
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
sourceimpl Lerp<f32> for i8
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
sourceimpl Lerp<f64> for i8
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
sourceimpl<'a> Lerp<f32> for &'a i8
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
sourceimpl<'a> Lerp<f64> for &'a i8
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
sourceimpl Lerp<f32> for i16
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
sourceimpl Lerp<f64> for i16
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
sourceimpl<'a> Lerp<f32> for &'a i16
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
sourceimpl<'a> Lerp<f64> for &'a i16
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
sourceimpl Lerp<f32> for i32
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
sourceimpl Lerp<f64> for i32
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
sourceimpl<'a> Lerp<f32> for &'a i32
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
sourceimpl<'a> Lerp<f64> for &'a i32
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
sourceimpl Lerp<f32> for i64
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
sourceimpl Lerp<f64> for i64
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
sourceimpl<'a> Lerp<f32> for &'a i64
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
sourceimpl<'a> Lerp<f64> for &'a i64
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
sourceimpl Lerp<f32> for isize
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
sourceimpl Lerp<f64> for isize
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
sourceimpl<'a> Lerp<f32> for &'a isize
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
sourceimpl<'a> Lerp<f64> for &'a isize
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
sourceimpl Lerp<f32> for u8
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
sourceimpl Lerp<f64> for u8
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
sourceimpl<'a> Lerp<f32> for &'a u8
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
sourceimpl<'a> Lerp<f64> for &'a u8
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
sourceimpl Lerp<f32> for u16
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
sourceimpl Lerp<f64> for u16
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
sourceimpl<'a> Lerp<f32> for &'a u16
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
sourceimpl<'a> Lerp<f64> for &'a u16
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
sourceimpl Lerp<f32> for u32
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
sourceimpl Lerp<f64> for u32
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
sourceimpl<'a> Lerp<f32> for &'a u32
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
sourceimpl<'a> Lerp<f64> for &'a u32
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
sourceimpl Lerp<f32> for u64
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
sourceimpl Lerp<f64> for u64
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
sourceimpl<'a> Lerp<f32> for &'a u64
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
sourceimpl<'a> Lerp<f64> for &'a u64
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
sourceimpl Lerp<f32> for usize
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
sourceimpl Lerp<f64> for 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
sourceimpl<'a> Lerp<f32> for &'a usize
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
sourceimpl<'a> Lerp<f64> for &'a usize
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
Implementors
sourceimpl<'a, P, O, S, Factor> Lerp<Factor> for &'a vek::transform::repr_c::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> + Real + Add<Output = O>,
impl<'a, P, O, S, Factor> Lerp<Factor> for &'a vek::transform::repr_c::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> + Real + Add<Output = O>,
LERP on a Transform
is defined as LERP-ing between the positions and scales,
and performing SLERP between the orientations.
sourceimpl<'a, P, O, S, Factor> Lerp<Factor> for &'a vek::transform::repr_simd::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> + Real + Add<Output = O>,
impl<'a, P, O, S, Factor> Lerp<Factor> for &'a vek::transform::repr_simd::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> + Real + Add<Output = O>,
LERP on a Transform
is defined as LERP-ing between the positions and scales,
and performing SLERP between the orientations.
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::quaternion::repr_c::Quaternion<T> where
T: Lerp<Factor, Output = T> + Add<T, Output = T> + Real,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::quaternion::repr_c::Quaternion<T> where
T: Lerp<Factor, Output = T> + Add<T, Output = T> + Real,
Factor: Copy,
The Lerp
implementation for quaternion is the “Normalized LERP”.
type Output = Quaternion<T>
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::quaternion::repr_simd::Quaternion<T> where
T: Lerp<Factor, Output = T> + Add<T, Output = T> + Real,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::quaternion::repr_simd::Quaternion<T> where
T: Lerp<Factor, Output = T> + Add<T, Output = T> + Real,
Factor: Copy,
The Lerp
implementation for quaternion is the “Normalized LERP”.
type Output = Quaternion<T>
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::extent2::Extent2<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::extent2::Extent2<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::extent3::Extent3<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::extent3::Extent3<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::rgb::Rgb<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::rgb::Rgb<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::rgba::Rgba<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::rgba::Rgba<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::vec2::Vec2<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::vec2::Vec2<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::vec3::Vec3<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::vec3::Vec3<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::vec4::Vec4<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_c::vec4::Vec4<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::extent2::Extent2<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::extent2::Extent2<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::extent3::Extent3<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::extent3::Extent3<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::rgb::Rgb<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::rgb::Rgb<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::rgba::Rgba<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::rgba::Rgba<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::vec2::Vec2<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::vec2::Vec2<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::vec3::Vec3<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::vec3::Vec3<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::vec4::Vec4<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
impl<'a, T, Factor> Lerp<Factor> for &'a vek::vec::repr_simd::vec4::Vec4<T> where
&'a T: Lerp<Factor, Output = T>,
Factor: Copy,
sourceimpl<P, O, S, Factor> Lerp<Factor> for vek::transform::repr_c::Transform<P, O, S> where
Factor: Copy + Into<O>,
P: Lerp<Factor, Output = P>,
S: Lerp<Factor, Output = S>,
O: Lerp<O, Output = O> + Real + Add<Output = O>,
impl<P, O, S, Factor> Lerp<Factor> for vek::transform::repr_c::Transform<P, O, S> where
Factor: Copy + Into<O>,
P: Lerp<Factor, Output = P>,
S: Lerp<Factor, Output = S>,
O: Lerp<O, Output = O> + Real + Add<Output = O>,
LERP on a Transform
is defined as LERP-ing between the positions and scales,
and performing SLERP between the orientations.
sourceimpl<P, O, S, Factor> Lerp<Factor> for vek::transform::repr_simd::Transform<P, O, S> where
Factor: Copy + Into<O>,
P: Lerp<Factor, Output = P>,
S: Lerp<Factor, Output = S>,
O: Lerp<O, Output = O> + Real + Add<Output = O>,
impl<P, O, S, Factor> Lerp<Factor> for vek::transform::repr_simd::Transform<P, O, S> where
Factor: Copy + Into<O>,
P: Lerp<Factor, Output = P>,
S: Lerp<Factor, Output = S>,
O: Lerp<O, Output = O> + Real + Add<Output = O>,
LERP on a Transform
is defined as LERP-ing between the positions and scales,
and performing SLERP between the orientations.
sourceimpl<T, Factor> Lerp<Factor> for vek::quaternion::repr_c::Quaternion<T> where
T: Lerp<Factor, Output = T> + Add<T, Output = T> + Real,
Factor: Copy,
impl<T, Factor> Lerp<Factor> for vek::quaternion::repr_c::Quaternion<T> where
T: Lerp<Factor, Output = T> + Add<T, Output = T> + Real,
Factor: Copy,
The Lerp
implementation for quaternion is the “Normalized LERP”.
type Output = Quaternion<T>
sourceimpl<T, Factor> Lerp<Factor> for vek::quaternion::repr_simd::Quaternion<T> where
T: Lerp<Factor, Output = T> + Add<T, Output = T> + Real,
Factor: Copy,
impl<T, Factor> Lerp<Factor> for vek::quaternion::repr_simd::Quaternion<T> where
T: Lerp<Factor, Output = T> + Add<T, Output = T> + Real,
Factor: Copy,
The Lerp
implementation for quaternion is the “Normalized LERP”.