Struct Sequence 

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

Runs child animations one after another.

Examples

use aura_anim_core::{
    Animation, Sequence, Tween,
    timing::{Duration, Timing},
};

let mut sequence = Sequence::new(0.0_f32)
    .then(Tween::between(0.0, 1.0, Timing::new(100.0)))
    .then(Tween::between(1.0, 2.0, Timing::new(100.0)));

sequence.tick(Duration::from_millis(150.0));
assert_eq!(*sequence.value(), 1.5);

Implementations

impl<T> Sequence<T>

where T: Animatable,

pub fn new(initial: T) -> Sequence<T>

Creates an empty sequence with an initial output value.

pub fn then(self, animation: impl Animation<T>) -> Sequence<T>

Appends an animation and returns the updated sequence.

pub fn push(&mut self, animation: impl Animation<T>)

Appends an animation to the sequence.

pub fn len(&self) -> usize

Returns the number of child animations.

pub fn is_empty(&self) -> bool

Returns whether the sequence contains no child animations.

Trait Implementations

impl<T> Animation<T> for Sequence<T>

where T: Animatable,

fn value(&self) -> &T

Returns the animation’s current value.

fn state(&self) -> AnimationState

Returns the animation’s lifecycle state.

fn duration(&self) -> Option<Duration>

Returns the total duration when it is finite and known.

fn tick(&mut self, delta: Duration)

Advances the animation by delta.

fn advance(&mut self, delta: Duration) -> Duration

Advances the animation and returns any unconsumed duration.

fn pause(&mut self)

Pauses a running animation.

fn resume(&mut self)

Resumes a paused animation.

fn cancel(&mut self)

Cancels the animation.

fn seek(&mut self, progress: f32)

Seeks to normalized progress within the animation.

fn finish(&mut self)

Moves the animation to its completed state.

fn retarget(&mut self, _target: &T) -> bool

Attempts to continue the animation toward a new target.

fn is_active(&self) -> bool

Returns whether the animation is currently running.