tge 0.0.4

A lightweight cross-platform 2D game framework written in pure Rust and based on OpenGL 3.3+.
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
86
87

use crate::error::GameResult;
use std::time::{Instant, Duration};

pub struct Timer {
    frame_duration: Duration,
    last_frame_instant: Instant,
    delta_time: Duration,
}

impl Timer {
    pub(crate) fn new(timer_config: TimerConfig) -> GameResult<Self> {
        Ok(Self {
            frame_duration: timer_config.frame_duration,
            last_frame_instant: Instant::now(),
            delta_time: Duration::new(0, 0),
        })
    }

    pub(crate) fn reset_tick(&mut self) {
        self.last_frame_instant = Instant::now();
        self.delta_time = Duration::new(0, 0);
    }

    pub(crate) fn tick_and_check(&mut self) -> bool {
        let now_instant = Instant::now();
        let delta_time = now_instant.duration_since(self.last_frame_instant);
        if delta_time >= self.frame_duration {
            self.last_frame_instant = now_instant;
            self.delta_time = delta_time;
            true
        } else {
            false
        }
    }

    pub fn frame_duration(&self) -> Duration {
        self.frame_duration
    }

    pub fn set_frame_duration(&mut self, frame_duration: Duration) {
        self.frame_duration = frame_duration;
    }

    pub fn fps(&self) -> f32 {
        1.0 / self.frame_duration.as_secs_f32()
    }

    pub fn set_fps(&mut self, fps: f32) {
        self.frame_duration = Duration::from_secs_f32(1.0 / fps);
    }

    pub fn real_time_fps(&self) -> f32 {
        let delta_time_secs_f32 = self.delta_time.as_secs_f32();
        if delta_time_secs_f32 > 0.0 {
            1.0 / delta_time_secs_f32
        } else {
            0.0
        }
    }

    pub fn delta_time(&self) -> Duration {
        self.delta_time
    }
}

#[derive(Debug, Clone)]
pub struct TimerConfig {
    frame_duration: Duration,
}

impl TimerConfig {
    pub fn new() -> Self {
        Self {
            frame_duration: Duration::from_secs_f32(1.0 / 60.0),
        }
    }

    pub fn frame_duration(mut self, frame_duration: Duration) -> Self {
        self.frame_duration = frame_duration;
        self
    }

    pub fn fps(mut self, fps: f32) -> Self {
        self.frame_duration = Duration::from_secs_f32(1.0 / fps);
        self
    }
}