Struct Timer

pub struct Timer { /* private fields */ }

Timer instance

Implementations

impl Timer

pub fn log_interval(self, log_interval: Duration) -> Self

Sets the logging interval of this timer to log_interval.

Arguments

• log_interval - logging interval as used by Self::log

Returns

Self the (modified) timer

Example

use std::time::Duration;
use fps_timer::Timer;
let mut timer = Timer::default()
    .log_interval(Duration::from_millis(100))
    .fps(240.);

Examples found in repository

examples/fps/main.rs (line 13)

fn main() {
    let args: Vec<String> = env::args().collect();
    let fps = args
        .get(1)
        .and_then(|arg| arg.parse().ok())
        .unwrap_or(420.69);

    let mut timer = Timer::default()
        .log_interval(Duration::from_millis(100))
        .high_precision(true)
        .fps(fps);

    loop {
        let _dt = timer.frame();
        if let Some(log) = timer.log() {
            print!(
                "{:>15.6}ms ({:>10.3}fps)      \r",
                log.delta_time_avg_ms(),
                log.fps_average()
            );
            let _ = std::io::stdout().flush();
        }
    }
}

pub fn frame_time(self, delta: Duration) -> Self

Sets the target frametime to the specified amount.

Arguments

• delta - target frametime

Returns

Self the (modified) timer

Example

use std::time::Duration;
use fps_timer::Timer;
let mut timer = Timer::default()
    .frame_time(Duration::from_secs_f64(1. / 60.));

pub fn fps(self, fps: f64) -> Self

Sets the framerate target to the specified amount.

Arguments

• fps - target framerate

Returns

Self the (modified) timer

Example

use fps_timer::Timer;
let mut timer = Timer::default()
    .fps(60.);

Examples found in repository

examples/fps/main.rs (line 15)

fn main() {
    let args: Vec<String> = env::args().collect();
    let fps = args
        .get(1)
        .and_then(|arg| arg.parse().ok())
        .unwrap_or(420.69);

    let mut timer = Timer::default()
        .log_interval(Duration::from_millis(100))
        .high_precision(true)
        .fps(fps);

    loop {
        let _dt = timer.frame();
        if let Some(log) = timer.log() {
            print!(
                "{:>15.6}ms ({:>10.3}fps)      \r",
                log.delta_time_avg_ms(),
                log.fps_average()
            );
            let _ = std::io::stdout().flush();
        }
    }
}

pub fn high_precision(self, enabled: bool) -> Self

Enable or disable improved accuracy for this timer.

Enabling high precision makes the timer more precise at the cost of higher power consumption because part of the duration is awaited in a busy spinloop.

Defaults to true

Arguments

• enable - whether or not to enable higher precision

Returns

Self the (modified) timer

Example

use fps_timer::Timer;
let mut timer = Timer::default()
    .fps(60.);

Examples found in repository

examples/fps/main.rs (line 14)

fn main() {
    let args: Vec<String> = env::args().collect();
    let fps = args
        .get(1)
        .and_then(|arg| arg.parse().ok())
        .unwrap_or(420.69);

    let mut timer = Timer::default()
        .log_interval(Duration::from_millis(100))
        .high_precision(true)
        .fps(fps);

    loop {
        let _dt = timer.frame();
        if let Some(log) = timer.log() {
            print!(
                "{:>15.6}ms ({:>10.3}fps)      \r",
                log.delta_time_avg_ms(),
                log.fps_average()
            );
            let _ = std::io::stdout().flush();
        }
    }
}

pub fn frame(&mut self) -> Duration

Waits until the specified frametime target is reached and returns the Duration since the last call to Self::frame() of this Timer (= frametime).

Example

use std::time::Duration;
use fps_timer::Timer;

fn update(dt: Duration) {
    // game logic
}

fn main()  {
    let mut timer = Timer::default();
    loop {
        let delta_time = timer.frame();
        update(delta_time);
    }
}

Examples found in repository

examples/fps/main.rs (line 18)

fn main() {
    let args: Vec<String> = env::args().collect();
    let fps = args
        .get(1)
        .and_then(|arg| arg.parse().ok())
        .unwrap_or(420.69);

    let mut timer = Timer::default()
        .log_interval(Duration::from_millis(100))
        .high_precision(true)
        .fps(fps);

    loop {
        let _dt = timer.frame();
        if let Some(log) = timer.log() {
            print!(
                "{:>15.6}ms ({:>10.3}fps)      \r",
                log.delta_time_avg_ms(),
                log.fps_average()
            );
            let _ = std::io::stdout().flush();
        }
    }
}

pub fn log(&mut self) -> Option<Log>

returns Some<Log>, holding information about the previous logging interval, every time the interval specified by Timer::log_interval has passed and None otherwise

Examples found in repository

examples/fps/main.rs (line 19)

fn main() {
    let args: Vec<String> = env::args().collect();
    let fps = args
        .get(1)
        .and_then(|arg| arg.parse().ok())
        .unwrap_or(420.69);

    let mut timer = Timer::default()
        .log_interval(Duration::from_millis(100))
        .high_precision(true)
        .fps(fps);

    loop {
        let _dt = timer.frame();
        if let Some(log) = timer.log() {
            print!(
                "{:>15.6}ms ({:>10.3}fps)      \r",
                log.delta_time_avg_ms(),
                log.fps_average()
            );
            let _ = std::io::stdout().flush();
        }
    }
}

Trait Implementations

impl Default for Timer

fn default() -> Self

Returns the “default value” for a type.