Publicly expose gamepad rumble

examples/gamepad.rs

@@ -1,6 +1,7 @@
 extern crate winit;
 use winit::window::WindowBuilder;
-use winit::event::{DeviceEvent, Event, WindowEvent};
+use winit::event::{ElementState, Event, WindowEvent};
+use winit::event::device::{DeviceEvent, GamepadEvent};
 use winit::event_loop::{EventLoop, ControlFlow};
 
 fn main() {
@@ -11,12 +12,24 @@ fn main() {
         .build(&event_loop)
         .unwrap();
 
-    event_loop.run(|event, _, control_flow| {
+    let mut rumble_left = true;
+
+    event_loop.run(move |event, _, control_flow| {
         match event {
-            Event::DeviceEvent { device_id, event } => match event {
-                DeviceEvent::Button { .. }
-                | DeviceEvent::Motion { .. } => {
-                    println!("[{:?}] {:#?}", device_id, event);
+            Event::DeviceEvent(DeviceEvent::GamepadEvent(gamepad_handle, event)) => match event {
+                GamepadEvent::Axis {value, ..} => {
+                    println!("[{:?}] {:#?}", gamepad_handle, event);
+                },
+                GamepadEvent::Button { state, .. } => {
+                    println!("[{:?}] {:#?}", gamepad_handle, event);
+                    match state {
+                        ElementState::Pressed if rumble_left => gamepad_handle.rumble(1.0, 0.0),
+                        ElementState::Pressed                => gamepad_handle.rumble(0.0, 1.0),
+                        ElementState::Released => {
+                            gamepad_handle.rumble(0.0, 0.0);
+                            rumble_left = !rumble_left;
+                        },
+                    }
                 },
                 _ => ()
             },

src/event/device.rs

@@ -76,7 +76,7 @@ pub enum AxisHint {
 /// game controls. Many physical actions, such as mouse movement, can produce both device and window events.
 ///
 /// Note that these events are delivered regardless of input focus.
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum DeviceEvent {
     MouseEvent(MouseId, MouseEvent),
     KeyboardEvent(KeyboardId, KeyboardEvent),
@@ -131,7 +131,7 @@ pub enum GamepadEvent {
 pub struct MouseId(pub(crate) platform_impl::MouseId);
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct KeyboardId(pub(crate) platform_impl::KeyboardId);
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct GamepadHandle(pub(crate) platform_impl::GamepadHandle);
 
 impl MouseId {
@@ -165,6 +165,10 @@ impl GamepadHandle {
     pub unsafe fn dummy() -> Self {
         GamepadHandle(platform_impl::GamepadHandle::dummy())
     }
+
+    pub fn rumble(&self, left_speed: f64, right_speed: f64) {
+        self.0.rumble(left_speed, right_speed);
+    }
 }
 
 impl fmt::Debug for MouseId {

src/platform_impl/windows/event_loop.rs

@@ -1495,8 +1495,11 @@ unsafe extern "system" fn thread_event_target_callback<T>(
                             },
                             RawDeviceInfo::Hid(_) => {
                                 event = Gamepad::new(handle).map(|gamepad| {
-                                    let gamepad_handle = GamepadHandle(handle);
-                                    subclass_input.active_device_ids.insert(handle, DeviceId::Gamepad(gamepad_handle, gamepad));
+                                    let gamepad_handle = GamepadHandle {
+                                        handle,
+                                        rumbler: gamepad.rumbler(),
+                                    };
+                                    subclass_input.active_device_ids.insert(handle, DeviceId::Gamepad(gamepad_handle.clone(), gamepad));
 
                                     DeviceEvent::GamepadEvent(
                                         gamepad_handle.into(),
@@ -1640,38 +1643,41 @@ unsafe extern "system" fn thread_event_target_callback<T>(
                     }
                 },
                 Some(RawInputData::Hid{device_handle, mut raw_hid}) => {
+                    let mut gamepad_handle_opt: Option<::event::device::GamepadHandle> = None;
                     let (mut changed_buttons, mut changed_axes) = (vec![], vec![]);
-                    if let Some(DeviceId::Gamepad(_, ref mut gamepad)) = subclass_input.active_device_ids.get_mut(&device_handle) {
+                    if let Some(DeviceId::Gamepad(gamepad_handle, ref mut gamepad)) = subclass_input.active_device_ids.get_mut(&device_handle) {
                         gamepad.update_state(&mut raw_hid.raw_input);
                         changed_buttons = gamepad.get_changed_buttons();
                         changed_axes = gamepad.get_changed_axes();
+                        gamepad_handle_opt = Some(gamepad_handle.clone().into());
                     }
 
-                    let gamepad_handle = GamepadHandle(device_handle).into();
-                    for ButtonEvent{ button_id, hint, state } in changed_buttons {
-                        subclass_input.send_event(Event::DeviceEvent(
-                            DeviceEvent::GamepadEvent(
-                                gamepad_handle,
-                                GamepadEvent::Button {
-                                    button_id,
-                                    hint,
-                                    state,
-                                },
-                            )
-                        ));
-                    }
+                    if let Some(gamepad_handle) = gamepad_handle_opt {
+                        for ButtonEvent{ button_id, hint, state } in changed_buttons {
+                            subclass_input.send_event(Event::DeviceEvent(
+                                DeviceEvent::GamepadEvent(
+                                    gamepad_handle.clone(),
+                                    GamepadEvent::Button {
+                                        button_id,
+                                        hint,
+                                        state,
+                                    },
+                                )
+                            ));
+                        }
 
-                    for AxisEvent{ axis, hint, value } in changed_axes {
-                        subclass_input.send_event(Event::DeviceEvent(
-                            DeviceEvent::GamepadEvent(
-                                gamepad_handle,
-                                GamepadEvent::Axis {
-                                    axis,
-                                    hint,
-                                    value,
-                                },
-                            )
-                        ));
+                        for AxisEvent{ axis, hint, value } in changed_axes {
+                            subclass_input.send_event(Event::DeviceEvent(
+                                DeviceEvent::GamepadEvent(
+                                    gamepad_handle.clone(),
+                                    GamepadEvent::Axis {
+                                        axis,
+                                        hint,
+                                        value,
+                                    },
+                                )
+                            ));
+                        }
                     }
                 },
                 None => ()

src/platform_impl/windows/gamepad.rs

@@ -1,18 +1,27 @@
+use std::rc::Weak;
+
 use winapi::um::winnt::HANDLE;
 
 use event::{
     ElementState,
     device::{AxisHint, ButtonHint},
 };
 use platform_impl::platform::raw_input::{get_raw_input_device_name, RawGamepad};
-use platform_impl::platform::xinput::{self, XInputGamepad};
+use platform_impl::platform::xinput::{self, XInputGamepad, XInputGamepadRumbler};
 
 #[derive(Debug)]
 pub enum GamepadType {
     Raw(RawGamepad),
     XInput(XInputGamepad),
 }
 
+#[derive(Clone)]
+pub enum GamepadRumbler {
+    Raw(()),
+    XInput(Weak<XInputGamepadRumbler>),
+    Dummy,
+}
+
 #[derive(Debug)]
 pub struct Gamepad {
     handle: HANDLE,
@@ -70,10 +79,10 @@ impl Gamepad {
         }
     }
 
-    pub fn rumble(&mut self, left_speed: u16, right_speed: u16) {
+    pub fn rumbler(&self) -> GamepadRumbler {
         match self.backend {
-            GamepadType::Raw(ref mut gamepad) => gamepad.rumble(left_speed, right_speed),
-            GamepadType::XInput(ref mut gamepad) => gamepad.rumble(left_speed, right_speed),
+            GamepadType::Raw(_) => GamepadRumbler::Raw(()),
+            GamepadType::XInput(ref gamepad) => GamepadRumbler::XInput(gamepad.rumbler()),
         }
     }
 }
@@ -89,3 +98,13 @@ impl ButtonEvent {
         ButtonEvent{ button_id, hint, state }
     }
 }
+
+impl GamepadRumbler {
+    pub fn rumble(&self, left_speed: f64, right_speed: f64) {
+        match self {
+            GamepadRumbler::Raw(_) => (),
+            GamepadRumbler::XInput(ref rumbler) => {rumbler.upgrade().map(|r| r.rumble(left_speed, right_speed));},
+            GamepadRumbler::Dummy => (),
+        }
+    }
+}

src/platform_impl/windows/mod.rs

@@ -13,13 +13,17 @@ mod window;
 mod window_state;
 mod xinput;
 
+use std::cmp::{Ordering, Eq, Ord, PartialEq, PartialOrd};
+use std::hash::{Hash, Hasher};
+use std::fmt;
 use std::ptr;
 use winapi;
 use winapi::shared::windef::HWND;
 use winapi::um::winnt::HANDLE;
 use window::Icon;
 
 pub use self::event_loop::{EventLoop, EventLoopWindowTarget, EventLoopProxy};
+pub use self::gamepad::GamepadRumbler;
 pub use self::monitor::MonitorHandle;
 pub use self::window::Window;
 
@@ -75,4 +79,68 @@ macro_rules! device_id {
 
 device_id!(MouseId);
 device_id!(KeyboardId);
-device_id!(GamepadHandle);
+
+#[derive(Clone)]
+pub(crate) struct GamepadHandle {
+    handle: HANDLE,
+    rumbler: GamepadRumbler,
+}
+
+impl GamepadHandle {
+    pub unsafe fn dummy() -> Self {
+        Self {
+            handle: ptr::null_mut(),
+            rumbler: GamepadRumbler::Dummy,
+        }
+    }
+
+    pub fn get_persistent_identifier(&self) -> Option<String> {
+        raw_input::get_raw_input_device_name(self.handle)
+    }
+
+    pub fn rumble(&self, left_speed: f64, right_speed: f64) {
+        self.rumbler.rumble(left_speed, right_speed);
+    }
+}
+
+impl From<GamepadHandle> for crate::event::device::GamepadHandle {
+    fn from(platform_id: GamepadHandle) -> Self {
+        Self(platform_id)
+    }
+}
+
+impl fmt::Debug for GamepadHandle {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        f.debug_tuple("GamepadHandle")
+            .field(&self.handle)
+            .finish()
+    }
+}
+
+impl Eq for GamepadHandle {}
+impl PartialEq for GamepadHandle {
+    #[inline(always)]
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl Ord for GamepadHandle {
+    #[inline(always)]
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.handle.cmp(&other.handle)
+    }
+}
+impl PartialOrd for GamepadHandle {
+    #[inline(always)]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.handle.partial_cmp(&other.handle)
+    }
+}
+
+impl Hash for GamepadHandle {
+    #[inline(always)]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.handle.hash(state);
+    }
+}

src/platform_impl/windows/raw_input.rs

@@ -673,9 +673,9 @@ impl RawGamepad {
             .collect()
     }
 
-    pub fn rumble(&mut self, _left_speed: u16, _right_speed: u16) {
-        // Even though I can't read German, this is still the most useful resource I found:
-        // https://zfx.info/viewtopic.php?t=3574&f=7
-        // I'm not optimistic about it being possible to implement this.
-    }
+    // pub fn rumble(&mut self, _left_speed: u16, _right_speed: u16) {
+    //     // Even though I can't read German, this is still the most useful resource I found:
+    //     // https://zfx.info/viewtopic.php?t=3574&f=7
+    //     // I'm not optimistic about it being possible to implement this.
+    // }
 }

src/platform_impl/windows/xinput.rs

@@ -1,4 +1,5 @@
 use std::mem;
+use std::rc::{Rc, Weak};
 
 use rusty_xinput::*;
 use winapi::shared::minwindef::{DWORD, WORD};
@@ -55,22 +56,31 @@ enum Side {
 
 #[derive(Debug)]
 pub struct XInputGamepad {
-    id: DWORD,
+    port: DWORD,
     prev_state: Option<XInputState>,
     state: Option<XInputState>,
+    rumbler: Rc<XInputGamepadRumbler>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct XInputGamepadRumbler {
+    port: DWORD,
 }
 
 impl XInputGamepad {
-    pub fn new(id: DWORD) -> Option<Self> {
+    pub fn new(port: DWORD) -> Option<Self> {
         XINPUT_GUARD.map(|_| XInputGamepad {
-            id,
+            port,
             prev_state: None,
             state: None,
+            rumbler: Rc::new(XInputGamepadRumbler {
+                port,
+            })
         })
     }
 
     pub fn update_state(&mut self) -> Option<()> {
-        let state = xinput_get_state(self.id).ok();
+        let state = xinput_get_state(self.port).ok();
         if state.is_some() {
             self.prev_state = mem::replace(&mut self.state, state);
             Some(())
@@ -218,8 +228,16 @@ impl XInputGamepad {
         events
     }
 
-    pub fn rumble(&mut self, left_speed: u16, right_speed: u16) {
+    pub fn rumbler(&self) -> Weak<XInputGamepadRumbler> {
+        Rc::downgrade(&self.rumbler)
+    }
+}
+
+impl XInputGamepadRumbler {
+    pub fn rumble(&self, left_speed: f64, right_speed: f64) {
+        let left_speed = (left_speed * u16::max_value() as f64) as u16;
+        let right_speed = (right_speed * u16::max_value() as f64) as u16;
         // TODO: We should probably return the status
-        let _ = xinput_set_state(self.id, left_speed, right_speed);
+        let _ = xinput_set_state(self.port, left_speed, right_speed);
     }
 }