oml-game 0.40.2-alpha

Game foundation extracted from Fiiish-RS to remove boilerplate for future procjects.
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
107
108
109
110
111
112
113
114
115
116
117
118
119

use crate::math::Vector2;

#[derive(Debug)]
#[repr(u8)]
pub enum ModifierKey {
	Shift,
	Ctrl,
	Alt,
}
#[derive(Debug, Copy, Clone)]
pub struct WindowUpdateContext {
	pub time_step:              f64,
	pub is_escape_pressed:      bool,
	pub is_space_pressed:       bool,
	pub mouse_pos:              Vector2,
	pub mouse_wheel_line_delta: Vector2,
	pub mouse_buttons:          [bool; 3], // left middle right
	pub is_key_pressed:         [bool; 256],
	is_modifier_pressed:        [bool; 256],
	pub window_size:            Vector2,
	pub window_pos:             Vector2,
	pub window_changed:         bool,

	mouse_buttons_internal: [bool; 3], // left middle right
	previous_mouse_buttons: [bool; 3],
	previous_keys_pressed:  [bool; 256],

	pub is_function_key_pressed:    [bool; 16],
	previous_function_keys_pressed: [bool; 16],
}

impl WindowUpdateContext {
	pub fn new() -> Self {
		Self {
			time_step:               0.0,
			is_escape_pressed:       false,
			is_space_pressed:        false,
			mouse_pos:               Vector2::zero(),
			mouse_wheel_line_delta:  Vector2::zero(),
			mouse_buttons:           [false, false, false],
			mouse_buttons_internal:  [false, false, false],
			is_key_pressed:          [false; 256],
			is_function_key_pressed: [false; 16],
			is_modifier_pressed:     [false; 256],
			window_size:             Vector2::zero(),
			window_pos:              Vector2::zero(),
			window_changed:          false,

			previous_mouse_buttons:         [false, false, false],
			previous_keys_pressed:          [false; 256],
			previous_function_keys_pressed: [false; 16],
		}
	}

	pub fn update(&mut self) {
		//		dbg!(&self);
		self.previous_mouse_buttons = self.mouse_buttons_internal;
		self.mouse_buttons = self.mouse_buttons_internal;
		self.previous_keys_pressed = self.is_key_pressed;
		self.previous_function_keys_pressed = self.is_function_key_pressed;
		//		for i in 0..self.is_key_pressed.len() {
		//			self.previous_keys_pressed[ i ] = self.is_key_pressed[ i ];
		//		}
	}

	pub fn fake_mouse_button_press(&mut self, button_index: usize) {
		self.mouse_buttons[button_index] = true;
		self.mouse_buttons_internal[button_index] = true;
		self.previous_mouse_buttons[button_index] = false;
	}

	pub fn was_mouse_button_pressed(&self, button_index: usize) -> bool {
		self.mouse_buttons[button_index] && !self.previous_mouse_buttons[button_index]
	}
	pub fn was_mouse_button_released(&self, button_index: usize) -> bool {
		!self.mouse_buttons[button_index] && self.previous_mouse_buttons[button_index]
	}

	pub fn consume_mouse_button_pressed(&mut self, button_index: usize) {
		self.mouse_buttons[button_index] = false;
	}
	pub(crate) fn set_mouse_button(&mut self, button_index: usize, down: bool) {
		self.mouse_buttons_internal[button_index] = down;
		self.mouse_buttons[button_index] = down;
	}

	pub fn was_key_pressed(&self, key: u8) -> bool {
		self.is_key_pressed[key as usize] && !self.previous_keys_pressed[key as usize]
	}

	pub fn is_key_pressed(&self, key: u8) -> bool {
		self.is_key_pressed[key as usize]
	}

	pub fn is_space_pressed(&self) -> bool {
		self.is_space_pressed
	}

	pub fn set_modifier_pressed(&mut self, modifier: ModifierKey, pressed: bool) {
		self.is_modifier_pressed[modifier as usize] = pressed;
	}

	pub fn is_modifier_pressed(&self, modifier: ModifierKey) -> bool {
		self.is_modifier_pressed[modifier as usize]
	}

	pub fn was_function_key_pressed(&self, key: u8) -> bool {
		self.is_function_key_pressed[key as usize]
			&& !self.previous_function_keys_pressed[key as usize]
	}

	pub fn is_function_key_pressed(&self, key: u8) -> bool {
		self.is_function_key_pressed[key as usize]
	}

	pub fn time_step(&self) -> f64 {
		self.time_step
	}
}