Trait Interpolate 

pub trait Interpolate: Sized {
    // Required method
    fn interpolate_progress(
        from: &Self,
        to: &Self,
        progress: InterpolationProgress,
    ) -> Self;

    // Provided methods
    fn lerp(&self, other: &Self, progress: f32) -> Self { ... }
    fn interpolate(from: &Self, to: &Self, progress: f32) -> Self { ... }
    fn extrapolate(from: &Self, to: &Self, progress: f32) -> Self { ... }
}

Interpolates values of the same type.

Required Methods

fn interpolate_progress( from: &Self, to: &Self, progress: InterpolationProgress, ) -> Self

Interpolates from from to to using a prepared progress value.

Provided Methods

fn lerp(&self, other: &Self, progress: f32) -> Self

Interpolates from self to other using normalized progress.

fn interpolate(from: &Self, to: &Self, progress: f32) -> Self

Interpolates from from to to using normalized progress.

fn extrapolate(from: &Self, to: &Self, progress: f32) -> Self

Interpolates or extrapolates from from to to without clamping finite progress.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Interpolate for Border

Available on crate features oklaba or rgba only.

fn interpolate_progress( from: &Border, to: &Border, progress: InterpolationProgress, ) -> Border

impl Interpolate for Color

Available on crate feature rgba only.

fn interpolate_progress( from: &Color, to: &Color, progress: InterpolationProgress, ) -> Color

impl Interpolate for Padding

fn interpolate_progress( from: &Padding, to: &Padding, progress: InterpolationProgress, ) -> Padding

impl Interpolate for Radius

fn interpolate_progress( from: &Radius, to: &Radius, progress: InterpolationProgress, ) -> Radius

impl Interpolate for Shadow

Available on crate features oklaba or rgba only.

fn interpolate_progress( from: &Shadow, to: &Shadow, progress: InterpolationProgress, ) -> Shadow

impl Interpolate for f32

fn interpolate_progress( from: &f32, to: &f32, progress: InterpolationProgress, ) -> f32

impl Interpolate for f64

fn interpolate_progress( from: &f64, to: &f64, progress: InterpolationProgress, ) -> f64

impl Interpolate for i8

fn interpolate_progress( from: &i8, to: &i8, progress: InterpolationProgress, ) -> i8

impl Interpolate for i16

fn interpolate_progress( from: &i16, to: &i16, progress: InterpolationProgress, ) -> i16

impl Interpolate for i32

fn interpolate_progress( from: &i32, to: &i32, progress: InterpolationProgress, ) -> i32

impl Interpolate for u8

fn interpolate_progress( from: &u8, to: &u8, progress: InterpolationProgress, ) -> u8

impl Interpolate for u16

fn interpolate_progress( from: &u16, to: &u16, progress: InterpolationProgress, ) -> u16

impl Interpolate for u32

fn interpolate_progress( from: &u32, to: &u32, progress: InterpolationProgress, ) -> u32

impl<A, B, C, D> Interpolate for (A, B, C, D)

where A: Interpolate + Clone, B: Interpolate + Clone, C: Interpolate + Clone, D: Interpolate + Clone,

fn interpolate_progress( from: &(A, B, C, D), to: &(A, B, C, D), progress: InterpolationProgress, ) -> (A, B, C, D)

impl<A, B, C> Interpolate for (A, B, C)

where A: Interpolate + Clone, B: Interpolate + Clone, C: Interpolate + Clone,

fn interpolate_progress( from: &(A, B, C), to: &(A, B, C), progress: InterpolationProgress, ) -> (A, B, C)

impl<A, B> Interpolate for (A, B)

where A: Interpolate + Clone, B: Interpolate + Clone,

fn interpolate_progress( from: &(A, B), to: &(A, B), progress: InterpolationProgress, ) -> (A, B)

impl<T, const N: usize> Interpolate for [T; N]

where T: Interpolate + Clone,

fn interpolate_progress( from: &[T; N], to: &[T; N], progress: InterpolationProgress, ) -> [T; N]

impl<T> Interpolate for Point<T>

where T: Interpolate + Clone,

fn interpolate_progress( from: &Point<T>, to: &Point<T>, progress: InterpolationProgress, ) -> Point<T>

impl<T> Interpolate for Rectangle<T>

where T: Interpolate + Clone,

fn interpolate_progress( from: &Rectangle<T>, to: &Rectangle<T>, progress: InterpolationProgress, ) -> Rectangle<T>

impl<T> Interpolate for Size<T>

where T: Interpolate + Clone,

fn interpolate_progress( from: &Size<T>, to: &Size<T>, progress: InterpolationProgress, ) -> Size<T>

impl<T> Interpolate for Vector<T>

where T: Interpolate + Clone,

fn interpolate_progress( from: &Vector<T>, to: &Vector<T>, progress: InterpolationProgress, ) -> Vector<T>

Implementors