Trait prisma::Lerp

pub trait Lerp {
    type Position: Float;
    fn lerp(&self, right: &Self, pos: Self::Position) -> Self;
}

A value that can be linearly interpolated between two values

Associated Types

type Position: Float

The type of the pos argument

Loading content...

Required methods

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

Interpolate between self and right

pos specifies how far between the two values to interpolate on a line, between zero and one.

$pos = 0$ would return self while $pos = 1$ would return right.

Loading content...

Implementations on Foreign Types

impl<T> Lerp for Deg<T> where
    T: Float, 

type Position = T

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T> Lerp for Rad<T> where
    T: Float, 

type Position = T

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T> Lerp for Turns<T> where
    T: Float, 

type Position = T

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T> Lerp for ArcMinutes<T> where
    T: Float, 

type Position = T

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T> Lerp for ArcSeconds<T> where
    T: Float, 

type Position = T

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl Lerp for u8

type Position = f64

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl Lerp for u16

type Position = f64

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl Lerp for u32

type Position = f64

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl Lerp for f32

type Position = f32

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl Lerp for f64

type Position = f64

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

Loading content...

Implementors

impl<C, E> Lerp for EncodedColor<C, E> where
    C: Color + Lerp + EncodableColor,
    E: ColorEncoding + PartialEq, 

type Position = C::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T> Lerp for AngularChannel<T> where
    T: Angle + Lerp, 

type Position = T::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T> Lerp for NormalBoundedChannel<T> where
    T: NormalChannelScalar + Lerp, 

type Position = <T as Lerp>::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T> Lerp for PosNormalBoundedChannel<T> where
    T: PosNormalChannelScalar + Lerp, 

type Position = <T as Lerp>::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T> Lerp for FreeChannel<T> where
    T: FreeChannelScalar + Lerp, 

type Position = <T as Lerp>::Position

fn lerp(&self, right: &FreeChannel<T>, pos: Self::Position) -> Self

impl<T> Lerp for PosFreeChannel<T> where
    T: FreeChannelScalar + Lerp, 

type Position = <T as Lerp>::Position

fn lerp(&self, right: &PosFreeChannel<T>, pos: Self::Position) -> Self

impl<T> Lerp for Rgb<T> where
    T: PosNormalChannelScalar + Lerp, 

type Position = <T as Lerp>::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T> Lerp for Rgi<T> where
    T: PosNormalChannelScalar + Lerp + Float, 

type Position = <T as Lerp>::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T> Lerp for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + Float,
    FreeChannel<T>: Lerp,
    PosNormalBoundedChannel<T>: Lerp<Position = <FreeChannel<T> as Lerp>::Position>, 

type Position = <FreeChannel<T> as Lerp>::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T> Lerp for Xyz<T> where
    T: FreeChannelScalar,
    PosFreeChannel<T>: Lerp, 

type Position = <PosFreeChannel<T> as Lerp>::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T> Lerp for BareYCbCr<T> where
    T: PosNormalChannelScalar + NormalChannelScalar + Lerp, 

type Position = <T as Lerp>::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T, A> Lerp for Hsi<T, A> where
    T: PosNormalChannelScalar + Lerp,
    A: AngularChannelScalar + Lerp, 

type Position = A::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T, A> Lerp for Hsl<T, A> where
    T: PosNormalChannelScalar + Lerp,
    A: AngularChannelScalar + Lerp, 

type Position = A::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T, A> Lerp for Hsv<T, A> where
    T: PosNormalChannelScalar + Lerp,
    A: AngularChannelScalar + Lerp, 

type Position = A::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T, A> Lerp for Hwb<T, A> where
    T: PosNormalChannelScalar + Float + Lerp,
    A: AngularChannelScalar + Lerp, 

type Position = A::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T, A> Lerp for eHsi<T, A> where
    T: PosNormalChannelScalar + Lerp,
    A: AngularChannelScalar + Lerp, 

type Position = A::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T, C, E, S> Lerp for SpacedColor<T, C, E, S> where
    C: Color + EncodableColor + Lerp,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float, 

type Position = C::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T, InnerColor> Lerp for Alpha<T, InnerColor> where
    T: PosNormalChannelScalar + Lerp<Position = InnerColor::Position>,
    InnerColor: Color + Lerp, 

type Position = InnerColor::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T, M> Lerp for YCbCr<T, M> where
    T: NormalChannelScalar + Lerp + PosNormalChannelScalar,
    M: YCbCrModel<T>, 

type Position = <T as Lerp>::Position

fn lerp(&self, other: &Self, pos: Self::Position) -> Self

impl<T, Model> Lerp for Lms<T, Model> where
    T: FreeChannelScalar,
    Model: LmsModel<T>,
    FreeChannel<T>: Lerp, 

type Position = <FreeChannel<T> as Lerp>::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T, W> Lerp for Lab<T, W> where
    T: FreeChannelScalar + Lerp,
    W: WhitePoint<T>, 

type Position = <FreeChannel<T> as Lerp>::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T, W> Lerp for Luv<T, W> where
    T: FreeChannelScalar + Lerp,
    W: WhitePoint<T>, 

type Position = <FreeChannel<T> as Lerp>::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T, W, A> Lerp for Lchab<T, W, A> where
    T: FreeChannelScalar + Lerp,
    A: AngularChannelScalar + Lerp,
    W: WhitePoint<T>, 

type Position = A::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

impl<T, W, A> Lerp for Lchuv<T, W, A> where
    T: FreeChannelScalar + Lerp,
    A: AngularChannelScalar + Lerp,
    W: WhitePoint<T>, 

type Position = A::Position

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

Loading content...