Implement gamepads as entities

crates/bevy_gilrs/src/converter.rs

@@ -1,7 +1,9 @@
-use bevy_input::gamepad::{Gamepad, GamepadAxisType, GamepadButtonType};
+use bevy_input::gamepad::{GamepadAxisType, GamepadButtonType, GamepadId};
 
-pub fn convert_gamepad_id(gamepad_id: gilrs::GamepadId) -> Gamepad {
-    Gamepad::new(gamepad_id.into())
+//  TODO: bevy_input directly depends on Gilrs::GamepadId's. This could cause conflicts with other plugins.
+//  Instead, bevy_input should provide a unique GamepadId and bevy_gilrs keep a mapping between them
+pub fn convert_gamepad_id(gamepad_id: gilrs::GamepadId) -> GamepadId {
+    GamepadId(gamepad_id.into())
 }
 
 pub fn convert_button(button: gilrs::Button) -> Option<GamepadButtonType> {

crates/bevy_gilrs/src/gilrs_system.rs

@@ -5,43 +5,37 @@ use crate::{
 use bevy_ecs::event::EventWriter;
 #[cfg(target_arch = "wasm32")]
 use bevy_ecs::system::NonSendMut;
-use bevy_ecs::system::{Res, ResMut};
+use bevy_ecs::system::ResMut;
 use bevy_input::gamepad::{
-    GamepadAxisChangedEvent, GamepadButtonChangedEvent, GamepadConnection, GamepadConnectionEvent,
-    GamepadSettings,
+    GamepadConnection, GamepadConnectionEvent, GamepadInfo, RawGamepadAxisChangedEvent,
+    RawGamepadButtonChangedEvent, RawGamepadEvent,
 };
-use bevy_input::gamepad::{GamepadEvent, GamepadInfo};
-use bevy_input::prelude::{GamepadAxis, GamepadButton};
-use bevy_input::Axis;
 use gilrs::{ev::filter::axis_dpad_to_button, EventType, Filter};
 
 pub fn gilrs_event_startup_system(
     #[cfg(target_arch = "wasm32")] mut gilrs: NonSendMut<Gilrs>,
     #[cfg(not(target_arch = "wasm32"))] mut gilrs: ResMut<Gilrs>,
-    mut events: EventWriter<GamepadEvent>,
+    mut events: EventWriter<GamepadConnectionEvent>,
 ) {
     for (id, gamepad) in gilrs.0.get().gamepads() {
         let info = GamepadInfo {
             name: gamepad.name().into(),
         };
 
-        events.send(
-            GamepadConnectionEvent {
-                gamepad: convert_gamepad_id(id),
-                connection: GamepadConnection::Connected(info),
-            }
-            .into(),
-        );
+        events.send(GamepadConnectionEvent {
+            gamepad: convert_gamepad_id(id),
+            connection: GamepadConnection::Connected(info),
+        });
     }
 }
 
 pub fn gilrs_event_system(
     #[cfg(target_arch = "wasm32")] mut gilrs: NonSendMut<Gilrs>,
     #[cfg(not(target_arch = "wasm32"))] mut gilrs: ResMut<Gilrs>,
-    mut events: EventWriter<GamepadEvent>,
-    mut gamepad_buttons: ResMut<Axis<GamepadButton>>,
-    gamepad_axis: Res<Axis<GamepadAxis>>,
-    gamepad_settings: Res<GamepadSettings>,
+    mut events: EventWriter<RawGamepadEvent>,
+    mut connection_events: EventWriter<GamepadConnectionEvent>,
+    mut button_events: EventWriter<RawGamepadButtonChangedEvent>,
+    mut axis_event: EventWriter<RawGamepadAxisChangedEvent>,
 ) {
     let gilrs = gilrs.0.get();
     while let Some(gilrs_event) = gilrs.next_event().filter_ev(&axis_dpad_to_button, gilrs) {
@@ -56,45 +50,41 @@ pub fn gilrs_event_system(
                 };
 
                 events.send(
-                    GamepadConnectionEvent::new(gamepad, GamepadConnection::Connected(info)).into(),
+                    GamepadConnectionEvent::new(
+                        gamepad,
+                        GamepadConnection::Connected(info.clone()),
+                    )
+                    .into(),
                 );
+                connection_events.send(GamepadConnectionEvent::new(
+                    gamepad,
+                    GamepadConnection::Connected(info),
+                ));
             }
             EventType::Disconnected => {
                 events.send(
                     GamepadConnectionEvent::new(gamepad, GamepadConnection::Disconnected).into(),
                 );
+                connection_events.send(GamepadConnectionEvent::new(
+                    gamepad,
+                    GamepadConnection::Disconnected,
+                ));
             }
             EventType::ButtonChanged(gilrs_button, raw_value, _) => {
-                if let Some(button_type) = convert_button(gilrs_button) {
-                    let button = GamepadButton::new(gamepad, button_type);
-                    let old_value = gamepad_buttons.get(button);
-                    let button_settings = gamepad_settings.get_button_axis_settings(button);
-
-                    // Only send events that pass the user-defined change threshold
-                    if let Some(filtered_value) = button_settings.filter(raw_value, old_value) {
-                        events.send(
-                            GamepadButtonChangedEvent::new(gamepad, button_type, filtered_value)
-                                .into(),
-                        );
-                        // Update the current value prematurely so that `old_value` is correct in
-                        // future iterations of the loop.
-                        gamepad_buttons.set(button, filtered_value);
-                    }
-                }
+                let Some(button) = convert_button(gilrs_button) else {
+                    continue;
+                };
+                events.send(RawGamepadButtonChangedEvent::new(gamepad, button, raw_value).into());
+                button_events.send(RawGamepadButtonChangedEvent::new(
+                    gamepad, button, raw_value,
+                ));
             }
             EventType::AxisChanged(gilrs_axis, raw_value, _) => {
-                if let Some(axis_type) = convert_axis(gilrs_axis) {
-                    let axis = GamepadAxis::new(gamepad, axis_type);
-                    let old_value = gamepad_axis.get(axis);
-                    let axis_settings = gamepad_settings.get_axis_settings(axis);
-
-                    // Only send events that pass the user-defined change threshold
-                    if let Some(filtered_value) = axis_settings.filter(raw_value, old_value) {
-                        events.send(
-                            GamepadAxisChangedEvent::new(gamepad, axis_type, filtered_value).into(),
-                        );
-                    }
-                }
+                let Some(axis) = convert_axis(gilrs_axis) else {
+                    continue;
+                };
+                events.send(RawGamepadAxisChangedEvent::new(gamepad, axis, raw_value).into());
+                axis_event.send(RawGamepadAxisChangedEvent::new(gamepad, axis, raw_value));
             }
             _ => (),
         };

crates/bevy_input/src/axis.rs

@@ -57,7 +57,7 @@ where
 
     /// Returns the unclamped position data of the provided `input_device`.
     ///
-    /// This value may be outside of the [`Axis::MIN`] and [`Axis::MAX`] range.
+    /// This value may be outside the [`Axis::MIN`] and [`Axis::MAX`] range.
     ///
     /// Use for things like camera zoom, where you want devices like mouse wheels to be able to
     /// exceed the normal range. If being able to move faster on one input device
@@ -70,18 +70,11 @@ where
     pub fn remove(&mut self, input_device: T) -> Option<f32> {
         self.axis_data.remove(&input_device)
     }
-    /// Returns an iterator of all the input devices that have position data
-    pub fn devices(&self) -> impl ExactSizeIterator<Item = &T> {
-        self.axis_data.keys()
-    }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        gamepad::{Gamepad, GamepadButton, GamepadButtonType},
-        Axis,
-    };
+    use crate::{gamepad::GamepadButtonType, Axis};
 
     #[test]
     fn test_axis_set() {
@@ -100,13 +93,11 @@ mod tests {
         ];
 
         for (value, expected) in cases {
-            let gamepad_button =
-                GamepadButton::new(Gamepad::new(1), GamepadButtonType::RightTrigger);
-            let mut axis = Axis::<GamepadButton>::default();
+            let mut axis = Axis::<GamepadButtonType>::default();
 
-            axis.set(gamepad_button, value);
+            axis.set(GamepadButtonType::RightTrigger, value);
 
-            let actual = axis.get(gamepad_button);
+            let actual = axis.get(GamepadButtonType::RightTrigger);
             assert_eq!(expected, actual);
         }
     }
@@ -116,48 +107,16 @@ mod tests {
         let cases = [-1.0, -0.9, -0.1, 0.0, 0.1, 0.9, 1.0];
 
         for value in cases {
-            let gamepad_button =
-                GamepadButton::new(Gamepad::new(1), GamepadButtonType::RightTrigger);
-            let mut axis = Axis::<GamepadButton>::default();
+            let mut axis = Axis::<GamepadButtonType>::default();
 
-            axis.set(gamepad_button, value);
-            assert!(axis.get(gamepad_button).is_some());
+            axis.set(GamepadButtonType::RightTrigger, value);
+            assert!(axis.get(GamepadButtonType::RightTrigger).is_some());
 
-            axis.remove(gamepad_button);
-            let actual = axis.get(gamepad_button);
+            axis.remove(GamepadButtonType::RightTrigger);
+            let actual = axis.get(GamepadButtonType::RightTrigger);
             let expected = None;
 
             assert_eq!(expected, actual);
         }
     }
-
-    #[test]
-    fn test_axis_devices() {
-        let mut axis = Axis::<GamepadButton>::default();
-        assert_eq!(axis.devices().count(), 0);
-
-        axis.set(
-            GamepadButton::new(Gamepad::new(1), GamepadButtonType::RightTrigger),
-            0.1,
-        );
-        assert_eq!(axis.devices().count(), 1);
-
-        axis.set(
-            GamepadButton::new(Gamepad::new(1), GamepadButtonType::LeftTrigger),
-            0.5,
-        );
-        assert_eq!(axis.devices().count(), 2);
-
-        axis.set(
-            GamepadButton::new(Gamepad::new(1), GamepadButtonType::RightTrigger),
-            -0.1,
-        );
-        assert_eq!(axis.devices().count(), 2);
-
-        axis.remove(GamepadButton::new(
-            Gamepad::new(1),
-            GamepadButtonType::RightTrigger,
-        ));
-        assert_eq!(axis.devices().count(), 1);
-    }
 }

crates/bevy_input/src/button_input.rs

@@ -73,17 +73,13 @@ use bevy_ecs::schedule::State;
 /// ```no_run
 /// # use bevy_app::{App, NoopPluginGroup as DefaultPlugins, Update};
 /// # use bevy_ecs::{prelude::{IntoSystemConfigs, Res, Resource, resource_changed}, schedule::Condition};
-/// # use bevy_input::{ButtonInput, prelude::{GamepadButton, KeyCode, MouseButton}};
+/// # use bevy_input::{ButtonInput, prelude::{KeyCode, MouseButton}};
 ///
 /// fn main() {
 ///     App::new()
 ///         .add_plugins(DefaultPlugins)
 ///         .add_systems(
 ///             Update,
-///             print_gamepad.run_if(resource_changed::<ButtonInput<GamepadButton>>),
-///         )
-///         .add_systems(
-///             Update,
 ///             print_mouse.run_if(resource_changed::<ButtonInput<MouseButton>>),
 ///         )
 ///         .add_systems(
@@ -93,10 +89,6 @@ use bevy_ecs::schedule::State;
 ///         .run();
 /// }
 ///
-/// fn print_gamepad(gamepad: Res<ButtonInput<GamepadButton>>) {
-///     println!("Gamepad: {:?}", gamepad.get_pressed().collect::<Vec<_>>());
-/// }
-///
 /// fn print_mouse(mouse: Res<ButtonInput<MouseButton>>) {
 ///     println!("Mouse: {:?}", mouse.get_pressed().collect::<Vec<_>>());
 /// }
@@ -116,22 +108,19 @@ use bevy_ecs::schedule::State;
 /// ```
 ///
 /// Accepting input from multiple devices:
-/// ```no_run
+///```no_run
 /// # use bevy_app::{App, NoopPluginGroup as DefaultPlugins, Update};
 /// # use bevy_ecs::{prelude::IntoSystemConfigs, schedule::Condition};
-/// # use bevy_input::{ButtonInput, common_conditions::{input_just_pressed}, prelude::{GamepadButton, Gamepad, GamepadButtonType, KeyCode}};
+/// # use bevy_input::{ButtonInput, common_conditions::{input_just_pressed}, prelude::{ MouseButton, KeyCode}};
 ///
 /// fn main() {
-///     App::new()
+///    App::new()
 ///         .add_plugins(DefaultPlugins)
 ///         .add_systems(
 ///             Update,
 ///             something_used.run_if(
 ///                 input_just_pressed(KeyCode::KeyE)
-///                     .or_else(input_just_pressed(GamepadButton::new(
-///                         Gamepad::new(0),
-///                         GamepadButtonType::West,
-///                     ))),
+///                     .or_else(input_just_pressed(MouseButton::Left)),
 ///             ),
 ///         )
 ///         .run();
@@ -298,6 +287,22 @@ where
     pub fn get_just_released(&self) -> impl ExactSizeIterator<Item = &T> {
         self.just_released.iter()
     }
+
+    /// Returns the current state of the input.
+    pub fn pressed_state(&self, input: T) -> InputState {
+        if self.pressed(input) {
+            return InputState::Pressed;
+        }
+        InputState::Released
+    }
+}
+
+/// State of the input
+pub enum InputState {
+    /// Input is pressed
+    Pressed,
+    /// Input is released
+    Released,
 }
 
 #[cfg(test)]