reaction 0.2.0

Universal low-latency input handling for game engines
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

use crate::mapping::binding::InputBinding;
use crate::state::advanced::AdvancedInputState;
use crate::trigger::trigger::InputTrigger;
use crate::types::GamepadId;

pub trait Triggerable {
    fn evaluate(
        &self,
        trigger: &InputTrigger,
        input: &AdvancedInputState,
        gamepad_id: Option<GamepadId>,
    ) -> bool;
}

impl Triggerable for InputBinding {
    fn evaluate(
        &self,
        trigger: &InputTrigger,
        input: &AdvancedInputState,
        gamepad_id: Option<GamepadId>,
    ) -> bool {
        match trigger {
            InputTrigger::Down => is_down(self, input, gamepad_id),
            InputTrigger::Pressed => is_just_pressed(self, input, gamepad_id),
            InputTrigger::Released => is_just_released(self, input, gamepad_id),
            InputTrigger::Held { min_duration } => is_held(self, input, gamepad_id, *min_duration),
            InputTrigger::Chord(triggers) => {
                // For a chord on a single binding, it doesn't make much sense unless the binding itself is a "Meta" binding
                // effectively, but simpler: verify this binding meets ALL triggers.
                // A more common chord is "Key A + Key B".
                // Our current architecture binds Actions to Bindings.
                // So if an Action Binding is "Ctrl + C", that's a chord of two inputs.
                // But here InputTrigger is applied to a single InputBinding?
                // Let's assume InputTrigger modifies HOW the binding is activated.

                triggers.iter().all(|t| self.evaluate(t, input, gamepad_id))
            }
        }
    }
}

fn is_down(
    binding: &InputBinding,
    input: &AdvancedInputState,
    gamepad_id: Option<GamepadId>,
) -> bool {
    match binding {
        InputBinding::Key(k) => input.is_key_down(*k),
        InputBinding::MouseButton(b) => input.is_mouse_button_down(*b),
        InputBinding::GamepadButton(b) => gamepad_id
            .and_then(|id| input.gamepads.get(id))
            .map(|gp| gp.is_button_down(*b))
            .unwrap_or(false),
        InputBinding::GamepadAxis(a) => gamepad_id
            .and_then(|id| input.gamepads.get(id))
            .map(|gp| gp.get_axis(*a).abs() > 0.1)
            .unwrap_or(false),
    }
}

fn is_just_pressed(
    binding: &InputBinding,
    input: &AdvancedInputState,
    gamepad_id: Option<GamepadId>,
) -> bool {
    match binding {
        InputBinding::Key(k) => input.was_key_just_pressed(*k),
        InputBinding::MouseButton(b) => input.mouse.was_button_just_pressed(*b),
        InputBinding::GamepadButton(b) => gamepad_id
            .and_then(|id| input.gamepads.get(id))
            .map(|gp| {
                gp.buttons
                    .get(b)
                    .map(|s| s.just_pressed_frame.is_some())
                    .unwrap_or(false)
            })
            .unwrap_or(false),
        _ => false, // Axis just pressed is simpler to model as threshold crossing, skipping for now
    }
}

fn is_just_released(
    binding: &InputBinding,
    input: &AdvancedInputState,
    gamepad_id: Option<GamepadId>,
) -> bool {
    match binding {
        InputBinding::Key(k) => input.keyboard.was_just_released(*k),
        InputBinding::MouseButton(b) => input.mouse.was_button_just_released(*b),
        InputBinding::GamepadButton(b) => gamepad_id
            .and_then(|id| input.gamepads.get(id))
            .map(|gp| {
                gp.buttons
                    .get(b)
                    .map(|s| s.just_released_frame.is_some())
                    .unwrap_or(false)
            })
            .unwrap_or(false),
        _ => false,
    }
}

fn is_held(
    binding: &InputBinding,
    input: &AdvancedInputState,
    _gamepad_id: Option<GamepadId>,
    min_duration_ms: f32,
) -> bool {
    let (is_down, duration) = match binding {
        InputBinding::Key(k) => (
            input.keyboard.is_down(*k),
            input.keyboard.get_held_duration(*k),
        ),
        InputBinding::MouseButton(b) => input
            .mouse
            .buttons
            .get(b)
            .map(|s| (s.is_down, s.held_duration_ms))
            .unwrap_or((false, 0.0)),
        _ => (false, 0.0),
    };
    is_down && duration >= min_duration_ms
}