Implement gamepads as entities (#12770)

# Objective

- Significantly improve the ergonomics of gamepads and allow new
features

Gamepads are a bit unergonomic to work with, they use resources but
unlike other inputs, they are not limited to a single gamepad, to get
around this it uses an identifier (Gamepad) to interact with anything
causing all sorts of issues.

1. There are too many: Gamepads, GamepadSettings, GamepadInfo,
ButtonInput<T>, 2 Axis<T>.
2. ButtonInput/Axis generic methods become really inconvenient to use
e.g. any_pressed()
3. GamepadButton/Axis structs are unnecessary boilerplate:

```rust
for gamepad in gamepads.iter() {
        if button_inputs.just_pressed(GamepadButton::new(gamepad, GamepadButtonType::South)) {
            info!("{:?} just pressed South", gamepad);
        } else if button_inputs.just_released(GamepadButton::new(gamepad, GamepadButtonType::South))
        {
            info!("{:?} just released South", gamepad);
        }
}
```
4. Projects often need to create resources to store the selected gamepad
and have to manually check if their gamepad is still valid anyways.

- Previously attempted by #3419 and #12674


## Solution

- Implement gamepads as entities.

Using entities solves all the problems above and opens new
possibilities.

1. Reduce boilerplate and allows iteration

```rust
let is_pressed = gamepads_buttons.iter().any(|buttons| buttons.pressed(GamepadButtonType::South))
```
2. ButtonInput/Axis generic methods become ergonomic again 
```rust
gamepad_buttons.any_just_pressed([GamepadButtonType::Start, GamepadButtonType::Select])
```
3. Reduces the number of public components significantly (Gamepad,
GamepadSettings, GamepadButtons, GamepadAxes)
4. Components are highly convenient. Gamepad optional features could now
be expressed naturally (`Option<Rumble> or Option<Gyro>`), allows devs
to attach their own components and filter them, so code like this
becomes possible:
```rust
fn move_player<const T: usize>(
    player: Query<&Transform, With<Player<T>>>,
    gamepads_buttons: Query<&GamepadButtons, With<Player<T>>>,
) {
    if let Ok(gamepad_buttons) = gamepads_buttons.get_single() {
        if gamepad_buttons.pressed(GamepadButtonType::South) {
            // move player
        }
    }
}
```
---

## Follow-up

- [ ] Run conditions?
- [ ] Rumble component

# Changelog

## Added

TODO

## Changed

TODO

## Removed

TODO


## Migration Guide

TODO

---------

Co-authored-by: Carter Anderson <mcanders1@gmail.com>

crates/bevy_gilrs/src/converter.rs

@@ -1,42 +1,38 @@
-use bevy_input::gamepad::{Gamepad, GamepadAxisType, GamepadButtonType};
+use bevy_input::gamepad::{GamepadAxis, GamepadButton};
 
-pub fn convert_gamepad_id(gamepad_id: gilrs::GamepadId) -> Gamepad {
- Gamepad::new(gamepad_id.into())
-}
-
-pub fn convert_button(button: gilrs::Button) -> Option<GamepadButtonType> {
+pub fn convert_button(button: gilrs::Button) -> Option<GamepadButton> {
  match button {
- gilrs::Button::South => Some(GamepadButtonType::South),
- gilrs::Button::East => Some(GamepadButtonType::East),
- gilrs::Button::North => Some(GamepadButtonType::North),
- gilrs::Button::West => Some(GamepadButtonType::West),
- gilrs::Button::C => Some(GamepadButtonType::C),
- gilrs::Button::Z => Some(GamepadButtonType::Z),
- gilrs::Button::LeftTrigger => Some(GamepadButtonType::LeftTrigger),
- gilrs::Button::LeftTrigger2 => Some(GamepadButtonType::LeftTrigger2),
- gilrs::Button::RightTrigger => Some(GamepadButtonType::RightTrigger),
- gilrs::Button::RightTrigger2 => Some(GamepadButtonType::RightTrigger2),
- gilrs::Button::Select => Some(GamepadButtonType::Select),
- gilrs::Button::Start => Some(GamepadButtonType::Start),
- gilrs::Button::Mode => Some(GamepadButtonType::Mode),
- gilrs::Button::LeftThumb => Some(GamepadButtonType::LeftThumb),
- gilrs::Button::RightThumb => Some(GamepadButtonType::RightThumb),
- gilrs::Button::DPadUp => Some(GamepadButtonType::DPadUp),
- gilrs::Button::DPadDown => Some(GamepadButtonType::DPadDown),
- gilrs::Button::DPadLeft => Some(GamepadButtonType::DPadLeft),
- gilrs::Button::DPadRight => Some(GamepadButtonType::DPadRight),
+ gilrs::Button::South => Some(GamepadButton::South),
+ gilrs::Button::East => Some(GamepadButton::East),
+ gilrs::Button::North => Some(GamepadButton::North),
+ gilrs::Button::West => Some(GamepadButton::West),
+ gilrs::Button::C => Some(GamepadButton::C),
+ gilrs::Button::Z => Some(GamepadButton::Z),
+ gilrs::Button::LeftTrigger => Some(GamepadButton::LeftTrigger),
+ gilrs::Button::LeftTrigger2 => Some(GamepadButton::LeftTrigger2),
+ gilrs::Button::RightTrigger => Some(GamepadButton::RightTrigger),
+ gilrs::Button::RightTrigger2 => Some(GamepadButton::RightTrigger2),
+ gilrs::Button::Select => Some(GamepadButton::Select),
+ gilrs::Button::Start => Some(GamepadButton::Start),
+ gilrs::Button::Mode => Some(GamepadButton::Mode),
+ gilrs::Button::LeftThumb => Some(GamepadButton::LeftThumb),
+ gilrs::Button::RightThumb => Some(GamepadButton::RightThumb),
+ gilrs::Button::DPadUp => Some(GamepadButton::DPadUp),
+ gilrs::Button::DPadDown => Some(GamepadButton::DPadDown),
+ gilrs::Button::DPadLeft => Some(GamepadButton::DPadLeft),
+ gilrs::Button::DPadRight => Some(GamepadButton::DPadRight),
  gilrs::Button::Unknown => None,
  }
 }
 
-pub fn convert_axis(axis: gilrs::Axis) -> Option<GamepadAxisType> {
+pub fn convert_axis(axis: gilrs::Axis) -> Option<GamepadAxis> {
  match axis {
- gilrs::Axis::LeftStickX => Some(GamepadAxisType::LeftStickX),
- gilrs::Axis::LeftStickY => Some(GamepadAxisType::LeftStickY),
- gilrs::Axis::LeftZ => Some(GamepadAxisType::LeftZ),
- gilrs::Axis::RightStickX => Some(GamepadAxisType::RightStickX),
- gilrs::Axis::RightStickY => Some(GamepadAxisType::RightStickY),
- gilrs::Axis::RightZ => Some(GamepadAxisType::RightZ),
+ gilrs::Axis::LeftStickX => Some(GamepadAxis::LeftStickX),
+ gilrs::Axis::LeftStickY => Some(GamepadAxis::LeftStickY),
+ gilrs::Axis::LeftZ => Some(GamepadAxis::LeftZ),
+ gilrs::Axis::RightStickX => Some(GamepadAxis::RightStickX),
+ gilrs::Axis::RightStickY => Some(GamepadAxis::RightStickY),
+ gilrs::Axis::RightZ => Some(GamepadAxis::RightZ),
  // The `axis_dpad_to_button` gilrs filter should filter out all DPadX and DPadY events. If
  // it doesn't then we probably need an entry added to the following repo and an update to
  // GilRs to use the updated database: https://github.com/gabomdq/SDL_GameControllerDB

crates/bevy_gilrs/src/gilrs_system.rs

@@ -1,103 +1,113 @@
 use crate::{
- converter::{convert_axis, convert_button, convert_gamepad_id},
- Gilrs,
+ converter::{convert_axis, convert_button},
+ Gilrs, GilrsGamepads,
 };
+use bevy_ecs::event::EventWriter;
+use bevy_ecs::prelude::Commands;
 #[cfg(target_arch = "wasm32")]
 use bevy_ecs::system::NonSendMut;
-use bevy_ecs::{
- event::EventWriter,
- system::{Res, ResMut},
-};
-use bevy_input::{
- gamepad::{
- GamepadAxisChangedEvent, GamepadButtonChangedEvent, GamepadConnection,
- GamepadConnectionEvent, GamepadEvent, GamepadInfo, GamepadSettings,
- },
- prelude::{GamepadAxis, GamepadButton},
- Axis,
+use bevy_ecs::system::ResMut;
+use bevy_input::gamepad::{
+ GamepadConnection, GamepadConnectionEvent, GamepadInfo, RawGamepadAxisChangedEvent,
+ RawGamepadButtonChangedEvent, RawGamepadEvent,
 };
 use gilrs::{ev::filter::axis_dpad_to_button, EventType, Filter};
 
 pub fn gilrs_event_startup_system(
+ mut commands: Commands,
  #[cfg(target_arch = "wasm32")] mut gilrs: NonSendMut<Gilrs>,
  #[cfg(not(target_arch = "wasm32"))] mut gilrs: ResMut<Gilrs>,
- mut events: EventWriter<GamepadEvent>,
+ mut gamepads: ResMut<GilrsGamepads>,
+ mut events: EventWriter<GamepadConnectionEvent>,
 ) {
  for (id, gamepad) in gilrs.0.get().gamepads() {
+ // Create entity and add to mapping
+ let entity = commands.spawn_empty().id();
+ gamepads.id_to_entity.insert(id, entity);
+ gamepads.entity_to_id.insert(entity, id);
+
  let info = GamepadInfo {
  name: gamepad.name().into(),
  };
 
- events.send(
- GamepadConnectionEvent {
- gamepad: convert_gamepad_id(id),
- connection: GamepadConnection::Connected(info),
- }
- .into(),
- );
+ events.send(GamepadConnectionEvent {
+ gamepad: entity,
+ connection: GamepadConnection::Connected(info),
+ });
  }
 }
 
 pub fn gilrs_event_system(
+ mut commands: Commands,
  #[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 gamepads: ResMut<GilrsGamepads>,
+ 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) {
  gilrs.update(&gilrs_event);
-
- let gamepad = convert_gamepad_id(gilrs_event.id);
  match gilrs_event.event {
  EventType::Connected => {
  let pad = gilrs.gamepad(gilrs_event.id);
+ let entity = gamepads.get_entity(gilrs_event.id).unwrap_or_else(|| {
+ let entity = commands.spawn_empty().id();
+ gamepads.id_to_entity.insert(gilrs_event.id, entity);
+ gamepads.entity_to_id.insert(entity, gilrs_event.id);
+ entity
+ });
+
  let info = GamepadInfo {
  name: pad.name().into(),
  };
 
  events.send(
- GamepadConnectionEvent::new(gamepad, GamepadConnection::Connected(info)).into(),
+ GamepadConnectionEvent::new(entity, GamepadConnection::Connected(info.clone()))
+ .into(),
  );
+ connection_events.send(GamepadConnectionEvent::new(
+ entity,
+ GamepadConnection::Connected(info),
+ ));
  }
  EventType::Disconnected => {
- events.send(
- GamepadConnectionEvent::new(gamepad, GamepadConnection::Disconnected).into(),
- );
+ let gamepad = gamepads
+ .id_to_entity
+ .get(&gilrs_event.id)
+ .copied()
+ .expect("mapping should exist from connection");
+ let event = GamepadConnectionEvent::new(gamepad, GamepadConnection::Disconnected);
+ events.send(event.clone().into());
+ connection_events.send(event);
  }
  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;
+ };
+ let gamepad = gamepads
+ .id_to_entity
+ .get(&gilrs_event.id)
+ .copied()
+ .expect("mapping should exist from connection");
+ 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;
+ };
+ let gamepad = gamepads
+ .id_to_entity
+ .get(&gilrs_event.id)
+ .copied()
+ .expect("mapping should exist from connection");
+ events.send(RawGamepadAxisChangedEvent::new(gamepad, axis, raw_value).into());
+ axis_event.send(RawGamepadAxisChangedEvent::new(gamepad, axis, raw_value));
  }
  _ => (),
  };

crates/bevy_gilrs/src/lib.rs

@@ -15,16 +15,38 @@ mod gilrs_system;
 mod rumble;
 
 use bevy_app::{App, Plugin, PostUpdate, PreStartup, PreUpdate};
+use bevy_ecs::entity::EntityHashMap;
 use bevy_ecs::prelude::*;
 use bevy_input::InputSystem;
-use bevy_utils::{synccell::SyncCell, tracing::error};
+use bevy_utils::{synccell::SyncCell, tracing::error, HashMap};
 use gilrs::GilrsBuilder;
 use gilrs_system::{gilrs_event_startup_system, gilrs_event_system};
 use rumble::{play_gilrs_rumble, RunningRumbleEffects};
 
 #[cfg_attr(not(target_arch = "wasm32"), derive(Resource))]
 pub(crate) struct Gilrs(pub SyncCell<gilrs::Gilrs>);
 
+/// A [`resource`](Resource) with the mapping of connected [`gilrs::GamepadId`] and their [`Entity`].
+#[derive(Debug, Default, Resource)]
+pub(crate) struct GilrsGamepads {
+ /// Mapping of [`Entity`] to [`gilrs::GamepadId`].
+ pub(crate) entity_to_id: EntityHashMap<gilrs::GamepadId>,
+ /// Mapping of [`gilrs::GamepadId`] to [`Entity`].
+ pub(crate) id_to_entity: HashMap<gilrs::GamepadId, Entity>,
+}
+
+impl GilrsGamepads {
+ /// Returns the [`Entity`] assigned to a connected [`gilrs::GamepadId`].
+ pub fn get_entity(&self, gamepad_id: gilrs::GamepadId) -> Option<Entity> {
+ self.id_to_entity.get(&gamepad_id).copied()
+ }
+
+ /// Returns the [`gilrs::GamepadId`] assigned to a gamepad [`Entity`].
+ pub fn get_gamepad_id(&self, entity: Entity) -> Option<gilrs::GamepadId> {
+ self.entity_to_id.get(&entity).copied()
+ }
+}
+
 /// Plugin that provides gamepad handling to an [`App`].
 #[derive(Default)]
 pub struct GilrsPlugin;
@@ -45,7 +67,7 @@ impl Plugin for GilrsPlugin {
  app.insert_non_send_resource(Gilrs(SyncCell::new(gilrs)));
  #[cfg(not(target_arch = "wasm32"))]
  app.insert_resource(Gilrs(SyncCell::new(gilrs)));
-
+ app.init_resource::<GilrsGamepads>();
  app.init_resource::<RunningRumbleEffects>()
  .add_systems(PreStartup, gilrs_event_startup_system)
  .add_systems(PreUpdate, gilrs_event_system.before(InputSystem))

crates/bevy_gilrs/src/rumble.rs

@@ -1,5 +1,5 @@
 //! Handle user specified rumble request events.
-use crate::Gilrs;
+use crate::{Gilrs, GilrsGamepads};
 use bevy_ecs::prelude::{EventReader, Res, ResMut, Resource};
 #[cfg(target_arch = "wasm32")]
 use bevy_ecs::system::NonSendMut;
@@ -16,8 +16,6 @@ use gilrs::{
 };
 use thiserror::Error;
 
-use crate::converter::convert_gamepad_id;
-
 /// A rumble effect that is currently in effect.
 struct RunningRumble {
  /// Duration from app startup when this effect will be finished
@@ -84,14 +82,15 @@ fn get_base_effects(
 fn handle_rumble_request(
  running_rumbles: &mut RunningRumbleEffects,
  gilrs: &mut gilrs::Gilrs,
+ gamepads: &GilrsGamepads,
  rumble: GamepadRumbleRequest,
  current_time: Duration,
 ) -> Result<(), RumbleError> {
  let gamepad = rumble.gamepad();
 
  let (gamepad_id, _) = gilrs
  .gamepads()
- .find(|(pad_id, _)| convert_gamepad_id(*pad_id) == gamepad)
+ .find(|(pad_id, _)| *pad_id == gamepads.get_gamepad_id(gamepad).unwrap())
  .ok_or(RumbleError::GamepadNotFound)?;
 
  match rumble {
@@ -129,6 +128,7 @@ pub(crate) fn play_gilrs_rumble(
  time: Res<Time<Real>>,
  #[cfg(target_arch = "wasm32")] mut gilrs: NonSendMut<Gilrs>,
  #[cfg(not(target_arch = "wasm32"))] mut gilrs: ResMut<Gilrs>,
+ gamepads: Res<GilrsGamepads>,
  mut requests: EventReader<GamepadRumbleRequest>,
  mut running_rumbles: ResMut<RunningRumbleEffects>,
 ) {
@@ -146,7 +146,7 @@ pub(crate) fn play_gilrs_rumble(
  // Add new effects.
  for rumble in requests.read().cloned() {
  let gamepad = rumble.gamepad();
- match handle_rumble_request(&mut running_rumbles, gilrs, rumble, current_time) {
+ match handle_rumble_request(&mut running_rumbles, gilrs, &gamepads, rumble, current_time) {
  Ok(()) => {}
  Err(RumbleError::GilrsError(err)) => {
  if let ff::Error::FfNotSupported(_) = err {