feat: all camera modes

Author: simbleau

Cargo.toml

@@ -31,7 +31,7 @@ bevy = { workspace = true, default-features = false, features = [
   "bevy_state",
   "bevy_core_pipeline",
 ] }
-bevy_pancam = { git = "https://github.com/tomara-x/bevy_pancam", features = [
+bevy_pancam = { git = "https://github.com/johanhelsing/bevy_pancam", features = [
   "bevy_egui",
 ] }
 #bevy_pancam = "0.12.0"

examples/simple/src/main.rs

@@ -1,6 +1,4 @@
-use std::ops::Deref;
-
-use bevy::{color::palettes::css, prelude::*, transform::commands};
+use bevy::{color::palettes::css, prelude::*};
 use bevy_egui::{egui, EguiContexts, EguiPlugin};
 use bevy_ogle::{prelude::*, OglePlugin};
 use rand::random;
@@ -12,11 +10,8 @@ fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
         .add_plugins(EguiPlugin)
-        .add_plugins(OglePlugin)
+        .add_plugins(OglePlugin::default())
         .add_systems(Startup, setup_scene)
-        .add_systems(Startup, |mut commands: Commands| {
-            commands.spawn(Camera2dBundle::default());
-        })
         .add_systems(Update, move_target)
         .add_systems(Update, control_camera_ui)
         .run();
@@ -81,9 +76,6 @@ fn control_camera_ui(
             || ui
                 .radio_value(&mut set_mode, OgleMode::Following, "Following")
                 .clicked()
-            || ui
-                .radio_value(&mut set_mode, OgleMode::Choreographed, "Choreographed")
-                .clicked()
             || ui
                 .radio_value(&mut set_mode, OgleMode::Pancam, "Pancam")
                 .clicked()
@@ -92,7 +84,7 @@ fn control_camera_ui(
         }
 
         ui.separator();
-        ui.heading("Mode");
+        ui.heading("Camera Target");
         let target_entity = query_thing.single();
         if ui.radio(*target == OgleTarget::None, "None").clicked() {
             commands.ogle_clear_target();
@@ -103,5 +95,25 @@ fn control_camera_ui(
         {
             commands.ogle_target_entity(target_entity);
         }
+        ui.horizontal(|ui| {
+            let mut pos = match *target {
+                OgleTarget::Position(p) => p,
+                _ => Vec2::new(0.0, 0.0),
+            };
+            if ui
+                .radio(matches!(*target, OgleTarget::Position(_)), "Position")
+                .clicked()
+            {
+                commands.ogle_target_position(pos);
+            }
+            ui.label("X");
+            if ui.add(egui::DragValue::new(&mut pos.x)).changed() {
+                commands.ogle_target_position(pos);
+            }
+            ui.label("Y");
+            if ui.add(egui::DragValue::new(&mut pos.y)).changed() {
+                commands.ogle_target_position(pos);
+            }
+        });
     });
 }

src/lib.rs

@@ -1,6 +1,5 @@
 use bevy::prelude::*;
-
-mod rig;
+use dolly::prelude::*;
 
 mod commands;
 pub use commands::OgleCommandExt;
@@ -28,14 +27,76 @@ pub enum OgleMode {
     Frozen,
     /// The camera should exponentially follow its target.
     Following,
-    /// The camera is being choreographed and should mirror its target position exactly.
-    ///
-    /// This is useful when the camera follows a spline, or you don't want loose following behavior.
-    Choreographed,
     /// The camera is in a detached pancam mode.
     Pancam,
 }
 
+#[derive(Resource, Deref, DerefMut)]
+pub struct OgleRig(CameraRig);
+
+impl Default for OgleRig {
+    fn default() -> Self {
+        let pos = mint::Point3 {
+            x: 0.0,
+            y: 0.0,
+            z: 1.0,
+        };
+        Self(
+            CameraRig::builder()
+                .with(Position::new(pos))
+                .with(Arm::new(pos))
+                .with(Smooth::new_position(1.5).predictive(false))
+                .build(),
+        )
+    }
+}
+
+#[derive(Resource, Debug, Clone, Copy, PartialEq)]
+pub struct OgleSettings {
+    /// The minimum scale for the camera
+    ///
+    /// The orthographic projection's scale will be clamped at this value when zooming in
+    pub min_scale: f32,
+    /// The maximum scale for the camera
+    ///
+    /// If present, the orthographic projection's scale will be clamped at
+    /// this value when zooming out.
+    pub max_scale: Option<f32>,
+    /// The minimum x position of the camera window
+    ///
+    /// If present, the orthographic projection will be clamped to this boundary both
+    /// when dragging the window, and zooming out.
+    pub min_x: Option<f32>,
+    /// The maximum x position of the camera window
+    ///
+    /// If present, the orthographic projection will be clamped to this boundary both
+    /// when dragging the window, and zooming out.
+    pub max_x: Option<f32>,
+    /// The minimum y position of the camera window
+    ///
+    /// If present, the orthographic projection will be clamped to this boundary both
+    /// when dragging the window, and zooming out.
+    pub min_y: Option<f32>,
+    /// The maximum y position of the camera window
+    ///
+    /// If present, the orthographic projection will be clamped to this boundary both
+    /// when dragging the window, and zooming out.
+    pub max_y: Option<f32>,
+}
+
+impl Default for OgleSettings {
+    fn default() -> Self {
+        Self {
+            min_scale: -(1.0 - 0.00001),
+            max_scale: None,
+            min_x: None,
+            max_x: None,
+            min_y: None,
+            max_y: None,
+        }
+    }
+}
+
 pub mod prelude {
-    pub use super::{OgleCommandExt, OgleMode, OgleTarget};
+    pub use super::{OgleCommandExt, OgleMode, OgleRig, OgleSettings, OgleTarget};
 }