Add winit phase to MouseWheel event

Author: liamaharon

crates/bevy_input/Cargo.toml

@@ -69,6 +69,7 @@ bevy_reflect = { path = "../bevy_reflect", version = "0.17.0-dev", features = [
 bevy_platform = { path = "../bevy_platform", version = "0.17.0-dev", default-features = false }
 
 # other
+winit = { version = "0.30", default-features = false, features = ["rwh_06"] }
 serde = { version = "1", features = [
   "alloc",
   "derive",

crates/bevy_input/src/mouse.rs

@@ -1,6 +1,6 @@
 //! The mouse input functionality.
 
-use crate::{ButtonInput, ButtonState};
+use crate::{touch::TouchPhase, ButtonInput, ButtonState};
 use bevy_ecs::{
     change_detection::DetectChangesMut,
     entity::Entity,
@@ -160,6 +160,8 @@ pub struct MouseWheel {
     pub y: f32,
     /// Window that received the input.
     pub window: Entity,
+    /// Phase of the wheel event.
+    pub phase: TouchPhase,
 }
 
 /// Updates the [`ButtonInput<MouseButton>`] resource with the latest [`MouseButtonInput`] events.

crates/bevy_input/src/touch.rs

@@ -127,11 +127,14 @@ pub enum ForceTouch {
     reflect(Serialize, Deserialize)
 )]
 pub enum TouchPhase {
-    /// A finger started to touch the touchscreen.
+    /// A finger started to touch the touchscreen or a wheel scroll started.
     Started,
-    /// A finger moved over the touchscreen.
+    /// A finger moved over the touchscreen or touchpad scroll is in progress.
+    ///
+    /// This can be used to detect whether a scroll action is taking place on a
+    /// mouse wheel or touchpad, because mouse wheel scrolls do not emit this event.
     Moved,
-    /// A finger stopped touching the touchscreen.
+    /// A finger stopped touching the touchscreen or a wheel scroll finished.
     Ended,
     /// The system canceled the tracking of the finger.
     ///
@@ -140,6 +143,17 @@ pub enum TouchPhase {
     Canceled,
 }
 
+impl From<winit::event::TouchPhase> for TouchPhase {
+    fn from(phase: winit::event::TouchPhase) -> TouchPhase {
+        match phase {
+            winit::event::TouchPhase::Started => TouchPhase::Started,
+            winit::event::TouchPhase::Moved => TouchPhase::Moved,
+            winit::event::TouchPhase::Ended => TouchPhase::Ended,
+            winit::event::TouchPhase::Cancelled => TouchPhase::Canceled,
+        }
+    }
+}
+
 /// A touch input.
 ///
 /// ## Usage

crates/bevy_picking/src/events.rs

@@ -40,7 +40,7 @@
 use core::{fmt::Debug, time::Duration};
 
 use bevy_ecs::{prelude::*, query::QueryData, system::SystemParam, traversal::Traversal};
-use bevy_input::mouse::MouseScrollUnit;
+use bevy_input::{mouse::MouseScrollUnit, touch::TouchPhase};
 use bevy_math::Vec2;
 use bevy_platform::collections::HashMap;
 use bevy_platform::time::Instant;
@@ -334,6 +334,8 @@ pub struct Scroll {
     pub y: f32,
     /// Information about the picking intersection.
     pub hit: HitData,
+    /// `TouchPhase` of the scroll.
+    pub phase: TouchPhase,
 }
 
 /// An entry in the cache that drives the `pointer_events` system, storing additional data
@@ -776,7 +778,7 @@ pub fn pointer_events(
                     event_writers.move_events.write(move_event);
                 }
             }
-            PointerAction::Scroll { x, y, unit } => {
+            PointerAction::Scroll { x, y, unit, phase } => {
                 for (hovered_entity, hit) in hover_map
                     .get(&pointer_id)
                     .iter()
@@ -791,6 +793,7 @@ pub fn pointer_events(
                             x,
                             y,
                             hit: hit.clone(),
+                            phase,
                         },
                     );
                     commands.trigger_targets(scroll_event.clone(), hovered_entity);

crates/bevy_picking/src/input.rs

@@ -174,7 +174,13 @@ pub fn mouse_pick_events(
                 pointer_events.write(PointerInput::new(PointerId::Mouse, location, action));
             }
             WindowEvent::MouseWheel(event) => {
-                let MouseWheel { unit, x, y, window } = *event;
+                let MouseWheel {
+                    unit,
+                    x,
+                    y,
+                    window,
+                    phase,
+                } = *event;
 
                 let location = Location {
                     target: match RenderTarget::Window(WindowRef::Entity(window))
@@ -186,7 +192,7 @@ pub fn mouse_pick_events(
                     position: *cursor_last,
                 };
 
-                let action = PointerAction::Scroll { x, y, unit };
+                let action = PointerAction::Scroll { x, y, unit, phase };
 
                 pointer_events.write(PointerInput::new(PointerId::Mouse, location, action));
             }

crates/bevy_picking/src/pointer.rs

@@ -9,7 +9,7 @@
 //! driven by lower-level input devices and consumed by higher-level interaction systems.
 
 use bevy_ecs::prelude::*;
-use bevy_input::mouse::MouseScrollUnit;
+use bevy_input::{mouse::MouseScrollUnit, touch::TouchPhase};
 use bevy_math::Vec2;
 use bevy_platform::collections::HashMap;
 use bevy_reflect::prelude::*;
@@ -263,6 +263,8 @@ pub enum PointerAction {
         x: f32,
         /// The vertical scroll value.
         y: f32,
+        /// The phase of the scroll.
+        phase: TouchPhase,
     },
     /// Cancel the pointer. Often used for touch events.
     Cancel,

crates/bevy_winit/src/converters.rs

@@ -2,7 +2,7 @@ use bevy_ecs::entity::Entity;
 use bevy_input::{
     keyboard::{KeyCode, KeyboardInput, NativeKeyCode},
     mouse::MouseButton,
-    touch::{ForceTouch, TouchInput, TouchPhase},
+    touch::{ForceTouch, TouchInput},
     ButtonState,
 };
 use bevy_math::{CompassOctant, Vec2};
@@ -51,12 +51,7 @@ pub fn convert_touch_input(
     window_entity: Entity,
 ) -> TouchInput {
     TouchInput {
-        phase: match touch_input.phase {
-            winit::event::TouchPhase::Started => TouchPhase::Started,
-            winit::event::TouchPhase::Moved => TouchPhase::Moved,
-            winit::event::TouchPhase::Ended => TouchPhase::Ended,
-            winit::event::TouchPhase::Cancelled => TouchPhase::Canceled,
-        },
+        phase: touch_input.phase.into(),
         position: Vec2::new(location.x as f32, location.y as f32),
         window: window_entity,
         force: touch_input.force.map(|f| match f {

crates/bevy_winit/src/state.rs

@@ -320,13 +320,14 @@ impl<T: BufferedEvent> ApplicationHandler<T> for WinitAppRunnerState<T> {
                             y: delta.y,
                         }));
                     }
-                    WindowEvent::MouseWheel { delta, .. } => match delta {
+                    WindowEvent::MouseWheel { delta, phase, .. } => match delta {
                         event::MouseScrollDelta::LineDelta(x, y) => {
                             self.bevy_window_events.send(MouseWheel {
                                 unit: MouseScrollUnit::Line,
                                 x,
                                 y,
                                 window,
+                                phase: phase.into(),
                             });
                         }
                         event::MouseScrollDelta::PixelDelta(p) => {
@@ -335,6 +336,7 @@ impl<T: BufferedEvent> ApplicationHandler<T> for WinitAppRunnerState<T> {
                                 x: p.x as f32,
                                 y: p.y as f32,
                                 window,
+                                phase: phase.into(),
                             });
                         }
                     },