Struct AnimLagged 

pub struct AnimLagged {
    animations: Vec<AnimNode>,
    lag_ratio: f64,
    cursor_sec: f64,
    duration_secs: f64,
    leading: LaggedFill,
    trailing: LaggedFill,
}

Dynamic lagged (staggered, end-filled) animation container.

Children are pushed un-placed (Unplaced); the container computes the placement itself: child i starts at start_{i-1} + lag_ratio · d_{i-1}. lag_ratio interpolates between the other two containers:

• 0.0 — all children start together (like AnimStack);
• 1.0 — each child starts when the previous ends (like AnimSequence);
• in between — overlapping succession.

By default the time outside a child’s window is filled with real static cells (LaggedFill::Hold on both ends): each item is materialized at build time as a per-item sequence track [leading fill][anim][trailing fill] spanning the whole extent — before its start the item shows its initial state, after its end it keeps showing its final state, and the preview timeline shows exactly what is rendered. Configure with with_leading / with_trailing — e.g. Empty leading makes items appear only at their window; to hide an item after its window instead of holding it, give it an animation that ends hidden, e.g. seq![item.fade_in(), item.hide()].

Fills are sampled at build time: empty fills are skipped, and a zero-duration child gets no leading fill (it appears at its point, which is what “show from that point on” means). Because fills are build-time samples, children are expected to be pure (closed-form) animations — a stateful child’s trailing fill would be its initial state, not its true final state.

Fields

animations: Vec<AnimNode>

lag_ratio: f64

cursor_sec: f64

Start offset for the next pushed child.

duration_secs: f64

leading: LaggedFill

trailing: LaggedFill

Implementations

impl AnimLagged

pub fn new(lag_ratio: f64) -> Self

Create an empty lagged container with the given stagger ratio.

pub fn lag_ratio(&self) -> f64

The stagger ratio between successive children.

pub fn with_leading(self, behavior: LaggedFill) -> Self

Configure the fill before each child’s window (default LaggedFill::Hold).

pub fn with_trailing(self, behavior: LaggedFill) -> Self

Configure the fill after each child’s window (default LaggedFill::Hold).

pub fn push<A: Unplaced + 'static>(&mut self, animation: A) -> &mut Self

Add an animation, placed by the container’s stagger rule.

fn materialize_fills(&mut self)

Materialize each child as a per-item sequence track: [leading fill][anim][trailing fill] (empty fills skipped).

The lagged container is thus a stack of per-item sequences — each item’s track spans the whole extent, with its window-edge states held by real static cells.

pub fn duration_secs(&self) -> f64

Current total extent (the last child’s end).

pub fn built_animations(&self) -> &[AnimNode]

Borrow the children as placed by the stagger rule — the pre-materialization view, before build turns them into filled tracks.

Trait Implementations

impl IntoAnimNode for AnimLagged

fn into_anim_node(self) -> AnimNode

Desugar: materialize each item into a full-extent sequence track, then lower the whole container to a plain runtime stack node — the stagger is ordinary window placement, so lagged needs no runtime kind of its own. anim_name keeps the authoring identity.

impl Unplaced for AnimLagged

fn at(self, offset_sec: f64) -> At<Self>

Place this definition at an offset in its parent’s local time coordinates.