chaos-framework 0.1.2

Game framework for creating games!
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use std::collections::{HashMap, HashSet};

use glfw::Key;

use glam::Vec2;

pub struct EventHandler {
    pub keys_pressed: HashMap<Key, usize>,
    pub keys_pressed_last_frame: HashSet<Key>,

    pub keys_released: HashMap<Key, usize>,
    pub keys_released_last_frame: HashSet<Key>,

    pub mouse_pos: Vec2,
    pub scroll: Vec2,

    pub width: f32,
    pub height: f32,
    
    pub lmb: bool,
    pub rmb: bool,
}
impl EventHandler {
    pub fn new() -> Self {
        Self { 
            keys_pressed: HashMap::new(),
            keys_pressed_last_frame: HashSet::new(),

            keys_released: HashMap::new(),
            keys_released_last_frame: HashSet::new(),
            
            mouse_pos: Vec2::ONE,

            width: 1.0,
            height: 1.0,

            scroll: Vec2::ZERO,

            lmb: false,
            rmb: false,
        }
    }

    pub fn on_key_press(&mut self, key: Key) {
        self.keys_released.remove(&key);

        let key_handle = self.keys_pressed.len();
        self.keys_pressed.insert(key, key_handle);
    }

    pub fn on_key_release(&mut self, key: Key) {
        self.keys_pressed.remove(&key);

        let key_handle = self.keys_released.len();
        self.keys_released.insert(key, key_handle);
    }

    pub fn on_mouse_move(&mut self, x: f64, y: f64) {
        self.mouse_pos.x =  x as f32 - self.width / 2.0;
        self.mouse_pos.y = -y as f32 + self.height / 2.0;
    }

    pub fn on_lmb_press(&mut self) {
        self.lmb = true;
    } 
    pub fn on_lmb_release(&mut self) {
        self.lmb = false;
    } 

    pub fn on_rmb_press(&mut self) {
        self.rmb = true;
    } 
    pub fn on_rmb_release(&mut self) {
        self.rmb = false;
    } 

    pub fn on_scroll_change(&mut self, change: Vec2){
        self.scroll = change;
    }

    pub fn on_window_resize(&mut self, w: i32, h: i32) {
        self.width = w as f32;
        self.height = h as f32;
    }

    pub fn update(&mut self) {
        self.keys_pressed_last_frame.clear();
        self.keys_released_last_frame.clear();

        self.scroll = Vec2::ZERO;
        for &key in self.keys_pressed.keys() {
            self.keys_pressed_last_frame.insert(key);
        }

        for &key in self.keys_released.keys() {
            self.keys_released_last_frame.insert(key);
        }
    }

    pub fn key_just_pressed(&self, key: Key) -> bool {
        self.keys_pressed.contains_key(&key) && !self.keys_pressed_last_frame.contains(&key)
    }
    pub fn key_just_released(&self, key: Key) -> bool {
        self.keys_released.contains_key(&key) && !self.keys_released_last_frame.contains(&key)
    }
}