Added gamepad support using Gilrs (#280)

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

.github/workflows/ci.yml

@@ -38,6 +38,10 @@ jobs:
  run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev
  if: ${{ runner.os == 'Linux' }}
 
+ - name: Install udev
+ run: sudo apt-get update; sudo apt-get install --no-install-recommends libudev-dev
+ if: ${{ runner.os == 'Linux' }}
+
  - name: Build
  run: cargo check
  env:
@@ -65,6 +69,9 @@ jobs:
  - name: Install alsa
  run: sudo apt-get install --no-install-recommends libasound2-dev
 
+ - name: Install udev
+ run: sudo apt-get install --no-install-recommends libudev-dev
+
  - name: Check the format
  run: cargo +nightly fmt --all -- --check
 

Cargo.toml

@@ -18,6 +18,7 @@ exclude = ["assets/**/*", "tools/**/*", ".github/**/*", "crates/**/*"]
 [features]
 default = [
  "bevy_audio",
+ "bevy_gilrs",
  "bevy_gltf",
  "bevy_wgpu",
  "bevy_winit",
@@ -83,6 +84,7 @@ bevy_text = { path = "crates/bevy_text", optional = true, version = "0.1" }
 bevy_ui = { path = "crates/bevy_ui", optional = true, version = "0.1" }
 bevy_wgpu = { path = "crates/bevy_wgpu", optional = true, version = "0.1" }
 bevy_winit = { path = "crates/bevy_winit", optional = true, version = "0.1" }
+bevy_gilrs = { path = "crates/bevy_gilrs", optional = true, version = "0.1" }
 
 [dev-dependencies]
 rand = "0.7.3"
@@ -217,6 +219,10 @@ path = "examples/input/keyboard_input.rs"
 name = "keyboard_input_events"
 path = "examples/input/keyboard_input_events.rs"
 
+[[example]]
+name = "gamepad_input"
+path = "examples/input/gamepad_input.rs"
+
 [[example]]
 name = "scene"
 path = "examples/scene/scene.rs"

crates/bevy_gilrs/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "bevy_gilrs"
+version = "0.1.0"
+edition = "2018"
+authors = ["Bevy Contributors <bevyengine@gmail.com>", "Carter Anderson <mcanders1@gmail.com>"]
+description = "Gamepad system made using Gilrs for Bevy Engine"
+homepage = "https://bevyengine.org"
+repository = "https://github.com/bevyengine/bevy"
+license = "MIT"
+keywords = ["bevy"]
+
+[dependencies]
+# bevy
+bevy_app = { path = "../bevy_app", version = "0.1" }
+bevy_ecs = { path = "../bevy_ecs", version = "0.1" }
+bevy_input = { path = "../bevy_input", version = "0.1" }
+
+# other
+gilrs = "0.7.4"
+log = { version = "0.4", features = ["release_max_level_info"] }

crates/bevy_gilrs/src/converter.rs

@@ -0,0 +1,44 @@
+use bevy_input::gamepad::{Gamepad, GamepadAxisType, GamepadButtonType};
+
+pub fn convert_gamepad_id(gamepad_id: gilrs::GamepadId) -> Gamepad {
+ Gamepad(gamepad_id.into())
+}
+
+pub fn convert_button(button: gilrs::Button) -> Option<GamepadButtonType> {
+ 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::Unknown => None,
+ }
+}
+
+pub fn convert_axis(axis: gilrs::Axis) -> Option<GamepadAxisType> {
+ 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::DPadX => Some(GamepadAxisType::DPadX),
+ gilrs::Axis::DPadY => Some(GamepadAxisType::DPadY),
+ gilrs::Axis::Unknown => None,
+ }
+}

crates/bevy_gilrs/src/gilrs_system.rs

@@ -0,0 +1,176 @@
+use crate::converter::{convert_axis, convert_button, convert_gamepad_id};
+use bevy_app::Events;
+use bevy_ecs::{Res, ResMut};
+use bevy_input::prelude::*;
+use gilrs::{Button, EventType, Gilrs};
+use std::sync::{Arc, Mutex};
+
+// TODO: remove this if/when bevy_ecs supports thread local resources
+struct GilrsSendWrapper(Gilrs);
+
+unsafe impl Send for GilrsSendWrapper {}
+
+pub struct GilrsArcMutexWrapper(Arc<Mutex<GilrsSendWrapper>>);
+
+impl GilrsArcMutexWrapper {
+ pub fn new(gilrs: Gilrs) -> GilrsArcMutexWrapper {
+ GilrsArcMutexWrapper(Arc::new(Mutex::new(GilrsSendWrapper(gilrs))))
+ }
+}
+
+pub fn gilrs_startup_system(
+ gilrs: Res<GilrsArcMutexWrapper>,
+ mut gamepad_event: ResMut<Events<GamepadEvent>>,
+ mut inputs: ResMut<Input<GamepadButton>>,
+ mut axes: ResMut<Axis<GamepadAxis>>,
+) {
+ gamepad_event.update();
+ inputs.update();
+ let gilrs = &gilrs.0.lock().unwrap().0;
+ for (gilrs_id, gilrs_gamepad) in gilrs.gamepads() {
+ connect_gamepad(
+ gilrs_gamepad,
+ convert_gamepad_id(gilrs_id),
+ &mut gamepad_event,
+ &mut inputs,
+ &mut axes,
+ );
+ }
+}
+
+pub fn gilrs_update_system(
+ gilrs: Res<GilrsArcMutexWrapper>,
+ mut gamepad_event: ResMut<Events<GamepadEvent>>,
+ mut inputs: ResMut<Input<GamepadButton>>,
+ mut axes: ResMut<Axis<GamepadAxis>>,
+) {
+ gamepad_event.update();
+ inputs.update();
+ let gilrs = &mut gilrs.0.lock().unwrap().0;
+ while let Some(gilrs_event) = gilrs.next_event() {
+ match gilrs_event.event {
+ EventType::Connected => {
+ connect_gamepad(
+ gilrs.gamepad(gilrs_event.id),
+ convert_gamepad_id(gilrs_event.id),
+ &mut gamepad_event,
+ &mut inputs,
+ &mut axes,
+ );
+ }
+ EventType::Disconnected => {
+ disconnect_gamepad(
+ convert_gamepad_id(gilrs_event.id),
+ &mut gamepad_event,
+ &mut inputs,
+ &mut axes,
+ );
+ }
+ EventType::ButtonPressed(gilrs_button, _) => {
+ if let Some(button_type) = convert_button(gilrs_button) {
+ inputs.press(GamepadButton(
+ convert_gamepad_id(gilrs_event.id),
+ button_type,
+ ));
+ }
+ }
+ EventType::ButtonReleased(gilrs_button, _) => {
+ if let Some(button_type) = convert_button(gilrs_button) {
+ inputs.release(GamepadButton(
+ convert_gamepad_id(gilrs_event.id),
+ button_type,
+ ));
+ }
+ }
+ EventType::AxisChanged(gilrs_axis, value, _) => {
+ if let Some(axis_type) = convert_axis(gilrs_axis) {
+ axes.set(
+ GamepadAxis(convert_gamepad_id(gilrs_event.id), axis_type),
+ value,
+ );
+ }
+ }
+ _ => (),
+ };
+ }
+ gilrs.inc();
+}
+
+const ALL_GILRS_BUTTONS: [Button; 19] = [
+ Button::South,
+ Button::East,
+ Button::North,
+ Button::West,
+ Button::C,
+ Button::Z,
+ Button::LeftTrigger,
+ Button::LeftTrigger2,
+ Button::RightTrigger,
+ Button::RightTrigger2,
+ Button::Select,
+ Button::Start,
+ Button::Mode,
+ Button::LeftThumb,
+ Button::RightThumb,
+ Button::DPadUp,
+ Button::DPadDown,
+ Button::DPadLeft,
+ Button::DPadRight,
+];
+
+const ALL_GILRS_AXES: [gilrs::Axis; 8] = [
+ gilrs::Axis::LeftStickX,
+ gilrs::Axis::LeftStickY,
+ gilrs::Axis::LeftZ,
+ gilrs::Axis::RightStickX,
+ gilrs::Axis::RightStickY,
+ gilrs::Axis::RightZ,
+ gilrs::Axis::DPadX,
+ gilrs::Axis::DPadY,
+];
+
+fn connect_gamepad(
+ gilrs_gamepad: gilrs::Gamepad,
+ gamepad: Gamepad,
+ events: &mut Events<GamepadEvent>,
+ inputs: &mut Input<GamepadButton>,
+ axes: &mut Axis<GamepadAxis>,
+) {
+ for gilrs_button in ALL_GILRS_BUTTONS.iter() {
+ if let Some(button_type) = convert_button(*gilrs_button) {
+ let gamepad_button = GamepadButton(gamepad, button_type);
+ inputs.reset(gamepad_button);
+ if gilrs_gamepad.is_pressed(*gilrs_button) {
+ inputs.press(gamepad_button);
+ }
+ }
+ }
+ for gilrs_axis in ALL_GILRS_AXES.iter() {
+ if let Some(axis_type) = convert_axis(*gilrs_axis) {
+ let gamepad_axis = GamepadAxis(gamepad, axis_type);
+ axes.set(gamepad_axis, gilrs_gamepad.value(*gilrs_axis));
+ }
+ }
+ events.send(GamepadEvent(gamepad, GamepadEventType::Connected));
+}
+
+fn disconnect_gamepad(
+ gamepad: Gamepad,
+ events: &mut Events<GamepadEvent>,
+ inputs: &mut Input<GamepadButton>,
+ axes: &mut Axis<GamepadAxis>,
+) {
+ for gilrs_button in ALL_GILRS_BUTTONS.iter() {
+ if let Some(button_type) = convert_button(*gilrs_button) {
+ let gamepad_button = GamepadButton(gamepad, button_type);
+ inputs.reset(gamepad_button);
+ }
+ }
+ for gilrs_axis in ALL_GILRS_AXES.iter() {
+ if let Some(axis_type) = convert_axis(*gilrs_axis) {
+ let gamepad_axis = GamepadAxis(gamepad, axis_type);
+ axes.remove(&gamepad_axis);
+ }
+ }
+ events.send(GamepadEvent(gamepad, GamepadEventType::Disconnected));
+}

crates/bevy_gilrs/src/lib.rs

@@ -0,0 +1,22 @@
+mod converter;
+mod gilrs_system;
+
+use bevy_app::prelude::*;
+use bevy_ecs::IntoQuerySystem;
+use gilrs_system::{gilrs_startup_system, gilrs_update_system, GilrsArcMutexWrapper};
+
+#[derive(Default)]
+pub struct GilrsPlugin;
+
+impl Plugin for GilrsPlugin {
+ fn build(&self, app: &mut AppBuilder) {
+ match gilrs::Gilrs::new() {
+ Ok(gilrs) => {
+ app.add_resource(GilrsArcMutexWrapper::new(gilrs))
+ .add_startup_system(gilrs_startup_system.system())
+ .add_system_to_stage(stage::EVENT_UPDATE, gilrs_update_system.system());
+ }
+ Err(err) => log::error!("Failed to start Gilrs. {}", err),
+ }
+ }
+}

crates/bevy_input/src/axis.rs

@@ -0,0 +1,33 @@
+use std::{collections::HashMap, hash::Hash};
+
+pub struct Axis<T> {
+ axis_data: HashMap<T, f32>,
+}
+
+impl<T> Default for Axis<T>
+where
+ T: Copy + Eq + Hash,
+{
+ fn default() -> Self {
+ Axis {
+ axis_data: HashMap::new(),
+ }
+ }
+}
+
+impl<T> Axis<T>
+where
+ T: Copy + Eq + Hash,
+{
+ pub fn set(&mut self, axis: T, value: f32) -> Option<f32> {
+ self.axis_data.insert(axis, value)
+ }
+
+ pub fn get(&self, axis: &T) -> Option<f32> {
+ self.axis_data.get(axis).copied()
+ }
+
+ pub fn remove(&mut self, axis: &T) -> Option<f32> {
+ self.axis_data.remove(axis)
+ }
+}