Struct FrameClock 

pub struct FrameClock { /* private fields */ }

A fixed-timestep accumulator.

Feed elapsed wall time with advance, then call tick in a loop to drain whole logic steps. Use alpha to interpolate rendering between logic frames.

Implementations

impl FrameClock

pub fn new(hz: u32) -> Self

Create an accumulator targeting hz logic updates per second.

Catch-up is capped at five steps per frame to avoid a “spiral of death” when logic temporarily runs slower than real time.

Panics

Panics if hz is zero.

pub const fn step(&self) -> Duration

The fixed timestep duration.

pub const fn dt_secs(&self) -> f64

The fixed timestep duration in seconds.

pub fn advance(&mut self, dt: Duration)

Add elapsed wall time to the accumulator, clamped to the catch-up cap.

Call once per rendered frame with Frame::delta.

pub fn tick(&mut self) -> bool

Consume one fixed step if enough time has accumulated.

Returns true when a logic step is due (and deducts it). Call in a loop until it returns false, then render:

clock.advance(Duration::from_millis(16));
while clock.tick() {
    // one fixed logic update
}

pub fn alpha(&self) -> f64

Fraction of the next step already accumulated, in 0.0..1.0.

Multiply by the delta between the previous and current state to render an interpolated position between fixed logic frames.

pub const fn reset(&mut self)

Reset the accumulator. Call after a pause to avoid a burst of catch-up steps on the next frame.

Trait Implementations

impl Clone for FrameClock

fn clone(&self) -> FrameClock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FrameClock

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

Formats the value using the given formatter.