Struct Tween 

pub struct Tween<T: Animatable> {
    pub start: T,
    pub end: T,
    pub duration: f32,
    pub easing: Easing,
    pub delay: f32,
    pub time_scale: f32,
    pub looping: Loop,
    /* private fields */
}

A single-value animation from start to end over duration seconds.

Build with Tween::new and the consuming builder chain:

use animato_tween::Tween;
use animato_core::Easing;

let mut t = Tween::new(0.0_f32, 100.0)
    .duration(1.5)
    .easing(Easing::EaseOutCubic)
    .delay(0.2)
    .build();

no_std

Tween<T> is stack-allocated — no heap allocation occurs in update() or value().

Fields

start: T

The value at t = 0.

end: T

The value at t = duration.

duration: f32

Total animation duration in seconds. Clamped to ≥ 0.

easing: Easing

Easing curve applied to the normalised progress.

delay: f32

Delay in seconds before the animation begins.

time_scale: f32

Time scale multiplier. 1.0 = normal, 2.0 = double speed.

looping: Loop

Looping behaviour.

Implementations

impl<T: Animatable> Tween<T>

pub fn new(start: T, end: T) -> TweenBuilder<T>

Begin building a tween from start to end.

use animato_tween::Tween;
use animato_core::Easing;

let t = Tween::new(0.0_f32, 1.0)
    .duration(2.0)
    .easing(Easing::EaseInOutSine)
    .build();

impl<T: Animatable> Tween<T>

pub fn value(&self) -> T

The current interpolated value.

This is the hot path — no allocation, just a lerp.

use animato_tween::Tween;
use animato_core::Easing;

let t = Tween::new(0.0_f32, 100.0).duration(1.0).build();
assert_eq!(t.value(), 0.0); // hasn't started yet

pub fn progress(&self) -> f32

Normalised progress in [0.0, 1.0] — raw, before easing.

pub fn eased_progress(&self) -> f32

Normalised progress after easing is applied.

pub fn is_complete(&self) -> bool

true when the tween has finished all its loops.

pub fn state(&self) -> &TweenState

Current execution state.

pub fn reset(&mut self)

Reset to the very beginning, including delay and loop counter.

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

Jump to a normalised time t ∈ [0, 1] within the current pass.

Does not affect loop count or ping-pong direction.

pub fn reverse(&mut self)

Swap start and end in place.

The animation immediately plays toward the new end.

When called mid-animation, the current visual position is preserved — elapsed is mirrored so the object appears to continue from where it is.

Example

use animato_tween::Tween;
use animato_core::{Easing, Update};

let mut t = Tween::new(0.0_f32, 100.0)
    .duration(1.0)
    .easing(Easing::Linear)
    .build();
// Advance 30% of the way
t.update(0.3);
assert!((t.value() - 30.0).abs() < 1.0);
// Reverse — now at 70% of the backward journey (100→0)
t.reverse();
assert!((t.value() - 30.0).abs() < 1.0); // same visual position

pub fn pause(&mut self)

Pause — update() calls become no-ops until resume.

pub fn resume(&mut self)

Resume from a paused state.

Trait Implementations

impl<T: Clone + Animatable> Clone for Tween<T>

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 + Animatable> Debug for Tween<T>

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

Formats the value using the given formatter.

impl<T: Animatable> Playable for Tween<T>

fn duration(&self) -> f32

Total finite duration in seconds.

fn reset(&mut self)

Reset the animation to its initial state.

fn seek_to(&mut self, progress: f32)

Seek to normalized progress through the animation.

fn is_complete(&self) -> bool

true when the animation has reached its terminal state.

fn as_any(&self) -> &dyn Any

Return a type-erased shared reference for downcasting.

fn as_any_mut(&mut self) -> &mut dyn Any

Return a type-erased mutable reference for downcasting.

impl<T: Animatable> Update for Tween<T>

fn update(&mut self, dt: f32) -> bool

Advance the tween by dt seconds.

Returns true while still running, false when complete. Negative dt is treated as 0.0.