Struct FixedClock 

pub struct FixedClock {
    pub alpha: f32,
    pub steps_this_frame: u32,
    pub dropped_dt: Duration,
    /* private fields */
}

A fixed-timestep accumulator + render interpolation factor.

Usage per rendered frame:

clock.begin_frame(frame_elapsed); // a Duration
while clock.step() { /* one fixed sim step of clock.fixed_dt() */ }
clock.finish();
let alpha = clock.alpha; // overstep fraction: lerp(prev, curr, alpha)

Fields

alpha: f32

Overstep fraction in [0, 1), set by finish; the render interpolation alpha. Carried debt is not part of it.

steps_this_frame: u32

Fixed steps consumed during the current frame (cadence diagnostic).

dropped_dt: Duration

Supplied time this frame will never simulate, set by begin_frame: the clamped-off delta when render-paced, whole discarded steps under a catch-up policy.

Implementations

impl FixedClock

pub fn new() -> Self

A render-paced clock at the default 60 Hz simulation rate.

pub fn with_hz(hz: f32) -> Self

A render-paced clock at an arbitrary fixed rate: at most one step per frame. The step is Duration::from_secs_f64(1.0 / f64::from(hz)); hz must be positive and give a step of at least one nanosecond.

pub fn with_catch_up(hz: f32, catch_up: CatchUp) -> Self

A clock that follows elapsed time with bounded catch-up (hz as for with_hz and max_steps_per_frame at least 1).

pub fn fixed_step(&self) -> Duration

The exact simulation step.

pub fn fixed_dt(&self) -> f32

The simulation step in seconds, for the game’s integration.

pub fn begin_frame(&mut self, elapsed: Duration)

Begin a rendered frame: add the frame’s elapsed time to the accumulator under the clock’s policy, record dropped_dt, and reset the per-frame step counter.

pub fn step(&mut self) -> bool

Consume one fixed step if enough time has accumulated and the frame’s step budget allows. Drive the fixed simulation in a while clock.step() { .. } loop.

pub fn finish(&mut self)

Finish the frame: compute the render interpolation alpha from the leftover accumulator (the overstep fraction, excluding whole steps of carried debt).

Trait Implementations

impl Clone for FixedClock

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for FixedClock

impl Debug for FixedClock

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

Formats the value using the given formatter.

impl Default for FixedClock

fn default() -> Self

Returns the “default value” for a type.