shine-input 0.2.1

SHINE. Input handling for the shine engine.
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

use crate::ButtonId;
use crate::{ModifierFilterMask, ModifierId, ModifierMask};
use std::collections::HashMap;

/// State of a button
#[derive(Clone, Default, Debug)]
struct ButtonState {
    /// Reset button automatically in prepare pass (ex: used for mouse move to reset axis when mouse is not moved)
    autoreset: bool,

    /// Required modifier mask
    modifier_mask: ModifierFilterMask,

    /// Current value in the [-1,1] range
    value: f32,
}

/// Store the current input state
pub struct State {
    time: u128,                              // The last update time
    cursore_position: (f32, f32),            // Cursore poisition on the normalize [0,1]^2 screen
    modifier_mask: ModifierMask,             // Current modifiers
    autoreset_modifiers: ModifierMask,       // Autoreset modifiers
    buttons: HashMap<ButtonId, ButtonState>, // State of the buttons
}

impl State {
    pub fn new() -> State {
        State {
            time: 0,
            cursore_position: (0., 0.),
            modifier_mask: ModifierMask::default(),
            autoreset_modifiers: ModifierMask::default(),
            buttons: HashMap::new(),
        }
    }

    pub fn clear(&mut self) {
        self.buttons.clear();
        self.modifier_mask.clear();
        self.autoreset_modifiers.clear();
        self.time = 0;
        self.cursore_position = (0., 0.);
    }

    /// Copy the previous state
    pub fn prepare(&mut self, prev: &State, time: u128) {
        self.clear();

        self.time = time;

        self.modifier_mask = ModifierMask::from_masked_clear(&prev.modifier_mask, &prev.autoreset_modifiers);

        self.buttons.clear();
        for (k, j) in prev.buttons.iter() {
            if j.autoreset {
                continue;
            }

            self.buttons.insert(*k, j.clone());
        }
    }

    pub fn get_time(&self) -> u128 {
        self.time
    }

    pub fn set_modifier(&mut self, modifier_id: ModifierId, pressed: bool, autoreset: bool) {
        self.modifier_mask.set(modifier_id, pressed);
        self.autoreset_modifiers.set(modifier_id, autoreset);
    }

    pub fn is_modifier(&self, modifier_id: ModifierId) -> bool {
        self.modifier_mask.get(modifier_id)
    }

    pub fn remove_button(&mut self, button_id: ButtonId) {
        let _ = self.buttons.remove(&button_id);
    }

    pub fn set_button(&mut self, button_id: ButtonId, modifier_mask: ModifierFilterMask, value: f32, autoreset: bool) {
        // clamp input to [-1,1]
        let value = if value > 1. {
            1.
        } else if value < -1. {
            -1.
        } else {
            value
        };

        if value == 0. {
            self.remove_button(button_id);
        } else {
            let entry = self.buttons.entry(button_id);
            let mut state = entry.or_insert_with(ButtonState::default);
            state.value = value;
            state.modifier_mask = modifier_mask;
            state.autoreset = autoreset;
        }
    }

    pub fn get_button(&self, button_id: ButtonId) -> f32 {
        match self.buttons.get(&button_id) {
            None => 0.,
            Some(ref s) => {
                log::trace!("s: {:?}", s);
                if s.modifier_mask.check(&self.modifier_mask) {
                    s.value
                } else {
                    0.
                }
            }
        }
    }

    pub fn is_button(&self, button_id: ButtonId) -> bool {
        self.get_button(button_id) != 0.
    }
}

impl Default for State {
    fn default() -> Self {
        State::new()
    }
}