bevy_ineffable 0.5.0

A simple-to-use input manager for bevy that empowers players and makes accessibility easy.
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

use bevy::prelude::{GamepadAxis, GamepadButton, GamepadButtonType, Reflect};

use crate::bindings::AnalogInput;
use crate::processed::updating::InputSources;

#[derive(Debug, Reflect, Clone)]
pub(crate) struct StatefulAnalogInput {
    analog_input: AnalogInput,
    pub(crate) value_current: f32,
    pub(crate) value_previous: f32,
}

impl StatefulAnalogInput {
    pub fn new(input: &AnalogInput) -> Self {
        Self {
            analog_input: input.clone(),
            value_current: 0.,
            value_previous: 0.,
        }
    }

    pub(crate) fn just_activated(&self) -> bool {
        self.value_current.abs() > f32::EPSILON && self.value_previous.abs() < f32::EPSILON
    }

    pub(crate) fn update(&mut self, sources: &mut InputSources<'_>) {
        self.value_previous = self.value_current;

        // If the post-acceptance-delay is active, then do nothing. We should ignore all user input.
        if sources.settings.input_blocked_by_pad() {
            return;
        }
        self.value_current = Self::calc_value(&self.analog_input, sources);
    }
    pub(crate) fn calc_value(input: &AnalogInput, sources: &InputSources<'_>) -> f32 {
        match input {
            AnalogInput::ScrollWheelX => sources.from_events.mouse_scroll.x,
            AnalogInput::ScrollWheelY => sources.from_events.mouse_scroll.y,
            AnalogInput::MouseMotionX => sources.from_events.mouse_motion.x,
            AnalogInput::MouseMotionY => sources.from_events.mouse_motion.y,
            AnalogInput::GamePad(axis_type) => {
                // For now, we don't support local multiplayer. (Will change in the future)
                // We'll check if the button is active on *any* connected gamepad.
                sources
                    .gamepads
                    .iter()
                    .filter_map(|gamepad| {
                        sources
                            .axis_gamepad_axis
                            .get(GamepadAxis::new(gamepad, *axis_type))
                    })
                    .next()
                    .unwrap_or_default()
            }
            AnalogInput::GamePadLeftTrigger2 => {
                Self::gamepad_value(GamepadButtonType::LeftTrigger2, sources)
            }
            AnalogInput::GamePadRightTrigger2 => {
                Self::gamepad_value(GamepadButtonType::RightTrigger2, sources)
            }
        }
    }

    fn gamepad_value(btn: GamepadButtonType, sources: &InputSources<'_>) -> f32 {
        // For now, we don't support local multiplayer. (Will change in the future)
        // We'll check if the button is active on *any* connected gamepad.
        sources
            .gamepads
            .iter()
            .filter_map(|gamepad| {
                sources
                    .axis_gamepad_btn
                    .get(GamepadButton::new(gamepad, btn))
            })
            .next()
            .unwrap_or_default()
    }
}