split off camera code into separate camera module

src/camera.rs

@@ -0,0 +1,215 @@
+use bevy::prelude::*;
+use bevy::input::mouse::MouseMotion;
+use bevy::window::{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;
+            *toggle_cursor_grab = 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);
+        }
+    }
+}

src/main.rs

@@ -1,4 +1,5 @@
 mod audio;
+mod camera;
 
 use bevy::{
     asset::LoadState,
@@ -6,6 +7,7 @@ use bevy::{
         Window,
         WindowMode,
         PrimaryWindow,
+        CursorGrabMode,
     },
     core_pipeline::Skybox,
     prelude::*,
@@ -28,7 +30,7 @@ fn main() {
                 audio::toggle_bgm,
         ))
         .add_plugins(DefaultPlugins.set(ImagePlugin::default_nearest()))
-        .add_plugins(CameraControllerPlugin)
+        .add_plugins(camera::CameraControllerPlugin)
         .run();
 }
 
@@ -65,7 +67,7 @@ fn setup(
             transform: Transform::from_xyz(0.0, 0.0, 8.0).looking_at(Vec3::ZERO, Vec3::Y),
             ..default()
         },
-        CameraController::default(),
+        camera::CameraController::default(),
         Skybox {
             image: skybox_handle.clone(),
             brightness: 150.0,
@@ -141,222 +143,3 @@ 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;
-            *toggle_cursor_grab = 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);
-        }
-    }
-}