padstate 0.2.5

Tiny structs that hold a game controller's state
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

use crate::{Button, AnyButton, DPad};

/// A simple virtual Game controller with digital buttons and a few analogue axis.
#[derive(Default, Debug, PartialEq, Clone, Copy)]
pub struct APad {
    pub left_stick_x: i16,
    pub left_stick_y: i16,
    pub buttons: DPad,
}

impl APad {
    pub fn new() -> Self {
        Self::default()
    }

    /// Must be called once per frame, prior to setting any value for the current state.
    #[inline(always)]
    pub fn copy_current_to_previous_state(&mut self) {
        self.buttons.copy_current_to_previous_state();
    }

    /// Whether the given button is currentl down.
    #[inline(always)]
    pub fn is_down(&self, button: Button) -> bool {
        self.buttons.is_down(button)
    }

    /// Whether the given button is currentl up.
    #[inline(always)]
    pub fn is_up(&self, button: Button) -> bool {
        self.buttons.is_up(button)
    }

    /// Whether the given button has just been pressed this frame. Requires
    /// [copy_current_to_previous_state] to have been called at the beginning of the frame
    #[inline(always)]
    pub fn is_just_pressed(&self, button: Button) -> bool {
        self.buttons.is_just_pressed(button)
    }

    /// Whether the given button has just been released this frame. Requires
    /// [copy_current_to_previous_state] to have been called at the beginning of the frame
    #[inline(always)]
    pub fn is_just_released(&self, button: Button) -> bool {
        self.buttons.is_just_released(button)
    }

    /// Whether any button in the group is currently down.
    #[inline(always)]
    pub fn is_any_down(&self, button_group: AnyButton) -> bool {
        self.buttons.is_any_down(button_group)
    }

    /// Whether any button in the group was just pressed this frame.
    #[inline(always)]
    pub fn is_any_just_pressed(&self, button_group: AnyButton) -> bool {
        self.buttons.is_any_just_pressed(button_group)
    }

    /// Whether any button in the group was just released this frame.
    #[inline(always)]
    pub fn is_any_just_released(&self, button_group: AnyButton) -> bool {
        self.buttons.is_any_just_released(button_group)
    }

    /// A single u16 where each bit represents a button pressed or not.
    #[inline(always)]
    pub fn buttons(&self) -> u16 {
        self.buttons.state
    }

    /// The X state of the left stick in the -1.0 to 1.0 range
    #[inline(always)]
    pub fn left_stick_x(&self) -> f32 {
        (self.left_stick_x as f32 / i16::MAX as f32).clamp(-1.0, 1.0)
    }

    /// The Y state of the left stick in the -1.0 to 1.0 range
    #[inline(always)]
    pub fn left_stick_y(&self) -> f32 {
        (self.left_stick_y as f32 / i16::MAX as f32).clamp(-1.0, 1.0)
    }

    /// Sets the bit for a particular button.
    #[inline(always)]
    pub fn set_button(&mut self, button: Button, value: bool) {
        self.buttons.set_state(button, value);
    }

    /// Converts from f32 to i16, clamps anything outside -1.0 to 1.0 range.
    #[inline(always)]
    pub fn set_left_stick_x(&mut self, x: f32) {
        self.left_stick_x = (x.clamp(-1.0, 1.0) * i16::MAX as f32) as i16;
    }

    /// Converts from f32 to i16, clamps anything outside -1.0 to 1.0 range.
    #[inline(always)]
    pub fn set_left_stick_y(&mut self, y: f32) {
        self.left_stick_y = (y.clamp(-1.0, 1.0) * i16::MAX as f32) as i16;
    }
}