Struct StaggeredAnimation 

pub struct StaggeredAnimation<T: Interpolate> {
    pub base_delay: f32,
    pub stagger_delay: f32,
    pub duration: f32,
    pub easing: EasingFunction,
    /* private fields */
}

Staggered animation system for multiple items

Creates a choreographed animation where items animate in sequence with configurable delays between them.

Example

use armas_basic::animation::StaggeredAnimation;

// Fade in 5 items, each delayed by 0.1s, taking 0.3s each
let mut anim = StaggeredAnimation::new(0.0_f32, 1.0, 5, 0.1, 0.3);
anim.update(0.2);
let opacity_0 = anim.opacity(0); // mostly visible
let opacity_4 = anim.opacity(4); // not started yet

Fields

base_delay: f32

Base delay before first item starts (seconds)

stagger_delay: f32

Delay between each item (seconds)

duration: f32

Duration of each item’s animation (seconds)

easing: EasingFunction

Easing function for each item

Implementations

impl<T: Interpolate> StaggeredAnimation<T>

pub const fn new( start: T, end: T, item_count: usize, stagger_delay: f32, duration: f32, ) -> Self

Create a new staggered animation

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

Set the base delay before first item

pub const fn easing(self, easing: EasingFunction) -> Self

Set the easing function

pub fn update(&mut self, dt: f32)

Update the animation

pub const fn reset(&mut self)

Reset the animation

pub fn value(&self, index: usize) -> T

Get the value for a specific item index

pub fn progress(&self, index: usize) -> f32

Get the progress (0.0 to 1.0) for a specific item

pub fn is_complete(&self) -> bool

Check if all items have completed

pub fn opacity(&self, index: usize) -> f32

Get opacity for item (useful for fade-in effects)

pub fn scale(&self, index: usize) -> f32

Get scale for item (useful for scale-in effects)

pub fn y_offset(&self, index: usize, distance: f32) -> f32

Get Y offset for item (useful for slide-in effects)

Trait Implementations

impl<T: Clone + Interpolate> Clone for StaggeredAnimation<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Interpolate> Debug for StaggeredAnimation<T>

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

Formats the value using the given formatter.