Struct scribl_curves::Lerp

pub struct Lerp { /* fields omitted */ }

Specifies interpolations between two sets of times.

This struct maintains two lists of "key-frame" times, which it uses for mapping times from one scale to another. The two lists of key-frames must have the same length; the ith key-frame of one list is mapped to the ith key-frame of the other list, and times that fall in between key-frames are mapped using linear interpolation. There are various different ways that you can handle times that lie outside the range of key-frames, as illustrated in the examples below.

Examples

let t = |x| Time::from_micros(x);

// Create an "identity" lerp that just maps the interval [100, 200] to itself.
let mut lerp = Lerp::identity(t(100), t(200));

// Now map time 150 to time 180. The interval [100, 150] will be stretched to cover
// [100, 180], and the interval [150, 200] will be squished to [180, 200].
lerp.add_lerp(t(150), t(180));

// The midpoint between 100 and 150 will be mapped to the midpoint between 100 and 180.
assert_eq!(lerp.lerp(t(125)), Some(t(140)));
// The midpoint between 150 and 200 will be mapped to the midpoint between 180 and 200.
assert_eq!(lerp.lerp(t(175)), Some(t(190)));

// Adding a lerp is like taking the *composition* of the two mappings. So taking the previous
// lerp and then sending 140 to 150 means that the original 125 will get sent to 150.
lerp.add_lerp(t(140), t(150));
assert_eq!(lerp.lerp(t(125)), Some(t(150)));
assert_eq!(lerp.lerp(t(120)), Some(t(140)));

// When we map a time to something outside the current output range, something special happens:
// all of the output times will get "squished" to the new time. Currently, the interval
// [125, 200] is getting mapped to [150, 200]; after this line, that whole interval will get
// mapped to 250.
lerp.add_lerp(t(150), t(250));
assert_eq!(lerp.lerp(t(125)), Some(t(250)));
assert_eq!(lerp.lerp(t(199)), Some(t(250)));

// There are three different ways that elements outside the domain can be handled.
// The `lerp` method returns `None` if asked to map something outside its domain.
assert_eq!(lerp.lerp(t(201)), None);
// The `lerp_clamped` method effectively rounds its input to the nearest end of the domain.
assert_eq!(lerp.lerp_clamped(t(201)), t(250));
// The `lerp_extended` method extends the map past the original domain by linear interpolation.
assert_eq!(lerp.lerp_extended(t(201)), t(251));

Implementations

impl Lerp

pub fn identity(start: Time, end: Time) -> Lerp

Creates a new Lerp representing the identity mapping on the interval [start, end].

That is, start will be mapped to start, end will be mapped to end, and everything in between will also be mapped to itself. Times outside the interval [start, end] will be treated differently depending on which of the lerping functions you call.

Examples

let t = |x| Time::from_micros(x);
assert_eq!(Lerp::identity(t(0), t(10)).lerp(t(5)), Some(t(5)));
assert_eq!(Lerp::identity(t(0), t(10)).lerp(t(10)), Some(t(10)));

pub fn first(&self) -> Time

The first time in the range of the mapping.

Examples

let t = |x| Time::from_micros(x);
assert_eq!(
    Lerp::identity(t(10), t(20))
        .with_new_lerp(t(10), t(9))
        .first(),
    t(9)
);

pub fn last(&self) -> Time

The last time in the range of the mapping.

Examples

let t = |x| Time::from_micros(x);
assert_eq!(
    Lerp::identity(t(10), t(20))
        .with_new_lerp(t(20), t(25))
        .last(),
    t(25)
);

pub fn times(&self) -> &[Time]

All of the key frames in the range of the mapping.

Examples

let t = |x| Time::from_micros(x);
assert_eq!(
    Lerp::identity(t(10), t(20))
        .with_new_lerp(t(15), t(18))
        .times(),
    &[t(10), t(18), t(20)]
);

pub fn shifted(&self, shift: TimeDiff) -> Lerp

Returns a clone of this Lerp, with all times shifted by shift.

pub fn lerp(&self, t: Time) -> Option<Time>

pub fn lerp_clamped(&self, t: Time) -> Time

pub fn lerp_extended(&self, t: Time) -> Time

pub fn unlerp(&self, t: Time) -> Option<Time>

pub fn unlerp_clamped(&self, t: Time) -> Time

pub fn unlerp_extended(&self, t: Time) -> Time

pub fn add_lerp(&mut self, time_from: Time, time_to: Time)

pub fn with_new_lerp(&self, time_from: Time, time_to: Time) -> Lerp

Trait Implementations

impl Clone for Lerp

fn clone(&self) -> Lerp

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Lerp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Lerp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl From<Lerp> for Lerp

fn from(lerp: Lerp) -> Lerp

Performs the conversion.

impl PartialEq<Lerp> for Lerp

fn eq(&self, other: &Lerp) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Lerp) -> bool

This method tests for !=.

impl Serialize for Lerp

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Lerp