feat(input): add touch controls

Author: matthewjberger

crates/nightshade/src/ecs/camera/systems.rs

@@ -42,11 +42,93 @@ pub fn update_camera_aspect_ratios(world: &mut World) {
 }
 
 pub fn fly_camera_system(world: &mut World) {
+    touch_camera_system(world);
     look_camera_system(world);
     wasd_keyboard_controls_system(world);
     gamepad_fly_camera_system(world);
 }
 
+fn touch_camera_system(world: &mut World) {
+    let Some(camera_entity) = world.resources.active_camera else {
+        return;
+    };
+
+    let delta_time = world.resources.window.timing.delta_time;
+
+    let (right, up) = {
+        let Some(local_transform) = world.get_local_transform(camera_entity) else {
+            return;
+        };
+        (local_transform.right_vector(), local_transform.up_vector())
+    };
+
+    let touch_count = world.resources.input.touch.touch_count;
+
+    if touch_count == 1 {
+        let raw_delta = world.resources.input.touch.single_finger_delta;
+
+        if raw_delta.magnitude() > 0.0 {
+            let Some(camera) = world.get_camera_mut(camera_entity) else {
+                return;
+            };
+            let Some(smoothing) = camera.smoothing.as_mut() else {
+                return;
+            };
+
+            let smoothing_factor = 1.0 - (-delta_time * smoothing.mouse_responsiveness).exp();
+            smoothing.smoothed_mouse_delta = smoothing.smoothed_mouse_delta * (1.0 - smoothing_factor)
+                + raw_delta * smoothing_factor;
+
+            let pixels_to_radians = (std::f32::consts::PI / 1000.0) * smoothing.mouse_dpi_scale;
+            let mut delta =
+                smoothing.smoothed_mouse_delta * smoothing.mouse_sensitivity * pixels_to_radians;
+            delta.x *= -1.0;
+            delta.y *= -1.0;
+
+            let Some(local_transform) = world.get_local_transform_mut(camera_entity) else {
+                return;
+            };
+
+            let yaw = nalgebra_glm::quat_angle_axis(delta.x, &Vec3::y());
+            local_transform.rotation = yaw * local_transform.rotation;
+
+            let forward = local_transform.forward_vector();
+            let current_pitch = forward.y.asin();
+
+            let new_pitch = current_pitch + delta.y;
+            if new_pitch.abs() <= 89_f32.to_radians() {
+                let pitch = nalgebra_glm::quat_angle_axis(delta.y, &Vec3::x());
+                local_transform.rotation *= pitch;
+            }
+
+            mark_local_transform_dirty(world, camera_entity);
+        }
+    } else if touch_count == 2 {
+        let mut delta =
+            world.resources.input.touch.two_finger_delta * world.resources.window.timing.delta_time;
+        delta.x *= -1.0;
+        delta.y *= -1.0;
+
+        if delta.magnitude() > 0.0 {
+            let Some(local_transform) = world.get_local_transform_mut(camera_entity) else {
+                return;
+            };
+            let translation_right = right * delta.x;
+            let translation_up = up * delta.y;
+
+            local_transform.translation += translation_right;
+            local_transform.translation += translation_up;
+
+            let changed = translation_right.magnitude() > 0.0 || translation_up.magnitude() > 0.0;
+            if changed {
+                mark_local_transform_dirty(world, camera_entity);
+            }
+        }
+    }
+
+    world.resources.input.touch.reset();
+}
+
 fn look_camera_system(world: &mut World) {
     let Some(camera_entity) = world.resources.active_camera else {
         return;

crates/nightshade/src/ecs/input/resources.rs

@@ -1,14 +1,17 @@
 pub mod gamepad;
 pub mod keyboard;
 pub mod mouse;
+pub mod touch;
 
 pub use gamepad::*;
 pub use keyboard::*;
 pub use mouse::*;
+pub use touch::*;
 
 #[derive(Default)]
 pub struct Input {
     pub keyboard: Keyboard,
     pub mouse: Mouse,
     pub gamepad: Gamepad,
+    pub touch: Touch,
 }

crates/nightshade/src/ecs/input/resources/touch.rs

@@ -0,0 +1,50 @@
+use crate::ecs::world::Vec2;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct TouchPoint {
+    pub id: u64,
+    pub position: Vec2,
+}
+
+#[derive(Default)]
+pub struct Touch {
+    pub active_touches: Vec<TouchPoint>,
+    pub previous_touches: Vec<TouchPoint>,
+    pub single_finger_delta: Vec2,
+    pub two_finger_delta: Vec2,
+    pub touch_count: usize,
+}
+
+impl Touch {
+    pub fn update_delta(&mut self) {
+        self.single_finger_delta = Vec2::zeros();
+        self.two_finger_delta = Vec2::zeros();
+
+        if self.active_touches.len() == 1 && self.previous_touches.len() == 1 {
+            if self.active_touches[0].id == self.previous_touches[0].id {
+                self.single_finger_delta =
+                    self.active_touches[0].position - self.previous_touches[0].position;
+            }
+        } else if self.active_touches.len() == 2 && self.previous_touches.len() == 2 {
+            let current_center = (self.active_touches[0].position + self.active_touches[1].position) / 2.0;
+            let previous_center = (self.previous_touches[0].position + self.previous_touches[1].position) / 2.0;
+            self.two_finger_delta = current_center - previous_center;
+        }
+
+        self.touch_count = self.active_touches.len();
+    }
+
+    pub fn reset(&mut self) {
+        self.previous_touches = self.active_touches.clone();
+        self.single_finger_delta = Vec2::zeros();
+        self.two_finger_delta = Vec2::zeros();
+    }
+
+    pub fn clear(&mut self) {
+        self.active_touches.clear();
+        self.previous_touches.clear();
+        self.single_finger_delta = Vec2::zeros();
+        self.two_finger_delta = Vec2::zeros();
+        self.touch_count = 0;
+    }
+}

crates/nightshade/src/run.rs

@@ -180,6 +180,29 @@ fn input_event_system(world: &mut World, window_event: &WindowEvent) {
             mouse.wheel_delta = Vec2::new(*h_lines, *v_lines);
             mouse.state.set(MouseState::SCROLLED, true);
         }
+        winit::event::WindowEvent::Touch(touch_event) => {
+            use crate::ecs::input::TouchPoint;
+            let touch = &mut world.resources.input.touch;
+
+            match touch_event.phase {
+                winit::event::TouchPhase::Started => {
+                    touch.active_touches.push(TouchPoint {
+                        id: touch_event.id,
+                        position: Vec2::new(touch_event.location.x as f32, touch_event.location.y as f32),
+                    });
+                }
+                winit::event::TouchPhase::Moved => {
+                    if let Some(existing) = touch.active_touches.iter_mut().find(|t| t.id == touch_event.id) {
+                        existing.position = Vec2::new(touch_event.location.x as f32, touch_event.location.y as f32);
+                    }
+                }
+                winit::event::TouchPhase::Ended | winit::event::TouchPhase::Cancelled => {
+                    touch.active_touches.retain(|t| t.id != touch_event.id);
+                }
+            }
+
+            touch.update_delta();
+        }
         _ => {}
     }
 }