bevy_gilrs changes

Author: maniwani

crates/bevy_gilrs/src/gilrs_system.rs

@@ -1,20 +1,21 @@
 use crate::converter::{convert_axis, convert_button, convert_gamepad_id};
+use crate::Gilrs;
 use bevy_ecs::event::EventWriter;
-use bevy_ecs::system::{NonSend, NonSendMut, Res, ResMut};
+use bevy_ecs::system::{Res, ResMut};
 use bevy_input::gamepad::{
     GamepadAxisChangedEvent, GamepadButtonChangedEvent, GamepadConnection, GamepadConnectionEvent,
     GamepadSettings,
 };
 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, Gilrs};
+use gilrs::{ev::filter::axis_dpad_to_button, EventType, Filter};
 
 pub fn gilrs_event_startup_system(
-    gilrs: NonSend<Gilrs>,
+    mut gilrs: ResMut<Gilrs>,
     mut connection_events: EventWriter<GamepadConnectionEvent>,
 ) {
-    for (id, gamepad) in gilrs.gamepads() {
+    for (id, gamepad) in gilrs.get().gamepads() {
         let info = GamepadInfo {
             name: gamepad.name().into(),
         };
@@ -27,22 +28,23 @@ pub fn gilrs_event_startup_system(
 }
 
 pub fn gilrs_event_system(
-    mut gilrs: NonSendMut<Gilrs>,
+    mut gilrs: ResMut<Gilrs>,
     mut events: EventWriter<GamepadEvent>,
     mut gamepad_buttons: ResMut<Axis<GamepadButton>>,
     gamepad_axis: Res<Axis<GamepadAxis>>,
     gamepad_settings: Res<GamepadSettings>,
 ) {
     while let Some(gilrs_event) = gilrs
+        .get()
         .next_event()
-        .filter_ev(&axis_dpad_to_button, &mut gilrs)
+        .filter_ev(&axis_dpad_to_button, gilrs.get())
     {
-        gilrs.update(&gilrs_event);
+        gilrs.get().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 pad = gilrs.get().gamepad(gilrs_event.id);
                 let info = GamepadInfo {
                     name: pad.name().into(),
                 };
@@ -88,5 +90,5 @@ pub fn gilrs_event_system(
             _ => (),
         };
     }
-    gilrs.inc();
+    gilrs.get().inc();
 }

crates/bevy_gilrs/src/lib.rs

@@ -7,11 +7,28 @@ mod rumble;
 use bevy_app::{App, Plugin, PostUpdate, PreStartup, PreUpdate};
 use bevy_ecs::prelude::*;
 use bevy_input::InputSystem;
-use bevy_utils::tracing::error;
+use bevy_utils::{synccell::SyncCell, tracing::error};
 use gilrs::GilrsBuilder;
 use gilrs_system::{gilrs_event_startup_system, gilrs_event_system};
 use rumble::{play_gilrs_rumble, RunningRumbleEffects};
 
+/// An instance of [`gilrs::Gilrs`] wrapped in a [`SyncCell`].
+#[derive(Resource)]
+pub struct Gilrs(SyncCell<gilrs::Gilrs>);
+
+impl std::ops::Deref for Gilrs {
+    type Target = SyncCell<gilrs::Gilrs>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl std::ops::DerefMut for Gilrs {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 #[derive(Default)]
 pub struct GilrsPlugin;
 
@@ -27,8 +44,9 @@ impl Plugin for GilrsPlugin {
             .build()
         {
             Ok(gilrs) => {
-                app.insert_non_send_resource(gilrs)
-                    .init_non_send_resource::<RunningRumbleEffects>()
+                let res = Gilrs(SyncCell::new(gilrs));
+                app.insert_resource(res)
+                    .init_resource::<RunningRumbleEffects>()
                     .add_systems(PreStartup, gilrs_event_startup_system)
                     .add_systems(PreUpdate, gilrs_event_system.before(InputSystem))
                     .add_systems(PostUpdate, play_gilrs_rumble.in_set(RumbleSystem));

crates/bevy_gilrs/src/rumble.rs

@@ -1,29 +1,27 @@
 //! Handle user specified rumble request events.
-use bevy_ecs::{
-    prelude::{EventReader, Res},
-    system::NonSendMut,
-};
+use bevy_ecs::prelude::{EventReader, Res};
+use bevy_ecs::system::{ResMut, Resource};
 use bevy_input::gamepad::{GamepadRumbleIntensity, GamepadRumbleRequest};
 use bevy_log::{debug, warn};
 use bevy_time::Time;
-use bevy_utils::{Duration, HashMap};
+use bevy_utils::{synccell::SyncCell, Duration, HashMap};
 use gilrs::{
     ff::{self, BaseEffect, BaseEffectType, Repeat, Replay},
-    GamepadId, Gilrs,
+    GamepadId,
 };
 use thiserror::Error;
 
-use crate::converter::convert_gamepad_id;
+use crate::{converter::convert_gamepad_id, Gilrs};
 
 /// A rumble effect that is currently in effect.
 struct RunningRumble {
-    /// Duration from app startup when this effect will be finished
+    /// The time (since app startup) when this effect will be finished.
     deadline: Duration,
-    /// A ref-counted handle to the specific force-feedback effect
+    /// A ref-counted handle to the specific force-feedback effect.
     ///
-    /// Dropping it will cause the effect to stop
+    /// Dropping it will end the effect.
     #[allow(dead_code)]
-    effect: ff::Effect,
+    effect: SyncCell<ff::Effect>,
 }
 
 #[derive(Error, Debug)]
@@ -35,7 +33,7 @@ enum RumbleError {
 }
 
 /// Contains the gilrs rumble effects that are currently running for each gamepad
-#[derive(Default)]
+#[derive(Resource, Default)]
 pub(crate) struct RunningRumbleEffects {
     /// If multiple rumbles are running at the same time, their resulting rumble
     /// will be the saturated sum of their strengths up until [`u16::MAX`]
@@ -79,8 +77,8 @@ fn get_base_effects(
 }
 
 fn handle_rumble_request(
+    gilrs: &mut gilrs::Gilrs,
     running_rumbles: &mut RunningRumbleEffects,
-    gilrs: &mut Gilrs,
     rumble: GamepadRumbleRequest,
     current_time: Duration,
 ) -> Result<(), RumbleError> {
@@ -113,17 +111,20 @@ fn handle_rumble_request(
 
             let gamepad_rumbles = running_rumbles.rumbles.entry(gamepad_id).or_default();
             let deadline = current_time + duration;
-            gamepad_rumbles.push(RunningRumble { deadline, effect });
+            gamepad_rumbles.push(RunningRumble {
+                deadline,
+                effect: SyncCell::new(effect),
+            });
         }
     }
 
     Ok(())
 }
 pub(crate) fn play_gilrs_rumble(
     time: Res<Time>,
-    mut gilrs: NonSendMut<Gilrs>,
     mut requests: EventReader<GamepadRumbleRequest>,
-    mut running_rumbles: NonSendMut<RunningRumbleEffects>,
+    mut gilrs: ResMut<Gilrs>,
+    mut running_rumbles: ResMut<RunningRumbleEffects>,
 ) {
     let current_time = time.raw_elapsed();
     // Remove outdated rumble effects.
@@ -138,7 +139,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, &mut gilrs, rumble, current_time) {
+        match handle_rumble_request(gilrs.get(), &mut running_rumbles, rumble, current_time) {
             Ok(()) => {}
             Err(RumbleError::GilrsError(err)) => {
                 if let ff::Error::FfNotSupported(_) = err {