Struct MotionValue 

pub struct MotionValue<T>
where
    T: Animatable,
{ /* private fields */ }

A value following its target on a spring, in closed form.

• Self::set starts a new segment from the value and velocity the current one has at now, so a reversal or a new target mid-flight never jumps and never stalls; repeated changes are one motion, never a queue.
• Self::get is exact at any now: the curve does not depend on how often, or whether, frames were drawn.
• Once within tolerance the value is the target, and Self::is_moving is false: a settled value asks for no frames.

Implementations

impl<T> MotionValue<T>

where T: Animatable,

pub fn new(value: T) -> MotionValue<T>

A value at rest.

pub fn with_tolerance(self, tolerance: f64) -> MotionValue<T>

The same value, arriving within tolerance per channel instead of the type’s default (a scalar carrying pixels rather than a fraction).

pub fn target(&self) -> T

Where the value is going (or is, at rest).

pub fn get(&self, now: Instant) -> T

pub fn velocity(&self, now: Instant) -> T

The velocity at now, per second, in the value’s own units.

pub fn is_moving(&self, now: Instant) -> bool

Whether the value is still on its way at now.

pub fn settles_at(&self) -> Option<Instant>

When the current motion arrives; None at rest. A host that sleeps until then instead of drawing frames has nothing to draw anyway.

pub fn defer(&mut self, by: Duration)

Hold the motion for by: time spent waiting (on a full presenter) is not progress, so the curve resumes where it stood.

pub fn shift_by(&mut self, by: T)

Move the whole motion by by: where it is going and every point of its way there, keeping its pace. For a value measured in a frame that moved under it (a pan whose canvas lost a window before the view): what it shows on screen goes on unchanged.

pub fn sampled_after(&self, elapsed: Duration) -> (T, T)

The value and its velocity elapsed into the current segment, whatever the clock says: a capture posing a motion at a chosen point of its run, since an offscreen frame costs more wall time than the whole motion lasts. Never for a live frame, which reads Self::get at its instant.

pub fn snap(&mut self, value: T)

Jump to value and rest there. A motion that was on its way takes back its wish for frames: whoever landed it draws the change.

pub fn set(&mut self, target: T, timing: Timing, now: Instant)

Send the value to target with timing, starting at now from where it is drawn and how fast it is moving there. Setting the target it is already going to changes nothing (a repeated request never restarts the curve).

pub fn release(&mut self, target: T, velocity: T, timing: Timing, now: Instant)

Send the value to target carrying velocity (a gesture’s release, a kick), whatever it was doing.

Trait Implementations

impl<T> Clone for MotionValue<T>

where T: Clone + Animatable,

fn clone(&self) -> MotionValue<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for MotionValue<T>

where T: Debug + Animatable,

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

Formats the value using the given formatter.

impl<T> Default for MotionValue<T>

where T: Animatable + Default,

fn default() -> MotionValue<T>

Returns the “default value” for a type.

impl<T> Copy for MotionValue<T>

where T: Copy + Animatable,