From 0e5e5b8a42450cf156e16be6123ab7c01d3922c6 Mon Sep 17 00:00:00 2001
From: Toniman575 <toniman575@gmail.com>
Date: Thu, 15 Aug 2024 12:58:45 +0200
Subject: [PATCH 1/4] Added keyboard movement

---
 src/lib.rs | 129 ++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 113 insertions(+), 16 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 1d61a43..2f6cd42 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -21,13 +21,34 @@ pub struct PanCamPlugin;
 #[derive(Debug, Clone, Copy, SystemSet, PartialEq, Eq, Hash)]
 pub struct PanCamSystemSet;
 
+/// How the camera is moved.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Reflect, Default)]
+pub enum MoveMode {
+    #[default]
+    /// Camera is moved through only the mouse.
+    Mouse,
+    /// Camera is moved through only the keyboard.
+    Keyboard,
+}
+
+/// Which keys move the camera in particular directions for keyboard movement.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Reflect)]
+pub struct DirectionKeys {
+    up: Vec<KeyCode>,
+    down: Vec<KeyCode>,
+    left: Vec<KeyCode>,
+    right: Vec<KeyCode>,
+}
+
 impl Plugin for PanCamPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(
             Update,
             (do_camera_movement, do_camera_zoom).in_set(PanCamSystemSet),
         )
-        .register_type::<PanCam>();
+        .register_type::<PanCam>()
+        .register_type::<MoveMode>()
+        .register_type::<DirectionKeys>();
 
         #[cfg(feature = "bevy_egui")]
         {
@@ -179,8 +200,10 @@ fn clamp_to_safe_zone(pos: Vec2, aabb: Aabb2d, bounded_area_size: Vec2) -> Vec2
 fn do_camera_movement(
     primary_window: Query<&Window, With<PrimaryWindow>>,
     mouse_buttons: Res<ButtonInput<MouseButton>>,
+    keyboard_buttons: Res<ButtonInput<KeyCode>>,
     mut query: Query<(&PanCam, &mut Transform, &OrthographicProjection)>,
     mut last_pos: Local<Option<Vec2>>,
+    time: Res<Time>,
 ) {
     let Ok(window) = primary_window.get_single() else {
         return;
@@ -196,21 +219,81 @@ fn do_camera_movement(
     let delta_device_pixels = current_pos - last_pos.unwrap_or(current_pos);
 
     for (cam, mut transform, projection) in &mut query {
-        if !cam.enabled
-            || !cam
-                .grab_buttons
-                .iter()
-                .any(|btn| mouse_buttons.pressed(*btn) && !mouse_buttons.just_pressed(*btn))
-        {
-            continue;
-        }
-
-        let proj_area_size = projection.area.size();
-        let world_units_per_device_pixel = proj_area_size / window_size;
-
-        // The proposed new camera position
-        let delta_world = delta_device_pixels * world_units_per_device_pixel;
-        let proposed_cam_pos = transform.translation.truncate() - delta_world;
+        let (proposed_cam_pos, proj_area_size) = match cam.move_mode {
+            MoveMode::Mouse => {
+                if !cam.enabled
+                    || !cam
+                        .grab_buttons
+                        .iter()
+                        .any(|btn| mouse_buttons.pressed(*btn) && !mouse_buttons.just_pressed(*btn))
+                {
+                    continue;
+                }
+
+                let proj_area_size = projection.area.size();
+                let world_units_per_device_pixel = proj_area_size / window_size;
+
+                // The proposed new camera position
+                let delta_world = delta_device_pixels * world_units_per_device_pixel;
+                (
+                    transform.translation.truncate() - delta_world,
+                    proj_area_size,
+                )
+            }
+            MoveMode::Keyboard => {
+                let mut direction = Vec2::ZERO;
+
+                if cam
+                    .move_keys
+                    .left
+                    .iter()
+                    .any(|key| keyboard_buttons.pressed(*key))
+                {
+                    direction.x += 1.;
+                }
+
+                if cam
+                    .move_keys
+                    .right
+                    .iter()
+                    .any(|key| keyboard_buttons.pressed(*key))
+                {
+                    direction.x -= 1.;
+                }
+
+                if cam
+                    .move_keys
+                    .up
+                    .iter()
+                    .any(|key| keyboard_buttons.pressed(*key))
+                {
+                    direction.y -= 1.;
+                }
+
+                if cam
+                    .move_keys
+                    .down
+                    .iter()
+                    .any(|key| keyboard_buttons.pressed(*key))
+                {
+                    direction.y += 1.;
+                }
+
+                if direction.length() == 0. {
+                    continue;
+                }
+
+                let delta = time.delta_seconds()
+                    * direction.normalize_or_zero()
+                    * cam.speed
+                    * projection.scale;
+
+                (
+                    transform.translation.truncate() - delta,
+                    projection.area.size(),
+                )
+            }
+        };
 
         transform.translation = clamp_to_safe_zone(proposed_cam_pos, cam.aabb(), proj_area_size)
             .extend(transform.translation.z);
@@ -222,6 +305,12 @@ fn do_camera_movement(
 #[derive(Component, Reflect)]
 #[reflect(Component)]
 pub struct PanCam {
+    /// How the camera is moved
+    pub move_mode: MoveMode,
+    /// The keyboard keys that will be used to move the camera
+    pub move_keys: DirectionKeys,
+    /// Speed for keyboard movement
+    pub speed: f32,
     /// The mouse buttons that will be used to drag and pan the camera
     pub grab_buttons: Vec<MouseButton>,
     /// Whether camera currently responds to user input
@@ -296,6 +385,14 @@ impl PanCam {
 impl Default for PanCam {
     fn default() -> Self {
         Self {
+            move_mode: MoveMode::Keyboard,
+            move_keys: DirectionKeys {
+                up: vec![KeyCode::ArrowUp, KeyCode::KeyW],
+                down: vec![KeyCode::ArrowDown, KeyCode::KeyS],
+                left: vec![KeyCode::ArrowLeft, KeyCode::KeyA],
+                right: vec![KeyCode::ArrowRight, KeyCode::KeyD],
+            },
+            speed: 200.,
             grab_buttons: vec![MouseButton::Left, MouseButton::Right, MouseButton::Middle],
             enabled: true,
             zoom_to_cursor: true,

From 035e5bd30f7816323f224993c8c7e873a12770f0 Mon Sep 17 00:00:00 2001
From: Toniman575 <toniman575@gmail.com>
Date: Fri, 16 Aug 2024 18:33:54 +0200
Subject: [PATCH 2/4] Using `length_squared` and removed `MoveMode`

---
 src/lib.rs | 163 ++++++++++++++++++++++++-----------------------------
 1 file changed, 75 insertions(+), 88 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 2f6cd42..b29ed48 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -21,16 +21,6 @@ pub struct PanCamPlugin;
 #[derive(Debug, Clone, Copy, SystemSet, PartialEq, Eq, Hash)]
 pub struct PanCamSystemSet;
 
-/// How the camera is moved.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Reflect, Default)]
-pub enum MoveMode {
-    #[default]
-    /// Camera is moved through only the mouse.
-    Mouse,
-    /// Camera is moved through only the keyboard.
-    Keyboard,
-}
-
 /// Which keys move the camera in particular directions for keyboard movement.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Reflect)]
 pub struct DirectionKeys {
@@ -47,7 +37,6 @@ impl Plugin for PanCamPlugin {
             (do_camera_movement, do_camera_zoom).in_set(PanCamSystemSet),
         )
         .register_type::<PanCam>()
-        .register_type::<MoveMode>()
         .register_type::<DirectionKeys>();
 
         #[cfg(feature = "bevy_egui")]
@@ -219,82 +208,83 @@ fn do_camera_movement(
     let delta_device_pixels = current_pos - last_pos.unwrap_or(current_pos);
 
     for (cam, mut transform, projection) in &mut query {
-        let (proposed_cam_pos, proj_area_size) = match cam.move_mode {
-            MoveMode::Mouse => {
-                if !cam.enabled
-                    || !cam
-                        .grab_buttons
-                        .iter()
-                        .any(|btn| mouse_buttons.pressed(*btn) && !mouse_buttons.just_pressed(*btn))
-                {
-                    continue;
-                }
-
-                let proj_area_size = projection.area.size();
-                let world_units_per_device_pixel = proj_area_size / window_size;
-
-                // The proposed new camera position
-                let delta_world = delta_device_pixels * world_units_per_device_pixel;
-                (
-                    transform.translation.truncate() - delta_world,
-                    proj_area_size,
-                )
-            }
-            MoveMode::Keyboard => {
-                let mut direction = Vec2::ZERO;
-
-                if cam
-                    .move_keys
-                    .left
-                    .iter()
-                    .any(|key| keyboard_buttons.pressed(*key))
-                {
-                    direction.x += 1.;
-                }
-
-                if cam
-                    .move_keys
-                    .right
-                    .iter()
-                    .any(|key| keyboard_buttons.pressed(*key))
-                {
-                    direction.x -= 1.;
-                }
-
-                if cam
-                    .move_keys
-                    .up
-                    .iter()
-                    .any(|key| keyboard_buttons.pressed(*key))
-                {
-                    direction.y -= 1.;
-                }
-
-                if cam
-                    .move_keys
-                    .down
-                    .iter()
-                    .any(|key| keyboard_buttons.pressed(*key))
-                {
-                    direction.y += 1.;
-                }
-
-                if direction.length() == 0. {
-                    continue;
-                }
-
-                let delta = time.delta_seconds()
-                    * direction.normalize_or_zero()
-                    * cam.speed
-                    * projection.scale;
-
-                (
-                    transform.translation.truncate() - delta,
-                    projection.area.size(),
-                )
-            }
+        if !cam.enabled {
+            continue;
+        }
+
+        let proj_area_size = projection.area.size();
+
+        let mouse_delta = if !cam
+            .grab_buttons
+            .iter()
+            .any(|btn| mouse_buttons.pressed(*btn) && !mouse_buttons.just_pressed(*btn))
+        {
+            None
+        } else {
+            Some(delta_device_pixels * proj_area_size / window_size)
         };
 
+        let mut direction = Vec2::ZERO;
+
+        if cam
+            .move_keys
+            .left
+            .iter()
+            .any(|key| keyboard_buttons.pressed(*key))
+        {
+            direction.x += 1.;
+        }
+
+        if cam
+            .move_keys
+            .right
+            .iter()
+            .any(|key| keyboard_buttons.pressed(*key))
+        {
+            direction.x -= 1.;
+        }
+
+        if cam
+            .move_keys
+            .up
+            .iter()
+            .any(|key| keyboard_buttons.pressed(*key))
+        {
+            direction.y -= 1.;
+        }
+
+        if cam
+            .move_keys
+            .down
+            .iter()
+            .any(|key| keyboard_buttons.pressed(*key))
+        {
+            direction.y += 1.;
+        }
+
+        let keyboard_delta = if direction.length_squared() == 0. {
+            None
+        } else {
+            Some(
+                time.delta_seconds() * direction.normalize_or_zero() * cam.speed * projection.scale,
+            )
+        };
+
+        if mouse_delta.is_none() && keyboard_delta.is_none() {
+            continue;
+        }
+
+        // The proposed new camera position
+        let mut proposed_cam_pos = transform.translation.truncate();
+
+        if let Some(mouse_delta) = mouse_delta {
+            proposed_cam_pos -= mouse_delta;
+        }
+
+        if let Some(keyboard_delta) = keyboard_delta {
+            proposed_cam_pos -= keyboard_delta;
+        }
+
         transform.translation = clamp_to_safe_zone(proposed_cam_pos, cam.aabb(), proj_area_size)
             .extend(transform.translation.z);
     }
@@ -305,8 +295,6 @@ fn do_camera_movement(
 #[derive(Component, Reflect)]
 #[reflect(Component)]
 pub struct PanCam {
-    /// How the camera is moved
-    pub move_mode: MoveMode,
     /// The keyboard keys that will be used to move the camera
     pub move_keys: DirectionKeys,
     /// Speed for keyboard movement
@@ -385,7 +373,6 @@ impl PanCam {
 impl Default for PanCam {
     fn default() -> Self {
         Self {
-            move_mode: MoveMode::Keyboard,
             move_keys: DirectionKeys {
                 up: vec![KeyCode::ArrowUp, KeyCode::KeyW],
                 down: vec![KeyCode::ArrowDown, KeyCode::KeyS],

From c73d3f8e1506bad73ffa2dc399c36037f236cabf Mon Sep 17 00:00:00 2001
From: Toniman575 <toniman575@gmail.com>
Date: Sat, 17 Aug 2024 15:44:40 +0200
Subject: [PATCH 3/4] added pub and documentation to `DirectionKeys` fields.

---
 src/lib.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index b29ed48..239cdc6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -24,10 +24,14 @@ pub struct PanCamSystemSet;
 /// Which keys move the camera in particular directions for keyboard movement.
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Reflect)]
 pub struct DirectionKeys {
-    up: Vec<KeyCode>,
-    down: Vec<KeyCode>,
-    left: Vec<KeyCode>,
-    right: Vec<KeyCode>,
+    ///  The keys that move the camera up.
+    pub up: Vec<KeyCode>,
+    ///  The keys that move the camera down.
+    pub down: Vec<KeyCode>,
+    ///  The keys that move the camera left.
+    pub left: Vec<KeyCode>,
+    ///  The keys that move the camera right.
+    pub right: Vec<KeyCode>,
 }
 
 impl Plugin for PanCamPlugin {

From 739a4aa4377b09ecf58f5f299dca83a9217dafe0 Mon Sep 17 00:00:00 2001
From: Toniman575 <toniman575@gmail.com>
Date: Sat, 17 Aug 2024 16:37:42 +0200
Subject: [PATCH 4/4] adressed comments and requested changes

---
 README.md  |   8 +++
 src/lib.rs | 150 +++++++++++++++++++++++++++++------------------------
 2 files changed, 89 insertions(+), 69 deletions(-)

diff --git a/README.md b/README.md
index a85d87d..1ade8a4 100644
--- a/README.md
+++ b/README.md
@@ -15,6 +15,7 @@ Behaves similarly to common online map applications:
 
 - Click and drag to move the camera
 - Scroll to zoom
+- Keep Keyboard buttons pushed to move the camera
 
 ## Usage
 
@@ -41,6 +42,13 @@ Alternatively, set the fields of the `PanCam` component to customize behavior:
 commands.spawn(Camera2dBundle::default())
     .insert(PanCam {
         grab_buttons: vec![MouseButton::Left, MouseButton::Middle], // which buttons should drag the camera
+        move_keys: DirectionKeys {      // the keyboard buttons used to move the camera
+            up:    vec![KeyCode::KeyQ], // initalize the struct like this or use the provided methods for
+            down:  vec![KeyCode::KeyW], // common key combinations
+            left:  vec![KeyCode::KeyE],
+            right: vec![KeyCode::KeyR],
+        },
+        speed: 400., // the speed for the keyboard movement
         enabled: true, // when false, controls are disabled. See toggle example.
         zoom_to_cursor: true, // whether to zoom towards the mouse or the center of the screen
         min_scale: 1., // prevent the camera from zooming too far in
diff --git a/src/lib.rs b/src/lib.rs
index 239cdc6..84f327b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -21,19 +21,81 @@ pub struct PanCamPlugin;
 #[derive(Debug, Clone, Copy, SystemSet, PartialEq, Eq, Hash)]
 pub struct PanCamSystemSet;
 
-/// Which keys move the camera in particular directions for keyboard movement.
+/// Which keys move the camera in particular directions for keyboard movement
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Reflect)]
 pub struct DirectionKeys {
-    ///  The keys that move the camera up.
+    ///  The keys that move the camera up
     pub up: Vec<KeyCode>,
-    ///  The keys that move the camera down.
+    ///  The keys that move the camera down
     pub down: Vec<KeyCode>,
-    ///  The keys that move the camera left.
+    ///  The keys that move the camera left
     pub left: Vec<KeyCode>,
-    ///  The keys that move the camera right.
+    ///  The keys that move the camera right
     pub right: Vec<KeyCode>,
 }
 
+impl DirectionKeys {
+    /// No keys move the camera
+    pub const NONE: Self = Self {
+        up: vec![],
+        down: vec![],
+        left: vec![],
+        right: vec![],
+    };
+
+    /// The camera is moved by the arrow keys
+    pub fn arrows() -> Self {
+        Self {
+            up: vec![KeyCode::ArrowUp],
+            down: vec![KeyCode::ArrowDown],
+            left: vec![KeyCode::ArrowLeft],
+            right: vec![KeyCode::ArrowRight],
+        }
+    }
+
+    /// The camera is moved by the WASD keys
+    pub fn wasd() -> Self {
+        Self {
+            up: vec![KeyCode::KeyW],
+            down: vec![KeyCode::KeyS],
+            left: vec![KeyCode::KeyA],
+            right: vec![KeyCode::KeyD],
+        }
+    }
+
+    /// The camera is moved by the arrow and WASD keys
+    pub fn arrows_and_wasd() -> Self {
+        Self {
+            up: vec![KeyCode::ArrowUp, KeyCode::KeyW],
+            down: vec![KeyCode::ArrowDown, KeyCode::KeyS],
+            left: vec![KeyCode::ArrowLeft, KeyCode::KeyA],
+            right: vec![KeyCode::ArrowRight, KeyCode::KeyD],
+        }
+    }
+
+    fn direction(&self, keyboard_buttons: &Res<ButtonInput<KeyCode>>) -> Vec2 {
+        let mut direction = Vec2::ZERO;
+
+        if self.left.iter().any(|key| keyboard_buttons.pressed(*key)) {
+            direction.x -= 1.;
+        }
+
+        if self.right.iter().any(|key| keyboard_buttons.pressed(*key)) {
+            direction.x += 1.;
+        }
+
+        if self.up.iter().any(|key| keyboard_buttons.pressed(*key)) {
+            direction.y += 1.;
+        }
+
+        if self.down.iter().any(|key| keyboard_buttons.pressed(*key)) {
+            direction.y -= 1.;
+        }
+
+        direction
+    }
+}
+
 impl Plugin for PanCamPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(
@@ -223,71 +285,23 @@ fn do_camera_movement(
             .iter()
             .any(|btn| mouse_buttons.pressed(*btn) && !mouse_buttons.just_pressed(*btn))
         {
-            None
+            Vec2::ZERO
         } else {
-            Some(delta_device_pixels * proj_area_size / window_size)
+            delta_device_pixels * proj_area_size / window_size
         };
 
-        let mut direction = Vec2::ZERO;
+        let direction = cam.move_keys.direction(&keyboard_buttons);
 
-        if cam
-            .move_keys
-            .left
-            .iter()
-            .any(|key| keyboard_buttons.pressed(*key))
-        {
-            direction.x += 1.;
-        }
-
-        if cam
-            .move_keys
-            .right
-            .iter()
-            .any(|key| keyboard_buttons.pressed(*key))
-        {
-            direction.x -= 1.;
-        }
-
-        if cam
-            .move_keys
-            .up
-            .iter()
-            .any(|key| keyboard_buttons.pressed(*key))
-        {
-            direction.y -= 1.;
-        }
+        let keyboard_delta =
+            time.delta_seconds() * direction.normalize_or_zero() * cam.speed * projection.scale;
+        let delta = mouse_delta - keyboard_delta;
 
-        if cam
-            .move_keys
-            .down
-            .iter()
-            .any(|key| keyboard_buttons.pressed(*key))
-        {
-            direction.y += 1.;
-        }
-
-        let keyboard_delta = if direction.length_squared() == 0. {
-            None
-        } else {
-            Some(
-                time.delta_seconds() * direction.normalize_or_zero() * cam.speed * projection.scale,
-            )
-        };
-
-        if mouse_delta.is_none() && keyboard_delta.is_none() {
+        if delta == Vec2::ZERO {
             continue;
         }
 
         // The proposed new camera position
-        let mut proposed_cam_pos = transform.translation.truncate();
-
-        if let Some(mouse_delta) = mouse_delta {
-            proposed_cam_pos -= mouse_delta;
-        }
-
-        if let Some(keyboard_delta) = keyboard_delta {
-            proposed_cam_pos -= keyboard_delta;
-        }
+        let proposed_cam_pos = transform.translation.truncate() - delta;
 
         transform.translation = clamp_to_safe_zone(proposed_cam_pos, cam.aabb(), proj_area_size)
             .extend(transform.translation.z);
@@ -299,12 +313,15 @@ fn do_camera_movement(
 #[derive(Component, Reflect)]
 #[reflect(Component)]
 pub struct PanCam {
+    /// The mouse buttons that will be used to drag and pan the camera
+    pub grab_buttons: Vec<MouseButton>,
     /// The keyboard keys that will be used to move the camera
     pub move_keys: DirectionKeys,
     /// Speed for keyboard movement
+    ///
+    /// This is multiplied with the projection scale of the camera so the
+    /// speed stays proportional to the current "zoom" level
     pub speed: f32,
-    /// The mouse buttons that will be used to drag and pan the camera
-    pub grab_buttons: Vec<MouseButton>,
     /// Whether camera currently responds to user input
     pub enabled: bool,
     /// When true, zooming the camera will center on the mouse cursor
@@ -377,12 +394,7 @@ impl PanCam {
 impl Default for PanCam {
     fn default() -> Self {
         Self {
-            move_keys: DirectionKeys {
-                up: vec![KeyCode::ArrowUp, KeyCode::KeyW],
-                down: vec![KeyCode::ArrowDown, KeyCode::KeyS],
-                left: vec![KeyCode::ArrowLeft, KeyCode::KeyA],
-                right: vec![KeyCode::ArrowRight, KeyCode::KeyD],
-            },
+            move_keys: DirectionKeys::arrows_and_wasd(),
             speed: 200.,
             grab_buttons: vec![MouseButton::Left, MouseButton::Right, MouseButton::Middle],
             enabled: true,