gamepad: expose raw and filtered gamepad events.

Cargo.toml

@@ -231,8 +231,8 @@ name = "gamepad_input"
 path = "examples/input/gamepad_input.rs"
 
 [[example]]
-name = "gamepad_input_event"
-path = "examples/input/gamepad_input_event.rs"
+name = "gamepad_input_events"
+path = "examples/input/gamepad_input_events.rs"
 
 [[example]]
 name = "touch_input"

crates/bevy_app/src/app_builder.rs

@@ -174,7 +174,8 @@ impl AppBuilder {
  .add_startup_stage(startup_stage::STARTUP)
  .add_startup_stage(startup_stage::POST_STARTUP)
  .add_stage(stage::FIRST)
- .add_stage(stage::EVENT_UPDATE)
+ .add_stage(stage::PRE_EVENT)
+ .add_stage(stage::EVENT)
  .add_stage(stage::PRE_UPDATE)
  .add_stage(stage::UPDATE)
  .add_stage(stage::POST_UPDATE)
@@ -217,7 +218,7 @@ impl AppBuilder {
  T: Send + Sync + 'static,
  {
  self.add_resource(Events::<T>::default())
- .add_system_to_stage(stage::EVENT_UPDATE, Events::<T>::update_system.system())
+ .add_system_to_stage(stage::EVENT, Events::<T>::update_system.system())
  }
 
  pub fn add_resource<T>(&mut self, resource: T) -> &mut Self

crates/bevy_app/src/stage.rs

@@ -1,8 +1,11 @@
 /// Name of app stage that runs before all other app stages
 pub const FIRST: &str = "first";
 
-/// Name of app stage that updates events. Generally this should run before UPDATE
-pub const EVENT_UPDATE: &str = "event_update";
+/// Name of app stage that runs before EVENT
+pub const PRE_EVENT: &str = "pre_events";
+
+/// Name of app stage that updates events. Runs before UPDATE
+pub const EVENT: &str = "events";
 
 /// Name of app stage responsible for performing setup before an update. Runs before UPDATE.
 pub const PRE_UPDATE: &str = "pre_update";

crates/bevy_gilrs/src/gilrs_system.rs

@@ -1,50 +1,38 @@
 use crate::converter::{convert_axis, convert_button, convert_gamepad_id};
 use bevy_app::Events;
 use bevy_ecs::{Resources, World};
-use bevy_input::prelude::*;
+use bevy_input::{gamepad::GamepadEventRaw, prelude::*};
 use gilrs::{EventType, Gilrs};
 
-pub fn gilrs_event_startup_system(_world: &mut World, resources: &mut Resources) {
- let gilrs = resources.get_thread_local::<Gilrs>().unwrap();
- let mut event = resources.get_mut::<Events<GamepadEvent>>().unwrap();
- event.update();
- for (id, _) in gilrs.gamepads() {
- event.send(GamepadEvent(
- convert_gamepad_id(id),
- GamepadEventType::Connected,
- ));
- }
-}
-
-pub fn girls_event_system(_world: &mut World, resources: &mut Resources) {
+pub fn gilrs_event_system(_world: &mut World, resources: &mut Resources) {
  let mut gilrs = resources.get_thread_local_mut::<Gilrs>().unwrap();
- let mut event = resources.get_mut::<Events<GamepadEvent>>().unwrap();
+ let mut event = resources.get_mut::<Events<GamepadEventRaw>>().unwrap();
  event.update();
  while let Some(gilrs_event) = gilrs.next_event() {
  match gilrs_event.event {
  EventType::Connected => {
- event.send(GamepadEvent(
+ event.send(GamepadEventRaw(
  convert_gamepad_id(gilrs_event.id),
  GamepadEventType::Connected,
  ));
  }
  EventType::Disconnected => {
- event.send(GamepadEvent(
+ event.send(GamepadEventRaw(
  convert_gamepad_id(gilrs_event.id),
  GamepadEventType::Disconnected,
  ));
  }
  EventType::ButtonChanged(gilrs_button, value, _) => {
  if let Some(button_type) = convert_button(gilrs_button) {
- event.send(GamepadEvent(
+ event.send(GamepadEventRaw(
  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) {
- event.send(GamepadEvent(
+ event.send(GamepadEventRaw(
  convert_gamepad_id(gilrs_event.id),
  GamepadEventType::AxisChanged(axis_type, value),
  ));

crates/bevy_gilrs/src/lib.rs

@@ -4,7 +4,7 @@ mod gilrs_system;
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
 use gilrs::GilrsBuilder;
-use gilrs_system::{gilrs_event_startup_system, girls_event_system};
+use gilrs_system::gilrs_event_system;
 
 #[derive(Default)]
 pub struct GilrsPlugin;
@@ -18,8 +18,11 @@ impl Plugin for GilrsPlugin {
  {
  Ok(gilrs) => {
  app.add_thread_local_resource(gilrs)
- .add_startup_system(gilrs_event_startup_system.thread_local_system())
- .add_system_to_stage(stage::FIRST, girls_event_system.thread_local_system());
+ .add_startup_system(gilrs_event_system.thread_local_system())
+ .add_system_to_stage(
+ stage::PRE_EVENT,
+ gilrs_event_system.thread_local_system(),
+ );
  }
  Err(err) => log::error!("Failed to start Gilrs. {}", err),
  }

crates/bevy_input/src/gamepad.rs

@@ -20,6 +20,10 @@ pub enum GamepadEventType {
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 pub struct GamepadEvent(pub Gamepad, pub GamepadEventType);
 
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+pub struct GamepadEventRaw(pub Gamepad, pub GamepadEventType);
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 pub enum GamepadButtonType {
@@ -66,51 +70,51 @@ pub enum GamepadAxisType {
 pub struct GamepadAxis(pub Gamepad, pub GamepadAxisType);
 
 #[derive(Default, Debug)]
-pub struct GamepadSetting {
- pub default_button_setting: ButtonSetting,
- pub default_axis_setting: AxisSetting,
- pub default_button_axis_setting: ButtonAxisSetting,
- pub button_settings: HashMap<GamepadButton, ButtonSetting>,
- pub axis_settings: HashMap<GamepadAxis, AxisSetting>,
- pub button_axis_settings: HashMap<GamepadButton, ButtonAxisSetting>,
+pub struct GamepadSettings {
+ pub default_button_settings: ButtonSettings,
+ pub default_axis_settings: AxisSettings,
+ pub default_button_axis_settings: ButtonAxisSettings,
+ pub button_settings: HashMap<GamepadButton, ButtonSettings>,
+ pub axis_settings: HashMap<GamepadAxis, AxisSettings>,
+ pub button_axis_settings: HashMap<GamepadButton, ButtonAxisSettings>,
 }
 
-impl GamepadSetting {
- pub fn get_button_setting(&self, button: GamepadButton) -> &ButtonSetting {
+impl GamepadSettings {
+ pub fn get_button_settings(&self, button: GamepadButton) -> &ButtonSettings {
  self.button_settings
  .get(&button)
- .unwrap_or(&self.default_button_setting)
+ .unwrap_or(&self.default_button_settings)
  }
 
- pub fn get_axis_setting(&self, axis: GamepadAxis) -> &AxisSetting {
+ pub fn get_axis_settings(&self, axis: GamepadAxis) -> &AxisSettings {
  self.axis_settings
  .get(&axis)
- .unwrap_or(&self.default_axis_setting)
+ .unwrap_or(&self.default_axis_settings)
  }
 
- pub fn get_button_axis_setting(&self, button: GamepadButton) -> &ButtonAxisSetting {
+ pub fn get_button_axis_settings(&self, button: GamepadButton) -> &ButtonAxisSettings {
  self.button_axis_settings
  .get(&button)
- .unwrap_or(&self.default_button_axis_setting)
+ .unwrap_or(&self.default_button_axis_settings)
  }
 }
 
 #[derive(Debug, Clone)]
-pub struct ButtonSetting {
+pub struct ButtonSettings {
  pub press: f32,
  pub release: f32,
 }
 
-impl Default for ButtonSetting {
+impl Default for ButtonSettings {
  fn default() -> Self {
- ButtonSetting {
+ ButtonSettings {
  press: 0.75,
  release: 0.65,
  }
  }
 }
 
-impl ButtonSetting {
+impl ButtonSettings {
  fn is_pressed(&self, value: f32) -> bool {
  value >= self.press
  }
@@ -121,17 +125,17 @@ impl ButtonSetting {
 }
 
 #[derive(Debug, Clone)]
-pub struct AxisSetting {
+pub struct AxisSettings {
  pub positive_high: f32,
  pub positive_low: f32,
  pub negative_high: f32,
  pub negative_low: f32,
  pub threshold: f32,
 }
 
-impl Default for AxisSetting {
+impl Default for AxisSettings {
  fn default() -> Self {
- AxisSetting {
+ AxisSettings {
  positive_high: 0.95,
  positive_low: 0.05,
  negative_high: -0.95,
@@ -141,7 +145,7 @@ impl Default for AxisSetting {
  }
 }
 
-impl AxisSetting {
+impl AxisSettings {
  fn filter(&self, new_value: f32, old_value: Option<f32>) -> f32 {
  if let Some(old_value) = old_value {
  if (new_value - old_value).abs() <= self.threshold {
@@ -162,23 +166,23 @@ impl AxisSetting {
 }
 
 #[derive(Debug, Clone)]
-pub struct ButtonAxisSetting {
+pub struct ButtonAxisSettings {
  pub high: f32,
  pub low: f32,
  pub threshold: f32,
 }
 
-impl Default for ButtonAxisSetting {
+impl Default for ButtonAxisSettings {
  fn default() -> Self {
- ButtonAxisSetting {
+ ButtonAxisSettings {
  high: 0.95,
  low: 0.05,
  threshold: 0.01,
  }
  }
 }
 
-impl ButtonAxisSetting {
+impl ButtonAxisSettings {
  fn filter(&self, new_value: f32, old_value: Option<f32>) -> f32 {
  if let Some(old_value) = old_value {
  if (new_value - old_value).abs() <= self.threshold {
@@ -195,65 +199,94 @@ impl ButtonAxisSetting {
  }
 }
 
-#[derive(Default)]
-pub struct GamepadEventState {
- gamepad_event_reader: EventReader<GamepadEvent>,
-}
-
+#[allow(clippy::float_cmp)]
 pub fn gamepad_event_system(
- mut state: Local<GamepadEventState>,
+ mut event_reader: Local<EventReader<GamepadEventRaw>>,
  mut button_input: ResMut<Input<GamepadButton>>,
  mut axis: ResMut<Axis<GamepadAxis>>,
  mut button_axis: ResMut<Axis<GamepadButton>>,
- events: Res<Events<GamepadEvent>>,
- settings: Res<GamepadSetting>,
+ raw_events: Res<Events<GamepadEventRaw>>,
+ mut events: ResMut<Events<GamepadEvent>>,
+ settings: Res<GamepadSettings>,
 ) {
  button_input.update();
- for event in state.gamepad_event_reader.iter(&events) {
- let (gamepad, event) = (&event.0, &event.1);
+ for event in event_reader.iter(&raw_events) {
+ let (gamepad, event) = (event.0, &event.1);
  match event {
  GamepadEventType::Connected => {
+ events.send(GamepadEvent(gamepad, event.clone()));
  for button_type in ALL_BUTTON_TYPES.iter() {
- let gamepad_button = GamepadButton(*gamepad, *button_type);
+ let gamepad_button = GamepadButton(gamepad, *button_type);
  button_input.reset(gamepad_button);
  button_axis.set(gamepad_button, 0.0);
  }
  for axis_type in ALL_AXIS_TYPES.iter() {
- axis.set(GamepadAxis(*gamepad, *axis_type), 0.0);
+ axis.set(GamepadAxis(gamepad, *axis_type), 0.0);
  }
  }
  GamepadEventType::Disconnected => {
+ events.send(GamepadEvent(gamepad, event.clone()));
  for button_type in ALL_BUTTON_TYPES.iter() {
- let gamepad_button = GamepadButton(*gamepad, *button_type);
+ let gamepad_button = GamepadButton(gamepad, *button_type);
  button_input.reset(gamepad_button);
  button_axis.remove(gamepad_button);
  }
  for axis_type in ALL_AXIS_TYPES.iter() {
- axis.remove(GamepadAxis(*gamepad, *axis_type));
+ axis.remove(GamepadAxis(gamepad, *axis_type));
  }
  }
  GamepadEventType::AxisChanged(axis_type, value) => {
- let gamepad_axis = GamepadAxis(*gamepad, *axis_type);
- let value = settings
- .get_axis_setting(gamepad_axis)
- .filter(*value, axis.get(gamepad_axis));
- axis.set(gamepad_axis, value);
+ let gamepad_axis = GamepadAxis(gamepad, *axis_type);
+ let old_value = axis.get(gamepad_axis);
+ let filtered_value = settings
+ .get_axis_settings(gamepad_axis)
+ .filter(*value, old_value);
+ axis.set(gamepad_axis, filtered_value);
+
+ // only send event if axis has changed after going through filters
+ if let Some(old_value) = old_value {
+ if old_value == filtered_value {
+ return;
+ }
+ } else if filtered_value == 0.0 {
+ return;
+ }
+
+ events.send(GamepadEvent(
+ gamepad,
+ GamepadEventType::AxisChanged(*axis_type, filtered_value),
+ ))
  }
  GamepadEventType::ButtonChanged(button_type, value) => {
- let gamepad_button = GamepadButton(*gamepad, *button_type);
+ let gamepad_button = GamepadButton(gamepad, *button_type);
+ let old_value = button_axis.get(gamepad_button);
  let filtered_value = settings
- .get_button_axis_setting(gamepad_button)
- .filter(*value, button_axis.get(gamepad_button));
+ .get_button_axis_settings(gamepad_button)
+ .filter(*value, old_value);
  button_axis.set(gamepad_button, filtered_value);
 
- let button_property = settings.get_button_setting(gamepad_button);
+ let button_property = settings.get_button_settings(gamepad_button);
  if button_input.pressed(gamepad_button) {
  if button_property.is_released(*value) {
  button_input.release(gamepad_button);
  }
  } else if button_property.is_pressed(*value) {
  button_input.press(gamepad_button);
  }
+
+ // only send event if axis has changed after going through filters
+ if let Some(old_value) = old_value {
+ if old_value == filtered_value {
+ return;
+ }
+ } else if filtered_value == 0.0 {
+ return;
+ }
+
+ events.send(GamepadEvent(
+ gamepad,
+ GamepadEventType::ButtonChanged(*button_type, filtered_value),
+ ))
  }
  }
  }