Trackpad-specific input event support

src/gui/egui_gui.rs

@@ -187,6 +187,13 @@ impl GUI {
                             None
                         }
                     }
+                    Event::PinchGesture { delta, handled, .. } => {
+                        if !handled {
+                            Some(egui::Event::Zoom(delta.exp()))
+                        } else {
+                            None
+                        }
+                    }
                     _ => None,
                 })
                 .collect::<Vec<_>>(),
@@ -223,6 +230,16 @@ impl GUI {
                     } => {
                         *handled = true;
                     }
+                    Event::PinchGesture {
+                        ref mut handled, ..
+                    } => {
+                        *handled = true;
+                    }
+                    Event::RotationGesture {
+                        ref mut handled, ..
+                    } => {
+                        *handled = true;
+                    }
                     _ => {}
                 }
             }

src/renderer/control.rs

@@ -24,6 +24,8 @@ pub use fly_control::*;
 
 pub use three_d_asset::PixelPoint as PhysicalPoint;
 
+use three_d_asset::Radians;
+
 /// Type of mouse button.
 #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Hash)]
 pub enum MouseButton {
@@ -84,6 +86,28 @@ pub enum Event {
         /// Whether or not this event already have been handled.
         handled: bool,
     },
+    /// Fired continuously when a pinch input gesture is recognized, such as on a Mac trackpad
+    PinchGesture {
+        /// The relative pinching since the last [Event::PinchGesture] event (positive is zoom in).
+        delta: f32,
+        /// The screen position in physical pixels.
+        position: PhysicalPoint,
+        /// The state of modifiers.
+        modifiers: Modifiers,
+        /// Whether or not this event already have been handled.
+        handled: bool,
+    },
+    /// Fired continuously when a rotation input gesture is recognized, such as on a Mac trackpad
+    RotationGesture {
+        /// The relative rotation since the last [Event::RotationGesture] event (positive is counterclockwise).
+        delta: Radians,
+        /// The screen position in physical pixels.
+        position: PhysicalPoint,
+        /// The state of modifiers.
+        modifiers: Modifiers,
+        /// Whether or not this event already have been handled.
+        handled: bool,
+    },
     /// Fired when the mouse enters the window.
     MouseEnter,
     /// Fired when the mouse leaves the window.

src/renderer/control/camera_control.rs

@@ -168,6 +168,10 @@ pub struct CameraControl {
     pub scroll_horizontal: CameraAction,
     /// Specifies what happens when scrolling vertically.
     pub scroll_vertical: CameraAction,
+    /// Specifies what happens when pinching on a gesture-capable device
+    pub pinch: CameraAction,
+    /// Specifies what happens when rotating on a gesture-capable device
+    pub rotate: CameraAction,
 }
 
 impl CameraControl {
@@ -216,6 +220,20 @@ impl CameraControl {
                         change |= *handled;
                     }
                 }
+                Event::PinchGesture { delta, handled, .. } => {
+                    if !*handled {
+                        self.pinch.apply(camera, *delta);
+                        *handled = self.pinch.is_some();
+                        change |= *handled;
+                    }
+                }
+                Event::RotationGesture { delta, handled, .. } => {
+                    if !*handled {
+                        self.rotate.apply(camera, delta.0);
+                        *handled = self.rotate.is_some();
+                        change |= *handled;
+                    }
+                }
                 _ => {}
             }
         }

src/renderer/control/free_orbit_control.rs

@@ -20,6 +20,12 @@ impl FreeOrbitControl {
                     speed: 0.1,
                     target,
                 },
+                pinch: CameraAction::Zoom {
+                    min: min_distance,
+                    max: max_distance,
+                    speed: 0.1,
+                    target,
+                },
                 ..Default::default()
             },
         }
@@ -41,6 +47,10 @@ impl FreeOrbitControl {
             let x = target.distance(*camera.position());
             *speed = 0.01 * x + 0.001;
         }
+        if let CameraAction::Zoom { target, speed, .. } = &mut self.control.pinch {
+            let x = target.distance(*camera.position());
+            *speed = x + 0.1;
+        }
         self.control.handle_events(camera, events)
     }
 }

src/renderer/control/orbit_control.rs

@@ -20,6 +20,12 @@ impl OrbitControl {
                     speed: 0.1,
                     target,
                 },
+                pinch: CameraAction::Zoom {
+                    min: min_distance,
+                    max: max_distance,
+                    speed: 0.1,
+                    target,
+                },
                 ..Default::default()
             },
         }
@@ -39,6 +45,10 @@ impl OrbitControl {
             let x = target.distance(*camera.position());
             *speed = 0.01 * x + 0.001;
         }
+        if let CameraAction::Zoom { target, speed, .. } = &mut self.control.pinch {
+            let x = target.distance(*camera.position());
+            *speed = x + 0.1;
+        }
         self.control.handle_events(camera, events)
     }
 }

src/window/winit_window/frame_input_generator.rs

@@ -211,6 +211,30 @@ impl FrameInputGenerator {
                     }
                 }
             }
+            WindowEvent::TouchpadMagnify { delta, .. } => {
+                // Renamed to PinchGesture in winit 0.30.0
+                if let Some(position) = self.cursor_pos {
+                    let d = *delta as f32;
+                    self.events.push(crate::Event::PinchGesture {
+                        delta: d,
+                        position: position.into(),
+                        modifiers: self.modifiers,
+                        handled: false,
+                    });
+                }
+            }
+            WindowEvent::TouchpadRotate { delta, .. } => {
+                // Renamed to RotationGesture in winit 0.30.0
+                if let Some(position) = self.cursor_pos {
+                    let d = radians(*delta);
+                    self.events.push(crate::Event::RotationGesture {
+                        delta: d,
+                        position: position.into(),
+                        modifiers: self.modifiers,
+                        handled: false,
+                    });
+                }
+            }
             WindowEvent::MouseInput { state, button, .. } => {
                 if let Some(position) = self.cursor_pos {
                     let button = match button {