rename touchpad to gesture, and add new gestures

crates/bevy_input/src/gestures.rs

@@ -0,0 +1,73 @@
+//! Gestures functionnality, from touchscreens and touchpads.
+
+use bevy_ecs::event::Event;
+use bevy_math::Vec2;
+use bevy_reflect::Reflect;
+
+#[cfg(feature = "serialize")]
+use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
+
+/// Two-finger pinch gesture, often used for magnifications.
+///
+/// Positive delta values indicate magnification (zooming in) and
+/// negative delta values indicate shrinking (zooming out).
+///
+/// ## Platform-specific
+///
+/// - Only available on **`macOS`** and **`iOS`**.
+/// - On **`iOS`**, must be enabled first
+#[derive(Event, Debug, Clone, Copy, PartialEq, Reflect)]
+#[reflect(Debug, PartialEq)]
+#[cfg_attr(
+    feature = "serialize",
+    derive(serde::Serialize, serde::Deserialize),
+    reflect(Serialize, Deserialize)
+)]
+pub struct PinchGesture(pub f32);
+
+/// Two-finger rotation gesture.
+///
+/// Positive delta values indicate rotation counterclockwise and
+/// negative delta values indicate rotation clockwise.
+///
+/// ## Platform-specific
+///
+/// - Only available on **`macOS`** and **`iOS`**.
+/// - On **`iOS`**, must be enabled first
+#[derive(Event, Debug, Clone, Copy, PartialEq, Reflect)]
+#[reflect(Debug, PartialEq)]
+#[cfg_attr(
+    feature = "serialize",
+    derive(serde::Serialize, serde::Deserialize),
+    reflect(Serialize, Deserialize)
+)]
+pub struct RotationGesture(pub f32);
+
+/// Double tap gesture.
+///
+/// ## Platform-specific
+///
+/// - Only available on **`macOS`** and **`iOS`**.
+/// - On **`iOS`**, must be enabled first
+#[derive(Event, Debug, Clone, Copy, PartialEq, Reflect)]
+#[reflect(Debug, PartialEq)]
+#[cfg_attr(
+    feature = "serialize",
+    derive(serde::Serialize, serde::Deserialize),
+    reflect(Serialize, Deserialize)
+)]
+pub struct DoubleTapGesture;
+
+/// Pan gesture.
+///
+/// ## Platform-specific
+///
+/// - On **`iOS`**, must be enabled first
+#[derive(Event, Debug, Clone, Copy, PartialEq, Reflect)]
+#[reflect(Debug, PartialEq)]
+#[cfg_attr(
+    feature = "serialize",
+    derive(serde::Serialize, serde::Deserialize),
+    reflect(Serialize, Deserialize)
+)]
+pub struct PanGesture(pub Vec2);

crates/bevy_input/src/lib.rs

@@ -16,10 +16,10 @@ mod button_input;
 /// Common run conditions
 pub mod common_conditions;
 pub mod gamepad;
+pub mod gestures;
 pub mod keyboard;
 pub mod mouse;
 pub mod touch;
-pub mod touchpad;
 
 pub use axis::*;
 pub use button_input::*;
@@ -41,10 +41,10 @@ pub mod prelude {
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_reflect::Reflect;
+use gestures::*;
 use keyboard::{keyboard_input_system, KeyCode, KeyboardInput};
 use mouse::{mouse_button_input_system, MouseButton, MouseButtonInput, MouseMotion, MouseWheel};
 use touch::{touch_screen_input_system, TouchInput, Touches};
-use touchpad::{TouchpadMagnify, TouchpadRotate};
 
 use gamepad::{
     gamepad_axis_event_system, gamepad_button_event_system, gamepad_connection_system,
@@ -77,8 +77,10 @@ impl Plugin for InputPlugin {
             .add_event::<MouseWheel>()
             .init_resource::<ButtonInput<MouseButton>>()
             .add_systems(PreUpdate, mouse_button_input_system.in_set(InputSystem))
-            .add_event::<TouchpadMagnify>()
-            .add_event::<TouchpadRotate>()
+            .add_event::<PinchGesture>()
+            .add_event::<RotationGesture>()
+            .add_event::<DoubleTapGesture>()
+            .add_event::<PanGesture>()
             // gamepad
             .add_event::<GamepadConnectionEvent>()
             .add_event::<GamepadButtonChangedEvent>()
@@ -114,8 +116,10 @@ impl Plugin for InputPlugin {
         app.register_type::<ButtonState>()
             .register_type::<KeyboardInput>()
             .register_type::<MouseButtonInput>()
-            .register_type::<TouchpadMagnify>()
-            .register_type::<TouchpadRotate>()
+            .register_type::<PinchGesture>()
+            .register_type::<RotationGesture>()
+            .register_type::<DoubleTapGesture>()
+            .register_type::<PanGesture>()
             .register_type::<TouchInput>()
             .register_type::<GamepadEvent>()
             .register_type::<GamepadButtonInput>()

crates/bevy_window/src/window.rs

@@ -281,6 +281,33 @@
     /// [`wgpu::SurfaceConfiguration::desired_maximum_frame_latency`]:
     /// https://docs.rs/wgpu/latest/wgpu/type.SurfaceConfiguration.html#structfield.desired_maximum_frame_latency
     pub desired_maximum_frame_latency: Option<NonZeroU32>,
+    /// Sets wether this window recognize [`PinchGesture`]
+    ///
+    /// ## Platform-specific
+    ///
+    /// - Only used on iOS.
+    /// - On macOS, they are recognized by default and can't be disabled.
+    pub recognize_pinch_gesture: bool,
+    /// Sets wether this window recognize [`RotationGesture`]
+    ///
+    /// ## Platform-specific
+    ///
+    /// - Only used on iOS.
+    /// - On macOS, they are recognized by default and can't be disabled.
+    pub recognize_rotation_gesture: bool,
+    /// Sets wether this window recognize [`DoubleTapGesture`]
+    ///
+    /// ## Platform-specific
+    ///
+    /// - Only used on iOS.
+    /// - On macOS, they are recognized by default and can't be disabled.
+    pub recognize_doubletap_gesture: bool,
+    /// Sets wether this window recognize [`PanGesture`], with a number of fingers between the first value and the last.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - Only used on iOS.
+    pub recognize_pan_gesture: Option<(u8, u8)>,
 }
 
 impl Default for Window {
@@ -311,6 +338,10 @@
             visible: true,
             skip_taskbar: false,
             desired_maximum_frame_latency: None,
+            recognize_pinch_gesture: false,
+            recognize_rotation_gesture: false,
+            recognize_doubletap_gesture: false,
+            recognize_pan_gesture: None,
         }
     }
 }

crates/bevy_winit/src/state.rs

@@ -7,8 +7,8 @@ use bevy_ecs::prelude::*;
 use bevy_ecs::system::SystemState;
 use bevy_ecs::world::FromWorld;
 use bevy_input::{
+    gestures::*,
     mouse::{MouseButtonInput, MouseMotion, MouseScrollUnit, MouseWheel},
-    touchpad::{TouchpadMagnify, TouchpadRotate},
 };
 use bevy_log::{error, trace, warn};
 use bevy_math::{ivec2, DVec2, Vec2};
@@ -264,10 +264,19 @@ impl<T: Event> ApplicationHandler<T> for WinitAppRunnerState<T> {
                 });
             }
             WindowEvent::PinchGesture { delta, .. } => {
-                self.winit_events.send(TouchpadMagnify(delta as f32));
+                self.winit_events.send(PinchGesture(delta as f32));
             }
             WindowEvent::RotationGesture { delta, .. } => {
-                self.winit_events.send(TouchpadRotate(delta));
+                self.winit_events.send(RotationGesture(delta));
+            }
+            WindowEvent::DoubleTapGesture { .. } => {
+                self.winit_events.send(DoubleTapGesture);
+            }
+            WindowEvent::PanGesture { delta, .. } => {
+                self.winit_events.send(PanGesture(Vec2 {
+                    x: delta.x,
+                    y: delta.y,
+                }));
             }
             WindowEvent::MouseWheel { delta, .. } => match delta {
                 event::MouseScrollDelta::LineDelta(x, y) => {
@@ -674,10 +683,16 @@ impl<T: Event> WinitAppRunnerState<T> {
                 WinitEvent::MouseWheel(e) => {
                     world.send_event(e);
                 }
-                WinitEvent::TouchpadMagnify(e) => {
+                WinitEvent::PinchGesture(e) => {
+                    world.send_event(e);
+                }
+                WinitEvent::RotationGesture(e) => {
+                    world.send_event(e);
+                }
+                WinitEvent::DoubleTapGesture(e) => {
                     world.send_event(e);
                 }
-                WinitEvent::TouchpadRotate(e) => {
+                WinitEvent::PanGesture(e) => {
                     world.send_event(e);
                 }
                 WinitEvent::TouchInput(e) => {

crates/bevy_winit/src/system.rs

@@ -16,6 +16,8 @@ use winit::dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize};
 use winit::event_loop::ActiveEventLoop;
 
 use bevy_ecs::query::With;
+#[cfg(target_os = "ios")]
+use winit::platform::ios::WindowExtIOS;
 #[cfg(target_arch = "wasm32")]
 use winit::platform::web::WindowExtWebSys;
 
@@ -97,6 +99,19 @@ pub fn create_windows<F: QueryFilter + 'static>(
                 style.set_property("height", "100%").unwrap();
             }
         }
+
+        #[cfg(target_os = "ios")]
+        {
+            winit_window.recognize_pinch_gesture(window.recognize_pinch_gesture);
+            winit_window.recognize_rotation_gesture(window.recognize_rotation_gesture);
+            winit_window.recognize_doubletap_gesture(window.recognize_doubletap_gesture);
+            if let Some((min, max)) = window.recognize_pan_gesture {
+                winit_window.recognize_pan_gesture(true, min, max);
+            } else {
+                winit_window.recognize_pan_gesture(false, 0, 0);
+            }
+        }
+
         window_created_events.send(WindowCreated { window: entity });
     }
 }
@@ -360,6 +375,31 @@ pub(crate) fn changed_windows(
             winit_window.set_visible(window.visible);
         }
 
+        #[cfg(target_os = "ios")]
+        {
+            if window.recognize_pinch_gesture != cache.window.recognize_pinch_gesture {
+                winit_window.recognize_pinch_gesture(window.recognize_pinch_gesture);
+            }
+            if window.recognize_rotation_gesture != cache.window.recognize_rotation_gesture {
+                winit_window.recognize_rotation_gesture(window.recognize_rotation_gesture);
+            }
+            if window.recognize_doubletap_gesture != cache.window.recognize_doubletap_gesture {
+                winit_window.recognize_doubletap_gesture(window.recognize_doubletap_gesture);
+            }
+            if window.recognize_pan_gesture != cache.window.recognize_pan_gesture {
+                match (
+                    window.recognize_pan_gesture,
+                    cache.window.recognize_pan_gesture,
+                ) {
+                    (Some(_), Some(_)) => {
+                        warn!("Bevy currently doesn't support modifying PanGesture number of fingers recognition. Please disable it before re-enabling it with the new number of fingers");
+                    }
+                    (Some((min, max)), _) => winit_window.recognize_pan_gesture(true, min, max),
+                    _ => winit_window.recognize_pan_gesture(false, 0, 0),
+                }
+            }
+        }
+
         cache.window = window.clone();
     }
 }

crates/bevy_winit/src/winit_event.rs

@@ -5,8 +5,8 @@ use bevy_ecs::prelude::*;
 use bevy_input::keyboard::KeyboardInput;
 use bevy_input::touch::TouchInput;
 use bevy_input::{
+    gestures::*,
     mouse::{MouseButtonInput, MouseMotion, MouseWheel},
-    touchpad::{TouchpadMagnify, TouchpadRotate},
 };
 use bevy_reflect::Reflect;
 #[cfg(feature = "serialize")]
@@ -55,8 +55,10 @@ pub enum WinitEvent {
     MouseMotion(MouseMotion),
     MouseWheel(MouseWheel),
 
-    TouchpadMagnify(TouchpadMagnify),
-    TouchpadRotate(TouchpadRotate),
+    PinchGesture(PinchGesture),
+    RotationGesture(RotationGesture),
+    DoubleTapGesture(DoubleTapGesture),
+    PanGesture(PanGesture),
 
     TouchInput(TouchInput),
 
@@ -168,14 +170,24 @@ impl From<MouseWheel> for WinitEvent {
         Self::MouseWheel(e)
     }
 }
-impl From<TouchpadMagnify> for WinitEvent {
-    fn from(e: TouchpadMagnify) -> Self {
-        Self::TouchpadMagnify(e)
+impl From<PinchGesture> for WinitEvent {
+    fn from(e: PinchGesture) -> Self {
+        Self::PinchGesture(e)
     }
 }
-impl From<TouchpadRotate> for WinitEvent {
-    fn from(e: TouchpadRotate) -> Self {
-        Self::TouchpadRotate(e)
+impl From<RotationGesture> for WinitEvent {
+    fn from(e: RotationGesture) -> Self {
+        Self::RotationGesture(e)
+    }
+}
+impl From<DoubleTapGesture> for WinitEvent {
+    fn from(e: DoubleTapGesture) -> Self {
+        Self::DoubleTapGesture(e)
+    }
+}
+impl From<PanGesture> for WinitEvent {
+    fn from(e: PanGesture) -> Self {
+        Self::PanGesture(e)
     }
 }
 impl From<TouchInput> for WinitEvent {