Struct Time 

pub struct Time {
    pub fps: f64,
    pub delta: f64,
    pub tick_count: u64,
    pub elapsed: f64,
    pub start_time: Instant,
    pub prev_time: Instant,
    pub prev_sec: Instant,
    pub local_tick: u32,
    /* private fields */
}

Frame timing data — delta time, smoothed FPS, and elapsed wall-clock time.

Time is updated once per frame by the engine (via Time::update) before user code runs. It provides three fundamental measurements:

Field	Meaning	Use case
delta	Seconds since the last frame	Physics, movement (frame-rate independent)
fps	Smoothed frames-per-second	Display in HUD, performance monitoring
elapsed	Total seconds since start	Timers, countdowns, replays

FPS smoothing

The FPS value is a running average of the last 32 delta samples. This avoids jarring frame-to-frame fluctuations while still responding to sustained changes in frame rate. The smoothing window size is fixed.

Which timing method should I use?

You want…	Use
Frame-independent movement speed	delta
“Time since game started”	elapsed
Timestamp for logging / profiling	now_ms
“5 seconds from now”	let deadline = time.elapsed() + 5.0;

Example

use optic_loop::Time;

let mut time = Time::new();

// Simulate a 16 ms frame
std::thread::sleep(std::time::Duration::from_millis(16));
time.update();

println!("Delta: {:.4}s  FPS: {:.1}", time.delta(), time.fps());
// → "Delta: 0.0160s  FPS: 62.5"

Fields

fps: f64

delta: f64

tick_count: u64

elapsed: f64

start_time: Instant

prev_time: Instant

prev_sec: Instant

local_tick: u32

Implementations

impl Time

pub fn new() -> Self

Creates a new timer with all counters at zero.

The internal start_time is set to the current wall-clock instant.

pub fn update(&mut self)

Advances the timer by one frame.

Called automatically by the engine each frame. Increments tick_count, computes delta and elapsed from wall-clock time, and updates the smoothed FPS.

You should not normally call this manually — Game and GameLoop call it before invoking user code.

pub fn fps(&self) -> f64

Smoothed frames-per-second (averaged over the last 32 frames).

pub fn delta(&self) -> f64

Delta time in seconds since the last frame.

Multiply speeds by this value to get frame-rate-independent motion:

let speed = 10.0; // units per second
entity.position.x += speed * time.delta();

pub fn elapsed(&self) -> f64

Total wall-clock seconds since Time::new was called.

pub fn now(&self) -> f64

Current elapsed time in seconds (re-queries Instant::now).

Unlike elapsed, this always returns the very latest wall-clock time, even if update has not been called yet for this frame.

pub fn now_ms(&self) -> u64

Current elapsed time in milliseconds.

pub fn now_as_ms(&self) -> u64

Alias for now_ms.

pub fn now_as_ns(&self) -> u64

Current elapsed time in nanoseconds.

pub fn sleep(&self, secs: f64)

Blocks the current thread for the given fractional seconds.

Useful for frame-rate limiting in non-interactive contexts.

pub fn sleep_ms(&self, millis: u64)

Blocks the current thread for the given milliseconds.

pub fn sleep_ns(&self, nanos: u64)

Blocks the current thread for the given nanoseconds.