From 43004caffc9619697f92202961c40d6224ddac11 Mon Sep 17 00:00:00 2001
From: hut <hut@hut.pm>
Date: Sat, 16 Mar 2024 16:35:48 +0100
Subject: [PATCH] add mouse-based camera controls

---
 src/main.rs | 220 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 220 insertions(+)

diff --git a/src/main.rs b/src/main.rs
index 2b18f0d..af04f75 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -17,6 +17,7 @@ fn main() {
                 handle_input
         ))
         .add_plugins(DefaultPlugins.set(ImagePlugin::default_nearest()))
+        .add_plugins(CameraControllerPlugin)
         .run();
 }
 
@@ -42,6 +43,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
             transform: Transform::from_xyz(0.0, 0.0, 8.0).looking_at(Vec3::ZERO, Vec3::Y),
             ..default()
         },
+        CameraController::default(),
         Skybox {
             image: skybox_handle.clone(),
             brightness: 150.0,
@@ -117,3 +119,221 @@ fn handle_input(
         app_exit_events.send(bevy::app::AppExit);
     }
 }
+
+
+// ------------------------------------------------------------------------------
+// --------- copy&pasted from bevy's helpers/camera_controller.rs ---------------
+// ------------------------------------------------------------------------------
+use bevy::input::mouse::MouseMotion;
+use bevy::window::CursorGrabMode;
+use std::{f32::consts::*, fmt};
+
+pub struct CameraControllerPlugin;
+
+impl Plugin for CameraControllerPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Update, run_camera_controller);
+    }
+}
+
+/// Based on Valorant's default sensitivity, not entirely sure why it is exactly 1.0 / 180.0,
+/// but I'm guessing it is a misunderstanding between degrees/radians and then sticking with
+/// it because it felt nice.
+pub const RADIANS_PER_DOT: f32 = 1.0 / 180.0 * 0.5;
+
+#[derive(Component)]
+pub struct CameraController {
+    pub enabled: bool,
+    pub initialized: bool,
+    pub sensitivity: f32,
+    pub key_forward: KeyCode,
+    pub key_back: KeyCode,
+    pub key_left: KeyCode,
+    pub key_right: KeyCode,
+    pub key_up: KeyCode,
+    pub key_down: KeyCode,
+    pub key_run: KeyCode,
+    pub mouse_key_cursor_grab: MouseButton,
+    pub keyboard_key_toggle_cursor_grab: KeyCode,
+    pub walk_speed: f32,
+    pub run_speed: f32,
+    pub friction: f32,
+    pub pitch: f32,
+    pub yaw: f32,
+    pub velocity: Vec3,
+}
+
+impl Default for CameraController {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            initialized: false,
+            sensitivity: 1.0,
+            key_forward: KeyCode::KeyW,
+            key_back: KeyCode::KeyS,
+            key_left: KeyCode::KeyA,
+            key_right: KeyCode::KeyD,
+            key_up: KeyCode::KeyE,
+            key_down: KeyCode::KeyQ,
+            key_run: KeyCode::ShiftLeft,
+            mouse_key_cursor_grab: MouseButton::Left,
+            keyboard_key_toggle_cursor_grab: KeyCode::KeyM,
+            walk_speed: 5.0,
+            run_speed: 15.0,
+            friction: 0.5,
+            pitch: 0.0,
+            yaw: 0.0,
+            velocity: Vec3::ZERO,
+        }
+    }
+}
+
+impl fmt::Display for CameraController {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "
+Freecam Controls:
+    Mouse\t- Move camera orientation
+    {:?}\t- Hold to grab cursor
+    {:?}\t- Toggle cursor grab
+    {:?} & {:?}\t- Fly forward & backwards
+    {:?} & {:?}\t- Fly sideways left & right
+    {:?} & {:?}\t- Fly up & down
+    {:?}\t- Fly faster while held",
+            self.mouse_key_cursor_grab,
+            self.keyboard_key_toggle_cursor_grab,
+            self.key_forward,
+            self.key_back,
+            self.key_left,
+            self.key_right,
+            self.key_up,
+            self.key_down,
+            self.key_run,
+        )
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn run_camera_controller(
+    time: Res<Time>,
+    mut windows: Query<&mut Window>,
+    mut mouse_events: EventReader<MouseMotion>,
+    mouse_button_input: Res<ButtonInput<MouseButton>>,
+    key_input: Res<ButtonInput<KeyCode>>,
+    mut toggle_cursor_grab: Local<bool>,
+    mut mouse_cursor_grab: Local<bool>,
+    mut query: Query<(&mut Transform, &mut CameraController), With<Camera>>,
+) {
+    let dt = time.delta_seconds();
+
+    if let Ok((mut transform, mut controller)) = query.get_single_mut() {
+        if !controller.initialized {
+            let (yaw, pitch, _roll) = transform.rotation.to_euler(EulerRot::YXZ);
+            controller.yaw = yaw;
+            controller.pitch = pitch;
+            controller.initialized = true;
+            info!("{}", *controller);
+        }
+        if !controller.enabled {
+            mouse_events.clear();
+            return;
+        }
+
+        // Handle key input
+        let mut axis_input = Vec3::ZERO;
+        if key_input.pressed(controller.key_forward) {
+            axis_input.z += 1.0;
+        }
+        if key_input.pressed(controller.key_back) {
+            axis_input.z -= 1.0;
+        }
+        if key_input.pressed(controller.key_right) {
+            axis_input.x += 1.0;
+        }
+        if key_input.pressed(controller.key_left) {
+            axis_input.x -= 1.0;
+        }
+        if key_input.pressed(controller.key_up) {
+            axis_input.y += 1.0;
+        }
+        if key_input.pressed(controller.key_down) {
+            axis_input.y -= 1.0;
+        }
+
+        let mut cursor_grab_change = false;
+        if key_input.just_pressed(controller.keyboard_key_toggle_cursor_grab) {
+            *toggle_cursor_grab = !*toggle_cursor_grab;
+            cursor_grab_change = true;
+        }
+        if mouse_button_input.just_pressed(controller.mouse_key_cursor_grab) {
+            *mouse_cursor_grab = true;
+            cursor_grab_change = true;
+        }
+        if mouse_button_input.just_released(controller.mouse_key_cursor_grab) {
+            *mouse_cursor_grab = false;
+            cursor_grab_change = true;
+        }
+        let cursor_grab = *mouse_cursor_grab || *toggle_cursor_grab;
+
+        // Apply movement update
+        if axis_input != Vec3::ZERO {
+            let max_speed = if key_input.pressed(controller.key_run) {
+                controller.run_speed
+            } else {
+                controller.walk_speed
+            };
+            controller.velocity = axis_input.normalize() * max_speed;
+        } else {
+            let friction = controller.friction.clamp(0.0, 1.0);
+            controller.velocity *= 1.0 - friction;
+            if controller.velocity.length_squared() < 1e-6 {
+                controller.velocity = Vec3::ZERO;
+            }
+        }
+        let forward = *transform.forward();
+        let right = *transform.right();
+        transform.translation += controller.velocity.x * dt * right
+            + controller.velocity.y * dt * Vec3::Y
+            + controller.velocity.z * dt * forward;
+
+        // Handle cursor grab
+        if cursor_grab_change {
+            if cursor_grab {
+                for mut window in &mut windows {
+                    if !window.focused {
+                        continue;
+                    }
+
+                    window.cursor.grab_mode = CursorGrabMode::Locked;
+                    window.cursor.visible = false;
+                }
+            } else {
+                for mut window in &mut windows {
+                    window.cursor.grab_mode = CursorGrabMode::None;
+                    window.cursor.visible = true;
+                }
+            }
+        }
+
+        // Handle mouse input
+        let mut mouse_delta = Vec2::ZERO;
+        if cursor_grab {
+            for mouse_event in mouse_events.read() {
+                mouse_delta += mouse_event.delta;
+            }
+        } else {
+            mouse_events.clear();
+        }
+
+        if mouse_delta != Vec2::ZERO {
+            // Apply look update
+            controller.pitch = (controller.pitch
+                - mouse_delta.y * RADIANS_PER_DOT * controller.sensitivity)
+                .clamp(-PI / 2., PI / 2.);
+            controller.yaw -= mouse_delta.x * RADIANS_PER_DOT * controller.sensitivity;
+            transform.rotation =
+                Quat::from_euler(EulerRot::ZYX, 0.0, controller.yaw, controller.pitch);
+        }
+    }
+}