scion 0.6.0

Game making library on top of wgpu, winit, legion
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! Everything that is relatives to the core.resources.inputs.

use crate::core::resources::inputs::{
    keyboard::Keyboard,
    mouse::{Mouse, MouseEvent},
    types::{Input, InputState, KeyCode, KeyboardEvent, Shortcut},
};

/// A resource updated by `Scion` to keep track of the core.resources.inputs
/// Can be used in any system.
#[derive(Default)]
pub struct InputsController {
    mouse: Mouse,
    keyboard: Keyboard,
}

impl InputsController {
    /// Whether or not `key` is currently pressed
    pub fn key_pressed(&self, key: &KeyCode) -> bool {
        self.keyboard.pressed_keys.contains(key)
    }

    /// convenient function to run `action` if `key` is pressed during the current frame
    pub fn on_key_pressed<Body>(&self, key: KeyCode, action: Body)
    where
        Body: FnMut(),
    {
        self.keyboard.on_key_pressed(key, action);
    }

    /// convenient function to run `action` if `key` is released during the current frame
    pub fn on_key_released<Body>(&self, key: KeyCode, action: Body)
    where
        Body: FnMut(),
    {
        self.keyboard.on_key_released(key, action);
    }

    /// Execute the action `action` if the left mouse button is clicked, actions params are mouse position x;y
    pub fn on_left_click_pressed<Body>(&self, action: Body)
    where
        Body: FnMut(f64, f64),
    {
        self.mouse.on_left_click_pressed(action);
    }

    /// Execute the action `action` if the right mouse button is clicked, actions params are mouse position x;y
    pub fn on_right_click_pressed<Body>(&self, action: Body)
    where
        Body: FnMut(f64, f64),
    {
        self.mouse.on_right_click_pressed(action);
    }

    /// Execute the action `action` if the middle mouse button is clicked, actions params are mouse position x;y
    pub fn on_middle_click_pressed<Body>(&self, action: Body)
    where
        Body: FnMut(f64, f64),
    {
        self.mouse.on_middle_click_pressed(action);
    }

    /// Execute the action `action` if the left mouse button is released, actions params are mouse position x;y
    pub fn on_left_click_released<Body>(&self, action: Body)
    where
        Body: FnMut(f64, f64),
    {
        self.mouse.on_left_click_released(action);
    }

    /// Execute the action `action` if the right mouse button is released, actions params are mouse position x;y
    pub fn on_right_click_released<Body>(&self, action: Body)
    where
        Body: FnMut(f64, f64),
    {
        self.mouse.on_right_click_released(action);
    }

    /// Execute the action `action` if the right mouse button is released, actions params are mouse position x;y
    pub fn on_middle_click_released<Body>(&self, action: Body)
    where
        Body: FnMut(f64, f64),
    {
        self.mouse.on_middle_click_released(action);
    }

    /// Retrieve all the inputs pressed or clicked during last frame
    pub fn all_pressed_events(&self) -> Vec<Input> {
        self.all_events_for_state(InputState::Pressed)
    }

    /// Retrieve all the inputs released or clicked during last frame
    pub fn all_released_events(&self) -> Vec<Input> {
        self.all_events_for_state(InputState::Released)
    }

    /// Retrieve all the inputs that are currently hold pressed or clicked
    pub fn all_pressed(&self) -> Vec<Input> {
        let mut pressed = self.keyboard.all_pressed();
        let mut mouse_pressed = self.mouse.all_pressed();
        pressed.append(&mut mouse_pressed);
        pressed
    }

    /// Retrieve the mouse x and y position
    pub fn mouse_xy(&self) -> (f64, f64) {
        self.mouse.xy()
    }

    /// Whether or not `shortcut` is currently pressed
    pub fn shortcut_pressed(&self, shortcut: &Shortcut) -> bool {
        shortcut.iter().all(|input| self.input_pressed(input))
    }

    /// Whether or not `shortcut` has just been pressed
    pub fn shortcut_pressed_event(&self, shortcut: &Shortcut) -> bool {
        shortcut.iter().all(|input| self.input_pressed(input))
            && shortcut.iter().any(|input| self.all_pressed_events().contains(input))
    }

    /// Whether or not `shortcut` has just been released
    pub fn shortcut_released_event(&self, shortcut: &Shortcut) -> bool {
        shortcut.iter().any(|input| self.all_released_events().contains(input))
            && shortcut.iter().all(|input| {
                self.input_pressed(input) || self.all_released_events().contains(input)
            })
    }

    fn all_events_for_state(&self, input_state: InputState) -> Vec<Input> {
        let mut inputs = self.keyboard.all_keys_at_state(input_state);
        let mut mouse_inputs = self.mouse.all_click_at_state(input_state);
        inputs.append(&mut mouse_inputs);
        inputs
    }

    fn input_pressed(&self, input: &Input) -> bool {
        match input {
            Input::Key(keycode) => self.key_pressed(keycode),
            Input::Mouse(mouse_button) => self.mouse.button_pressed(mouse_button),
        }
    }

    pub(crate) fn reset_inputs(&mut self) {
        self.mouse.clear_events();
        self.keyboard.clear_events();
    }

    pub(crate) fn set_mouse_position(&mut self, x: f64, y: f64) {
        self.mouse.set_position(x, y);
    }

    pub(crate) fn add_click_event(&mut self, event: MouseEvent) {
        self.mouse.add_click_event(event);
    }

    pub(crate) fn add_keyboard_event(&mut self, event: KeyboardEvent) {
        self.keyboard.add_keyboard_event(event);
    }
}