elikar 0.1.9

A rust asynchronous ECS game engine
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

use std::time::{Duration, Instant};

pub struct Time {
    // Count how many frames until now
    frame_counter : usize,
    // the instant when leave a frame
    frame_timer : Instant,
    // Time of last frame
    last_frame_time : Duration,
    // One second timer
    one_sec_timer : Instant,
    // Record the frame count in one second start
    one_sec_frame : usize,
    // Last one second frames 
    last_one_sec_frames : usize,
}

impl Time {
    pub(in crate) fn new() -> Time {
        Time {
            frame_counter : 0,
            frame_timer : Instant::now(),
            last_frame_time : Duration::from_secs(1),
            one_sec_timer : Instant::now(),
            one_sec_frame : 0,
            last_one_sec_frames : 0
        }
    }

    pub(in crate) fn tick(&mut self) {
        self.frame_counter += 1;
        self.last_frame_time = self.frame_timer.elapsed();
        self.frame_timer = Instant::now();
        if self.one_sec_timer.elapsed() > Duration::from_secs(1) {
            self.one_sec_timer = Instant::now();
            self.last_one_sec_frames = self.frame_counter - self.one_sec_frame;
            self.one_sec_frame = self.frame_counter;
        }
    }

    // Get the time from frame start to now
    pub fn delta(&self) -> Duration {
        self.frame_timer.elapsed()
    }

    pub fn actual_fps(&self) -> usize {
        self.last_one_sec_frames
    }

    pub fn fps(&self) -> f64 {
        1.0 / self.last_frame_time.as_secs_f64()
    }

    pub fn frame_counter(&self) -> usize {
        self.frame_counter
    }

    pub fn timer(&self) -> Timer {
        todo!()
    }
}

pub struct Timer {

}