Struct Time

pub struct Time { /* private fields */ }

Frame timing values.

Implementations

impl Time

pub fn delta_time(&self) -> Duration

Gets the time difference between frames.

pub fn delta_real_time(&self) -> Duration

Gets the time difference between frames ignoring the time speed multiplier.

pub fn fixed_time(&self) -> Duration

Gets the fixed time step. Must be used instead of delta_time during fixed updates.

pub fn frame_number(&self) -> u64

Gets the current frame number. This increments by 1 every frame. There is no frame 0.

pub fn absolute_time(&self) -> Duration

Gets the time since the start of the game, taking into account the speed multiplier.

pub fn absolute_real_time(&self) -> Duration

Gets the time since the start of the game, ignoring the speed multiplier.

pub fn time_scale(&self) -> f32

Gets the current time speed multiplier.

pub fn advance_frame(&mut self, time_diff: Duration)

Sets delta_time to the given Duration. Updates the struct to reflect the changes of this frame. This should be called before using step_fixed_update.

Examples found in repository

examples/simple.rs (line 9)

fn main() {
    let mut time = Time::default();
    time.set_fixed_time(Duration::from_secs_f64(1.0 / 20.0));

    let step = 1.0 / 60.0;
    for _ in 0..60 {
        time.advance_frame(Duration::from_secs_f64(step));
        {} // Run dynamic frame (ie. game logic, rendering)
        while time.step_fixed_update() {
            // runs 20 times in a frame.
            {} // Run fixed frame (ie. physics)
        }
    }
}

pub fn set_fixed_time(&mut self, time: Duration)

Sets both fixed_time and fixed_seconds based on the duration given.

Examples found in repository

examples/simple.rs (line 5)

fn main() {
    let mut time = Time::default();
    time.set_fixed_time(Duration::from_secs_f64(1.0 / 20.0));

    let step = 1.0 / 60.0;
    for _ in 0..60 {
        time.advance_frame(Duration::from_secs_f64(step));
        {} // Run dynamic frame (ie. game logic, rendering)
        while time.step_fixed_update() {
            // runs 20 times in a frame.
            {} // Run fixed frame (ie. physics)
        }
    }
}

pub fn set_time_scale(&mut self, multiplier: f32)

Sets the time multiplier that affects how time values are computed, effectively slowing or speeding up your game.

Panics

This will panic if multiplier is NaN, Infinity, or less than 0.

pub fn step_fixed_update(&mut self) -> bool

Checks to see if we should perform another fixed update iteration, and if so, returns true and reduces the accumulator.

Examples found in repository

examples/simple.rs (line 11)

fn main() {
    let mut time = Time::default();
    time.set_fixed_time(Duration::from_secs_f64(1.0 / 20.0));

    let step = 1.0 / 60.0;
    for _ in 0..60 {
        time.advance_frame(Duration::from_secs_f64(step));
        {} // Run dynamic frame (ie. game logic, rendering)
        while time.step_fixed_update() {
            // runs 20 times in a frame.
            {} // Run fixed frame (ie. physics)
        }
    }
}

Trait Implementations

impl Clone for Time

fn clone(&self) -> Time

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Time

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

Formats the value using the given formatter.

impl Default for Time

fn default() -> Time

Returns the “default value” for a type.

impl PartialEq for Time

fn eq(&self, other: &Time) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Time

impl StructuralPartialEq for Time