docs: Documentation and clean up of bevy_input

crates/bevy_gilrs/src/converter.rs

@@ -1,7 +1,7 @@
 use bevy_input::gamepad::{Gamepad, GamepadAxisType, GamepadButtonType};
 
 pub fn convert_gamepad_id(gamepad_id: gilrs::GamepadId) -> Gamepad {
-    Gamepad(gamepad_id.into())
+    Gamepad::new(gamepad_id.into())
 }
 
 pub fn convert_button(button: gilrs::Button) -> Option<GamepadButtonType> {

crates/bevy_gilrs/src/gilrs_system.rs

@@ -6,7 +6,7 @@ use gilrs::{EventType, Gilrs};
 
 pub fn gilrs_event_startup_system(gilrs: NonSend<Gilrs>, mut events: EventWriter<GamepadEventRaw>) {
     for (id, _) in gilrs.gamepads() {
-        events.send(GamepadEventRaw(
+        events.send(GamepadEventRaw::new(
             convert_gamepad_id(id),
             GamepadEventType::Connected,
         ));
@@ -17,28 +17,28 @@ pub fn gilrs_event_system(mut gilrs: NonSendMut<Gilrs>, mut events: EventWriter<
     while let Some(gilrs_event) = gilrs.next_event() {
         match gilrs_event.event {
             EventType::Connected => {
-                events.send(GamepadEventRaw(
+                events.send(GamepadEventRaw::new(
                     convert_gamepad_id(gilrs_event.id),
                     GamepadEventType::Connected,
                 ));
             }
             EventType::Disconnected => {
-                events.send(GamepadEventRaw(
+                events.send(GamepadEventRaw::new(
                     convert_gamepad_id(gilrs_event.id),
                     GamepadEventType::Disconnected,
                 ));
             }
             EventType::ButtonChanged(gilrs_button, value, _) => {
                 if let Some(button_type) = convert_button(gilrs_button) {
-                    events.send(GamepadEventRaw(
+                    events.send(GamepadEventRaw::new(
                         convert_gamepad_id(gilrs_event.id),
                         GamepadEventType::ButtonChanged(button_type, value),
                     ));
                 }
             }
             EventType::AxisChanged(gilrs_axis, value, _) => {
                 if let Some(axis_type) = convert_axis(gilrs_axis) {
-                    events.send(GamepadEventRaw(
+                    events.send(GamepadEventRaw::new(
                         convert_gamepad_id(gilrs_event.id),
                         GamepadEventType::AxisChanged(axis_type, value),
                     ));

crates/bevy_input/Cargo.toml

@@ -21,3 +21,5 @@ bevy_utils = { path = "../bevy_utils", version = "0.6.0" }
 
 # other
 serde = { version = "1", features = ["derive"], optional = true }
+strum = { version = "0.23" }
+strum_macros = { version = "0.23" }

crates/bevy_input/src/axis.rs

@@ -1,12 +1,12 @@
 use bevy_utils::HashMap;
 use std::hash::Hash;
 
-/// Stores the position data of input devices of type T
+/// Stores the position data of the input devices of type `T`.
 ///
-/// Values are stored as `f32` values, which range from `min` to `max`.
-/// The valid range is from -1.0 to 1.0, inclusive.
+/// Values are stored as `f32` values, which range from -1.0 to 1.0, inclusive.
 #[derive(Debug)]
 pub struct Axis<T> {
+    /// The position data of the input devices.
     axis_data: HashMap<T, f32>,
 }
 
@@ -25,17 +25,13 @@ impl<T> Axis<T>
 where
     T: Copy + Eq + Hash,
 {
-    pub const MIN: f32 = -1.0;
-    pub const MAX: f32 = 1.0;
-
-    /// Inserts a position data for an input device,
-    /// restricting the position data to an interval `min..=max`.
-    ///
-    /// If the input device wasn't present before, [None] is returned.
+    /// Inserts a position data for an input device, restricting the position data to an interval `min..=max`.
     ///
-    /// If the input device was present, the position data is updated, and the old value is returned.
+    /// If the `input_device`:
+    /// - was present before, the position data is updated, and the old value is returned.
+    /// - wasn't present before, [None] is returned.
     pub fn set(&mut self, input_device: T, position_data: f32) -> Option<f32> {
-        let new_position_data = position_data.clamp(Self::MIN, Self::MAX);
+        let new_position_data = position_data.clamp(-1.0, 1.0);
         self.axis_data.insert(input_device, new_position_data)
     }
 
@@ -44,8 +40,7 @@ where
         self.axis_data.get(&input_device).copied()
     }
 
-    /// Removes the position data of the input device,
-    /// returning the position data if the input device was previously set.
+    /// Removes the position data of the input device, returning the position data if the input device was previously set.
     pub fn remove(&mut self, input_device: T) -> Option<f32> {
         self.axis_data.remove(&input_device)
     }
@@ -59,7 +54,7 @@ mod tests {
     };
 
     #[test]
-    fn test_axis_set() {
+    fn test_set() {
         let cases = [
             (-1.5, Some(-1.0)),
             (-1.1, Some(-1.0)),
@@ -75,7 +70,8 @@ mod tests {
         ];
 
         for (value, expected) in cases {
-            let gamepad_button = GamepadButton(Gamepad(1), GamepadButtonType::RightTrigger);
+            let gamepad_button =
+                GamepadButton::new(Gamepad::new(1), GamepadButtonType::RightTrigger);
             let mut axis = Axis::<GamepadButton>::default();
 
             axis.set(gamepad_button, value);
@@ -86,18 +82,30 @@ mod tests {
     }
 
     #[test]
-    fn test_axis_remove() {
+    fn test_get() {
         let cases = [-1.0, -0.9, -0.1, 0.0, 0.1, 0.9, 1.0];
 
         for value in cases {
-            let gamepad_button = GamepadButton(Gamepad(1), GamepadButtonType::RightTrigger);
             let mut axis = Axis::<GamepadButton>::default();
+            let button = GamepadButton::new(Gamepad::new(1), GamepadButtonType::RightTrigger);
+            axis.axis_data.insert(button, value);
+            assert_eq!(axis.get(button).unwrap(), value);
+        }
+    }
 
-            axis.set(gamepad_button, value);
-            assert!(axis.get(gamepad_button).is_some());
+    #[test]
+    fn test_remove() {
+        let cases = [-1.0, -0.9, -0.1, 0.0, 0.1, 0.9, 1.0];
 
-            axis.remove(gamepad_button);
-            let actual = axis.get(gamepad_button);
+        for value in cases {
+            let button = GamepadButton::new(Gamepad::new(1), GamepadButtonType::RightTrigger);
+            let mut axis = Axis::<GamepadButton>::default();
+
+            axis.set(button, value);
+            assert!(axis.get(button).is_some());
+
+            axis.remove(button);
+            let actual = axis.get(button);
             let expected = None;
 
             assert_eq!(expected, actual);