Struct Lagged 

pub struct Lagged<T: Clone, E: Eval<Output = T>> {
    anims: Vec<E>,
    lag_ratio: f64,
    _output: PhantomData<fn() -> T>,
}

The lagged anim.

This is applyable to IntoIterator<Item = T>, and this will apply the anims in the order of the elements with the lag ratio.

Fields

anims: Vec<E>

lag_ratio: f64

_output: PhantomData<fn() -> T>

Implementations

impl<T: Clone, E: Eval<Output = T>> Lagged<T, E>

pub fn new(lag_ratio: f64, anims: Vec<E>) -> Self

Constructor

Trait Implementations

impl<T: Clone, E: Eval<Output = T>> Eval for Lagged<T, E>

type Output = Vec<T>

Value produced by this evaluator.

fn eval_alpha(&self, alpha: f64) -> Self::Output

Evaluate the animation at a normalized progress in [0, 1]. Functional segments implement this; iterative segments have no closed form and the default panics (the runtime drives them via sample).

fn sample(&self, time: &SegmentTime) -> Self::Output

Sample the current state at the given time context. Functional default = eval_alpha(time.alpha); iterative segments implement this to return their current state.

fn reset(&mut self)

Reset to the segment’s initial state (deterministic contract: no wall clock, no unseeded RNG). No-op by default.

fn step(&mut self, _time: &SegmentTime)

Advance one logic step (or substep); time.local_delta_secs is the integration step. No-op by default (functional segments are stepped as no-ops for free; sampling is unaffected).

fn apply_to(self, item: &mut Self::Output) -> Self

where Self: Sized,

Apply the final state and return this evaluator.

fn apply_alpha_to(self, item: &mut Self::Output, alpha: f64) -> Self

where Self: Sized,

Apply a sampled state and return this evaluator.