Struct Stagger 

pub struct Stagger { /* private fields */ }

Parallel staggered animation where each item starts after a fixed delay.

Stagger applies one tween configuration to many items. The start tick for each item is start_tick + delay_ticks * item_index.

By default the animation plays once (LoopMode::Once). Use Stagger::loop_mode to repeat or ping-pong. The total cycle length includes the delay of every item, so all items finish before the next cycle begins.

Example

use slt::anim::{ease_out_quad, Stagger, LoopMode};

let mut stagger = Stagger::new(0.0, 100.0, 30)
    .easing(ease_out_quad)
    .delay(5)
    .loop_mode(LoopMode::Repeat);

stagger.reset(100);
let _ = stagger.value(120, 3);

Implementations

impl Stagger

pub fn new(from: f64, to: f64, duration_ticks: u64) -> Self

Create a new stagger animation template.

Uses linear easing, zero delay, and LoopMode::Once by default.

pub fn easing(self, f: fn(f64) -> f64) -> Self

Set easing for each item’s tween.

pub fn delay(self, ticks: u64) -> Self

Set delay in ticks between consecutive item starts.

pub fn loop_mode(self, mode: LoopMode) -> Self

Set loop behavior. LoopMode::Repeat restarts after all items finish; LoopMode::PingPong reverses direction each cycle.

pub fn on_complete(self, f: impl FnMut() + 'static) -> Self

Register a callback that runs once when the sampled item completes.

pub fn items(self, count: usize) -> Self

Set the number of items for cycle length calculation.

When using LoopMode::Repeat or LoopMode::PingPong, the total cycle length is duration_ticks + delay_ticks * (item_count - 1). If not set, it is inferred from the highest item_index seen.

pub fn value(&mut self, tick: u64, item_index: usize) -> f64

Return the value for item_index at tick.

pub fn is_done(&self) -> bool

Returns true if the last-sampled item reached its end value.

done is updated on every Stagger::value call; sampling value(tick, i) for a non-final i after a later item completed can reset this flag to false. To check whether the entire stagger has finished — independent of which item was sampled last — use Stagger::is_all_done.

pub fn is_all_done(&self, tick: u64, item_count: usize) -> bool

Returns true if all item_count items have passed their end tick.

Independent of which item was sampled last: uses pure tick arithmetic against the configured delay_ticks, duration_ticks, and start_tick. With LoopMode::Repeat / LoopMode::PingPong this only reports true for the first cycle (loops are re-entered after completion).

Example

use slt::Stagger;
let stagger = Stagger::new(0.0, 100.0, 10).delay(5);
// 10 items: last item starts at tick 45, ends at tick 55.
assert!(stagger.is_all_done(60, 10));
assert!(!stagger.is_all_done(40, 10));

pub fn reset(&mut self, tick: u64)

Restart stagger timing, treating tick as the base start time.