notan_app 0.6.0

Provides the core API for Notan
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use notan_utils::{Duration, Instant};
use std::collections::VecDeque;

#[derive(Debug, Clone)]
pub struct AppTimer {
    init_time: Instant,
    last_time: Option<Instant>,
    delta: Duration,
    delta_seconds: f32,
    time_since_init: f32,
    fps_cache: VecDeque<f32>,
    fps: f32,
}

impl Default for AppTimer {
    fn default() -> AppTimer {
        let fps = 60.0;

        // calculate the average fps for the last 60 frames
        let max_frames = 60;
        let mut fps_cache = VecDeque::with_capacity(max_frames);
        fps_cache.resize(max_frames, 1.0 / fps);

        AppTimer {
            init_time: Instant::now(),
            last_time: None,
            delta: Duration::from_secs(0),
            delta_seconds: 0.0,
            time_since_init: 0.0,
            fps_cache,
            fps,
        }
    }
}

impl AppTimer {
    #[inline]
    pub(crate) fn update(&mut self) {
        let now = Instant::now();

        if let Some(last_time) = self.last_time {
            self.delta = now - last_time;
            self.delta_seconds = self.delta.as_secs_f32();
        }

        self.last_time = Some(now);

        let time_since_init = now - self.init_time;
        self.time_since_init = time_since_init.as_secs_f32();

        self.fps_cache.pop_front();
        self.fps_cache.push_back(self.delta_seconds);
        self.fps = 1.0 / (self.fps_cache.iter().sum::<f32>() / self.fps_cache.len() as f32);
    }

    #[inline]
    pub fn fps(&self) -> f32 {
        self.fps
    }

    #[inline]
    pub fn delta(&self) -> Duration {
        self.delta
    }

    #[inline]
    pub fn delta_f32(&self) -> f32 {
        self.delta_seconds
    }

    #[inline]
    pub fn time_since_init(&self) -> f32 {
        self.time_since_init
    }

    #[inline]
    pub fn init_time(&self) -> Instant {
        self.init_time
    }

    #[inline]
    pub fn last_time(&self) -> Option<Instant> {
        self.last_time
    }
}