Add support for using real time (#125)

Author: Plonq

examples/keyboard_controls.rs

@@ -50,6 +50,8 @@ fn setup(
 }
 
 fn keyboard_controls(
+    // If you set `PanOrbitCamera::use_real_time` to `true`, you may want to use `Res<Time<Real>>`
+    // here too, so you can control the camera while virtual time is paused.
     time: Res<Time>,
     key_input: Res<ButtonInput<KeyCode>>,
     mut pan_orbit_query: Query<(&mut PanOrbitCamera, &mut Transform)>,

examples/pausing.rs

@@ -0,0 +1,75 @@
+//! Demonstrates how to pause time without affecting the camera
+
+use bevy::prelude::*;
+use bevy_panorbit_camera::{PanOrbitCamera, PanOrbitCameraPlugin};
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugins(PanOrbitCameraPlugin)
+        .add_systems(Startup, setup)
+        .add_systems(Update, (pause_game_system, cube_rotator_system))
+        .run();
+}
+
+#[derive(Component)]
+struct Cube;
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // Ground
+    commands.spawn((
+        Mesh3d(meshes.add(Plane3d::default().mesh().size(5.0, 5.0))),
+        MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))),
+    ));
+    // Cube
+    commands.spawn((
+        Mesh3d(meshes.add(Cuboid::new(1.0, 1.0, 1.0))),
+        MeshMaterial3d(materials.add(Color::srgb(0.8, 0.7, 0.6))),
+        Transform::from_xyz(0.0, 0.5, 0.0),
+        Cube,
+    ));
+    // Light
+    commands.spawn((
+        PointLight {
+            shadows_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(4.0, 8.0, 4.0),
+    ));
+    // Camera
+    commands.spawn((
+        Transform::from_xyz(0.0, 1.5, 5.0),
+        PanOrbitCamera {
+            use_real_time: true,
+            ..default()
+        },
+    ));
+    // Help text
+    commands.spawn(Text::new(
+        "\
+Press Space to pause the 'game'",
+    ));
+}
+
+// Pauses the game (i.e. virtual time)
+fn pause_game_system(key_input: Res<ButtonInput<KeyCode>>, mut time: ResMut<Time<Virtual>>) {
+    if key_input.just_pressed(KeyCode::Space) {
+        if time.is_paused() {
+            time.unpause()
+        } else {
+            time.pause()
+        }
+    }
+}
+
+// Rotates the cube so you can see the effect of pausing time
+// Note the default time for the Update schedule is `Time<Virtual>`
+fn cube_rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Cube>>) {
+    for mut transform in &mut query {
+        transform.rotate_y(1.0 * time.delta_secs());
+    }
+}

src/lib.rs

@@ -270,6 +270,10 @@ pub struct PanOrbitCamera {
     /// up direction. The default up is Y, but if you want the camera rotated.
     /// The axis can be switched. Default is [Vec3::X, Vec3::Y, Vec3::Z]
     pub axis: [Vec3; 3],
+    /// Use real time instead of virtual time. Set this to `true` if you want to pause virtual
+    /// time without affecting the camera, for example in a game.
+    /// Defaults to `false`.
+    pub use_real_time: bool,
 }
 
 impl Default for PanOrbitCamera {
@@ -313,6 +317,7 @@ impl Default for PanOrbitCamera {
             zoom_lower_limit: 0.05,
             force_update: false,
             axis: [Vec3::X, Vec3::Y, Vec3::Z],
+            use_real_time: false,
         }
     }
 }
@@ -484,7 +489,8 @@ fn pan_orbit_camera(
     mouse_key_tracker: Res<MouseKeyTracker>,
     touch_tracker: Res<TouchTracker>,
     mut orbit_cameras: Query<(Entity, &mut PanOrbitCamera, &mut Transform, &mut Projection)>,
-    time: Res<Time>,
+    time_real: Res<Time<Real>>,
+    time_virt: Res<Time<Virtual>>,
 ) {
     for (entity, mut pan_orbit, mut transform, mut projection) in orbit_cameras.iter_mut() {
         // Closures that apply limits to the yaw, pitch, and zoom values
@@ -704,6 +710,12 @@ fn pan_orbit_camera(
 
         // 4 - Update the camera's transform based on current values
 
+        let delta = if pan_orbit.use_real_time {
+            time_real.delta_secs()
+        } else {
+            time_virt.delta_secs()
+        };
+
         if let (Some(yaw), Some(pitch), Some(radius)) =
             (pan_orbit.yaw, pan_orbit.pitch, pan_orbit.radius)
         {
@@ -723,25 +735,25 @@ fn pan_orbit_camera(
                     yaw,
                     pan_orbit.target_yaw,
                     pan_orbit.orbit_smoothness,
-                    time.delta_secs(),
+                    delta,
                 );
                 let new_pitch = util::lerp_and_snap_f32(
                     pitch,
                     pan_orbit.target_pitch,
                     pan_orbit.orbit_smoothness,
-                    time.delta_secs(),
+                    delta,
                 );
                 let new_radius = util::lerp_and_snap_f32(
                     radius,
                     pan_orbit.target_radius,
                     pan_orbit.zoom_smoothness,
-                    time.delta_secs(),
+                    delta,
                 );
                 let new_focus = util::lerp_and_snap_vec3(
                     pan_orbit.focus,
                     pan_orbit.target_focus,
                     pan_orbit.pan_smoothness,
-                    time.delta_secs(),
+                    delta,
                 );
 
                 util::update_orbit_transform(