Struct Motion 

pub struct Motion {
    pub tracks: Vec<Track>,
    pub duration: f32,
    pub delay: f32,
    pub end_delay: f32,
    pub ease: Easing,
    pub loops: Loop,
    pub alternate: bool,
    pub reversed: bool,
}

A set of tracks that run together, with shared timing.

Fields

tracks: Vec<Track>

duration: f32

Milliseconds each track gets, before per-keyframe overrides.

delay: f32

Milliseconds of stillness before the tracks start. The tracks hold their from value throughout — which is what makes a staggered entrance stay hidden until its turn.

end_delay: f32

Milliseconds of stillness after the tracks finish, inside the iteration — so a loop pauses at the end instead of snapping back.

ease: Easing

loops: Loop

alternate: bool

Play every other iteration backwards.

reversed: bool

Play the whole thing backwards.

Implementations

impl Motion

pub fn new() -> Self

pub fn tween( self, prop: Prop, from: impl Into<AnimValue>, to: impl Into<AnimValue>, ) -> Self

A single leg from from to to.

pub fn keyframes<K: IntoKeyframe>( self, prop: Prop, from: impl Into<AnimValue>, frames: impl IntoIterator<Item = K>, ) -> Self

A multi-leg path for one property. The legs are destinations, or Keyframes when a leg needs its own duration or easing.

pub fn track(self, track: Track) -> Self

pub fn duration(self, ms: f32) -> Self

Milliseconds. Springs ignore it — they run for their settle time.

pub fn delay(self, ms: f32) -> Self

pub fn end_delay(self, ms: f32) -> Self

pub fn ease(self, easing: Easing) -> Self

pub fn loops(self, loops: Loop) -> Self

pub fn repeat(self, times: u32) -> Self

pub fn repeat_forever(self) -> Self

pub fn alternate(self, alternate: bool) -> Self

pub fn reversed(self, reversed: bool) -> Self

pub fn iteration_ms(&self) -> f32

The duration of one pass, delays included.

pub fn total_ms(&self) -> f32

The duration of every pass together, or f32::INFINITY when it loops forever.

pub fn sample(&self, t: f32) -> Frame

The values t milliseconds in.

pub fn sample_into(&self, t: f32, frame: &mut Frame)

Sample into an existing frame. Later writers win, which is how a Sequence layers overlapping motions.

impl Motion

pub fn enter(kind: TransitionKind) -> Self

The entrance Transition plays, as a motion you can retime, delay, stagger or drop into a Sequence.

pub fn enter_from(kind: TransitionKind, distance: f32) -> Self

Motion::enter with the slide distance spelled out.

pub fn exit(kind: TransitionKind) -> Self

The mirror of Motion::enter — ends invisible and displaced.

pub fn exit_to(kind: TransitionKind, distance: f32) -> Self

pub fn as_margins(self) -> Self

Re-express Prop::X/Prop::Y as margins.

Those two are relative insets, which is the right way to move an element in flow — it slides and its neighbours do not care. But an element pinned with absolute() is its inset, so animating one would drag it off its pin and leave it wherever the motion ended. Margins offset a pinned element from where it was pinned, which is the same visible motion without the fight.

pub fn pulse() -> Self

A breathing fade that never stops — the shape of a “working on it” hint that isn’t a spinner.

Trait Implementations

impl Clone for Motion

fn clone(&self) -> Motion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Motion

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

Formats the value using the given formatter.

impl Default for Motion

fn default() -> Self

Returns the “default value” for a type.

impl From<Motion> for Clip

fn from(motion: Motion) -> Self

Converts to this type from the input type.

impl PartialEq for Motion

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Motion