build: initial follow mode

simbleau · simbleau · commit 39f5b7d87d8f · 2024-07-07T23:15:18.000-04:00
diff --git a/.cargo/config.toml b/.cargo/config.toml
@@ -3,3 +3,6 @@ run_wasm = "run --release --package run_wasm --"
 # Other crates use the alias run-wasm, even though crate names should use `_`s not `-`s
 # Allow this to be used
 run-wasm = "run_wasm"
+
+[target.'cfg(target_family = "wasm")']
+rustflags = ["--cfg=web_sys_unstable_apis"]
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,21 +1,42 @@
-[package]
-name = "bevy_ogle"
+[workspace]
+resolver = "2"
+members = ["examples/run_wasm", "examples/simple"]
+
+[workspace.package]
 edition = "2021"
 version = "0.1.0"
 license = "MIT OR Apache-2.0"
-description = "A multi-mode camera library for 2d games"
 repository = "https://github.com/loopystudios/bevy_ogle"
+
+[package]
+name = "bevy_ogle"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+description = "A multi-mode camera library for 2d games"
 authors = ["Spencer C. Imbleau"]
 keywords = ["bevy"]
 categories = ["game-development", "wasm"]
 readme = "README.md"
 
 [lib]
 
+
+[workspace.dependencies]
+bevy = { version = "0.14.0", default-features = false }
+
 [dependencies]
-bevy = { version = "0.14", default-features = false }
-bevy_pancam = "0.11.1"
+bevy = { workspace = true, default-features = false, features = [
+  "bevy_state",
+  "bevy_core_pipeline",
+] }
+bevy_pancam = { git = "https://github.com/tomara-x/bevy_pancam", features = [
+  "bevy_egui",
+] }
+#bevy_pancam = "0.12.0"
 dolly = "0.5.0"
+mint = "0.5.8"
 
 [dev-dependencies]
 wasm-bindgen-test = "0.3.42"
diff --git a/examples/simple.rs b/examples/simple.rs
diff --git a/examples/simple/Cargo.toml b/examples/simple/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "simple"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[dependencies]
+bevy = { workspace = true, default-features = true }
+bevy_ogle = { path = "../.." }
+bevy_egui = { version = "0.28.0" }
+rand = "0.8.5"
diff --git a/examples/simple/src/main.rs b/examples/simple/src/main.rs
@@ -0,0 +1,91 @@
+use bevy::{color::palettes::css, prelude::*};
+use bevy_egui::{egui, EguiContexts, EguiPlugin};
+use bevy_ogle::{prelude::*, OglePlugin};
+use rand::random;
+
+#[derive(Component)]
+struct ThingToFollow;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugins(EguiPlugin)
+        .add_plugins(OglePlugin)
+        .add_systems(Startup, setup_background)
+        .add_systems(Startup, |mut commands: Commands| {
+            commands.spawn(Camera2dBundle::default());
+            // Create target, begin following it.
+            let entity = commands
+                .spawn((ThingToFollow, SpatialBundle::default()))
+                .id();
+            commands.ogle_change_mode(OgleMode::Frozen);
+            commands.ogle_target_entity(entity);
+        })
+        .add_systems(Update, move_target)
+        .add_systems(Update, control_camera_ui)
+        .run();
+}
+
+fn setup_background(mut commands: Commands) {
+    let n = 20;
+    let spacing = 50.;
+    let offset = spacing * n as f32 / 2.;
+    let custom_size = Some(Vec2::new(spacing, spacing));
+    for x in 0..n {
+        for y in 0..n {
+            let x = x as f32 * spacing - offset;
+            let y = y as f32 * spacing - offset;
+            let color = Color::hsl(240., random::<f32>() * 0.3, random::<f32>() * 0.3);
+            commands.spawn(SpriteBundle {
+                sprite: Sprite {
+                    color,
+                    custom_size,
+                    ..default()
+                },
+                transform: Transform::from_xyz(x, y, 0.),
+                ..default()
+            });
+        }
+    }
+}
+
+fn move_target(
+    time: Res<Time>,
+    mut query_thing: Query<&mut Transform, With<ThingToFollow>>,
+    mut gizmos: Gizmos,
+) {
+    let mut transform = query_thing.single_mut();
+    transform.translation.x += time.delta_seconds() * (random::<f32>() * 500.0 - 500.0 / 2.0);
+    transform.translation.y += time.delta_seconds() * (random::<f32>() * 500.0 - 500.0 / 2.0);
+    gizmos.rect_2d(transform.translation.xy(), 0.0, (5.0, 5.0).into(), css::RED);
+}
+
+fn control_camera_ui(
+    mut contexts: EguiContexts,
+    query_thing: Query<Entity, With<ThingToFollow>>,
+    mode: Res<State<OgleMode>>,
+    mut next_mode: ResMut<NextState<OgleMode>>,
+) {
+    let window = egui::Window::new("Camera Controls")
+        .anchor(egui::Align2::LEFT_TOP, [25.0, 25.0])
+        .resizable(false)
+        .title_bar(true);
+    window.show(contexts.ctx_mut(), |ui| {
+        let mut set_mode = mode.clone();
+        if ui
+            .radio_value(&mut set_mode, OgleMode::Frozen, "Frozen")
+            .clicked()
+            || 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()
+        {
+            next_mode.set(set_mode);
+        }
+    });
+}
diff --git a/src/commands.rs b/src/commands.rs
@@ -0,0 +1,58 @@
+use bevy::{ecs::world::Command, prelude::*};
+
+use crate::{OgleMode, OgleTarget};
+
+pub enum OgleCommand {
+    TargetPosition(Vec2),
+    TargetEntity(Entity),
+    ClearTarget,
+    ChangeMode(OgleMode),
+}
+
+pub trait OgleCommandExt {
+    fn ogle_target_position(&mut self, pos: Vec2);
+    fn ogle_target_entity(&mut self, entity: Entity);
+    fn ogle_clear_target(&mut self);
+    fn ogle_change_mode(&mut self, mode: OgleMode);
+}
+
+impl<'w, 's> OgleCommandExt for Commands<'w, 's> {
+    fn ogle_target_position(&mut self, pos: Vec2) {
+        self.add(OgleCommand::TargetPosition(pos));
+    }
+
+    fn ogle_target_entity(&mut self, entity: Entity) {
+        self.add(OgleCommand::TargetEntity(entity));
+    }
+
+    fn ogle_clear_target(&mut self) {
+        self.add(OgleCommand::ClearTarget);
+    }
+
+    fn ogle_change_mode(&mut self, mode: OgleMode) {
+        self.add(OgleCommand::ChangeMode(mode));
+    }
+}
+
+impl Command for OgleCommand {
+    fn apply(self, world: &mut World) {
+        match self {
+            OgleCommand::TargetEntity(entity) => {
+                let mut target = world.resource_mut::<OgleTarget>();
+                *target = OgleTarget::Entity(entity);
+            }
+            OgleCommand::TargetPosition(pos) => {
+                let mut target = world.resource_mut::<OgleTarget>();
+                *target = OgleTarget::Position(pos);
+            }
+            OgleCommand::ClearTarget => {
+                let mut target = world.resource_mut::<OgleTarget>();
+                *target = OgleTarget::None;
+            }
+            OgleCommand::ChangeMode(mode) => {
+                let mut next_mode = world.resource_mut::<NextState<OgleMode>>();
+                next_mode.set(mode);
+            }
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,14 +1,41 @@
-pub fn add(left: usize, right: usize) -> usize {
-    left + right
-}
+use bevy::prelude::*;
+
+mod rig;
+
+mod commands;
+pub use commands::OgleCommandExt;
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+mod plugin;
+pub use plugin::OglePlugin;
+
+#[derive(Resource, Debug)]
+pub enum OgleTarget {
+    Position(Vec2),
+    Entity(Entity),
+    None,
+}
 
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
+impl Default for OgleTarget {
+    fn default() -> Self {
+        Self::Position(Vec2 { x: 0.0, y: 0.0 })
     }
 }
+
+#[derive(States, Clone, PartialEq, Eq, Hash, Debug, Default)]
+pub enum OgleMode {
+    /// The camera will not move under normal circumstances.
+    #[default]
+    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,
+}
+
+pub mod prelude {
+    pub use super::{OgleCommandExt, OgleMode, OgleTarget};
+}
diff --git a/src/plugin.rs b/src/plugin.rs
@@ -0,0 +1,105 @@
+use crate::{rig::OgleRig, OgleMode, OgleTarget};
+use bevy::prelude::*;
+use bevy_pancam::{PanCam, PanCamPlugin};
+use dolly::prelude::*;
+
+// TODO: These should be configurable and play well with pancam
+const MIN_ZOOM: f32 = 0.01;
+const MAX_ZOOM: f32 = 3.0;
+const ZOOM_SPEED: f32 = 2.0;
+
+#[derive(Default)]
+pub struct OglePlugin;
+
+impl Plugin for OglePlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<OgleRig>()
+            .init_resource::<OgleTarget>()
+            .init_state::<OgleMode>()
+            .add_plugins(PanCamPlugin)
+            .add_systems(Startup, setup)
+            .add_systems(Update, follow_target.run_if(in_state(OgleMode::Following)))
+            .add_systems(
+                Update,
+                choreograph_target.run_if(in_state(OgleMode::Choreographed)),
+            )
+            .add_systems(OnEnter(OgleMode::Pancam), on_enter_pancam)
+            .add_systems(OnExit(OgleMode::Pancam), on_exit_pancam);
+    }
+}
+
+fn setup(mut commands: Commands) {
+    // TODO: Settings for pancam handled consistently with other ogle settings
+    commands.spawn(bevy_pancam::PanCam::default());
+}
+
+fn on_enter_pancam(mut query: Query<&mut PanCam>) {
+    let mut pancam = query.single_mut();
+    info!("Enabling pancam");
+    pancam.enabled = true;
+}
+
+fn on_exit_pancam(mut query: Query<&mut PanCam>) {
+    let mut pancam = query.single_mut();
+    info!("Disabling pancam");
+    pancam.enabled = false;
+}
+
+fn choreograph_target() {
+    todo!("handle camera choreographs, like following a spline")
+}
+
+fn follow_target(
+    time: Res<Time>,
+    target: Res<OgleTarget>,
+    mut rig: ResMut<OgleRig>,
+    query_transform: Query<&Transform, Without<Camera>>,
+    mut query_cam: Query<&mut Transform, With<Camera>>,
+    mut proj_query: Query<&mut OrthographicProjection>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+) {
+    let mut proj = proj_query.single_mut();
+    if keyboard_input.pressed(KeyCode::ArrowUp) {
+        rig.driver_mut::<Arm>().offset.z -= proj.scale * ZOOM_SPEED * time.delta_seconds();
+    }
+    if keyboard_input.pressed(KeyCode::ArrowDown) {
+        rig.driver_mut::<Arm>().offset.z += proj.scale * ZOOM_SPEED * time.delta_seconds();
+    }
+    rig.driver_mut::<Arm>().offset.z = rig.driver_mut::<Arm>().offset.z.clamp(MIN_ZOOM, MAX_ZOOM);
+
+    match *target {
+        OgleTarget::Position(pos) => {
+            rig.driver_mut::<Position>().position = mint::Point3 {
+                x: pos.x,
+                y: pos.y,
+                z: 0.0,
+            };
+        }
+        OgleTarget::Entity(e) => {
+            // TODO: Handle errors
+            let transform = query_transform
+                .get(e)
+                .expect("entity target has no transform");
+            rig.driver_mut::<Position>().position = mint::Point3 {
+                x: transform.translation.x,
+                y: transform.translation.y,
+                z: 0.0,
+            };
+        }
+        OgleTarget::None => {}
+    }
+
+    rig.update(time.delta_seconds());
+
+    if let Some(mut camera_transform) = query_cam.iter_mut().next() {
+        camera_transform.translation.x = rig.final_transform.position.x;
+        camera_transform.translation.y = rig.final_transform.position.y;
+        camera_transform.rotation = Quat::from_xyzw(
+            rig.final_transform.rotation.v.x,
+            rig.final_transform.rotation.v.y,
+            rig.final_transform.rotation.v.z,
+            rig.final_transform.rotation.s,
+        );
+        proj.scale = rig.final_transform.position.z;
+    }
+}
diff --git a/src/rig.rs b/src/rig.rs
