Struct Tween 

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

An animation that interpolates between two values using Timing.

Examples

use aura_anim_core::{Tween, timing::Timing};
use std::time::Duration;

let mut tween = Tween::between(0.0_f32, 10.0, Timing::new(100.0));

tween.tick(Duration::from_millis(50));
assert_eq!(*tween.value(), 5.0);

tween.tick(Duration::from_millis(50));
assert!(tween.is_completed());
assert_eq!(*tween.value(), 10.0);

Implementations

impl<T> Tween<T>

where T: Animatable,

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

Creates an idle tween with the default 200 millisecond timing.

pub fn with_timing(value: T, timing: Timing) -> Tween<T>

Creates an idle tween with the provided timing.

pub fn between(from: T, to: T, timing: Timing) -> Tween<T>

Creates a running tween from from to to.

pub fn value(&self) -> &T

Returns the current interpolated value.

pub fn from(&self) -> &T

Returns the value at the start of the current transition.

pub fn target(&self) -> &T

Returns the target value of the current transition.

pub const fn timing(&self) -> Timing

Returns the timing configuration.

pub const fn state(&self) -> AnimationState

Returns the current lifecycle state.

pub fn is_active(&self) -> bool

Returns whether the tween is currently running.

pub fn is_completed(&self) -> bool

Returns whether the tween has completed.

pub fn transition_to(&mut self, target: T)

Starts a transition from the current value to target.

pub fn tick(&mut self, delta: impl Into<Duration>)

Advances the tween by delta.

pub fn pause(&mut self)

Pauses the tween when it is running.

pub fn resume(&mut self)

Resumes the tween when it is paused.

pub fn cancel(&mut self)

Cancels the tween unless it is already completed or canceled.

pub fn seek(&mut self, progress: f32)

Seeks to normalized progress within the complete timing interval.

pub fn finish(&mut self)

Moves the tween to its final value and completed state.

Trait Implementations

impl<T> Animation<T> for Tween<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.

impl<T> Clone for Tween<T>

where T: Clone + Animatable,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Tween<T>

where T: Debug + Animatable,

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

Formats the value using the given formatter.