From cacf3929db5969736a6627c4c49abee2920fe857 Mon Sep 17 00:00:00 2001
From: ickshonpe <david.curthoys@googlemail.com>
Date: Tue, 10 Sep 2024 21:21:40 +0100
Subject: [PATCH 1/4] fix spelling mistake (#15146)

# Objective

Fix spelling mistake: `interned_root_notes` -> `interned_root_nodes`
---
 crates/bevy_ui/src/layout/mod.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index b529df6f30f40..269af520b1e8f 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -76,7 +76,7 @@ pub struct UiLayoutSystemRemovedComponentParam<'w, 's> {
 #[doc(hidden)]
 #[derive(Default)]
 pub struct UiLayoutSystemBuffers {
-    interned_root_notes: Vec<Vec<Entity>>,
+    interned_root_nodes: Vec<Vec<Entity>>,
     resized_windows: EntityHashSet,
     camera_layout_info: EntityHashMap<CameraLayoutInfo>,
 }
@@ -122,7 +122,7 @@ pub fn ui_layout_system(
     #[cfg(feature = "bevy_text")] mut text_pipeline: ResMut<TextPipeline>,
 ) {
     let UiLayoutSystemBuffers {
-        interned_root_notes,
+        interned_root_nodes,
         resized_windows,
         camera_layout_info,
     } = &mut *buffers;
@@ -147,7 +147,7 @@ pub fn ui_layout_system(
             size,
             resized,
             scale_factor: scale_factor * ui_scale.0,
-            root_nodes: interned_root_notes.pop().unwrap_or_default(),
+            root_nodes: interned_root_nodes.pop().unwrap_or_default(),
         }
     };
 
@@ -280,7 +280,7 @@ pub fn ui_layout_system(
         }
 
         camera.root_nodes.clear();
-        interned_root_notes.push(camera.root_nodes);
+        interned_root_nodes.push(camera.root_nodes);
     }
 
     fn update_uinode_geometry_recursive(

From fa51e260521a969577e5259ae9402ad1de45d6cd Mon Sep 17 00:00:00 2001
From: UkoeHB <37489173+UkoeHB@users.noreply.github.com>
Date: Tue, 10 Sep 2024 18:28:05 -0500
Subject: [PATCH 2/4] Trim cosmic-text's shape run cache (#15037)

# Objective

- Fixes https://github.com/bevyengine/bevy/pull/14991. The `cosmic-text`
shape run cache requires manual cleanup for old text that no longer
needs to be cached.

## Solution

- Add a system to trim the cache.
- Add an `average fps` indicator to the `text_debug` example.

## Testing

Tested with `cargo run --example text_debug`.
- **No shape run cache**: 82fps with ~1fps variance.
- **Shape run cache no trim**: 90-100fps with ~2-4fps variance
- **Shape run cache trim age = 1**: 90-100fps with ~2-8fps variance
- **Shape run cache trim age = 2**: 90-100fps with ~2-4fps variance
- **Shape run cache trim age = 2000**: 80-120fps with ~2-6fps variance

The shape run cache seems to increase average FPS but also increases
frame time variance (when there is dynamic text).
---
 crates/bevy_text/src/lib.rs      |  3 +-
 crates/bevy_text/src/pipeline.rs | 17 ++++++++-
 examples/ui/text_debug.rs        | 65 +++++++++++++++++++++++++++++---
 3 files changed, 78 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_text/src/lib.rs b/crates/bevy_text/src/lib.rs
index 4c379e61e5ae1..0b638cdb1d5e8 100644
--- a/crates/bevy_text/src/lib.rs
+++ b/crates/bevy_text/src/lib.rs
@@ -123,7 +123,8 @@ impl Plugin for TextPlugin {
                         .ambiguous_with(CameraUpdateSystem),
                     remove_dropped_font_atlas_sets,
                 ),
-            );
+            )
+            .add_systems(Last, trim_cosmic_cache);
 
         if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
             render_app.add_systems(
diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index 7ac46096270e8..f5fbc64b3a4d8 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -1,7 +1,12 @@
 use std::sync::Arc;
 
 use bevy_asset::{AssetId, Assets};
-use bevy_ecs::{component::Component, entity::Entity, reflect::ReflectComponent, system::Resource};
+use bevy_ecs::{
+    component::Component,
+    entity::Entity,
+    reflect::ReflectComponent,
+    system::{ResMut, Resource},
+};
 use bevy_math::{UVec2, Vec2};
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::texture::Image;
@@ -407,3 +412,13 @@ fn buffer_dimensions(buffer: &Buffer) -> Vec2 {
 
     Vec2::new(width.ceil(), height).ceil()
 }
+
+/// Discards stale data cached in `FontSystem`.
+pub(crate) fn trim_cosmic_cache(mut pipeline: ResMut<TextPipeline>) {
+    // A trim age of 2 was found to reduce frame time variance vs age of 1 when tested with dynamic text.
+    // See https://github.com/bevyengine/bevy/pull/15037
+    //
+    // We assume only text updated frequently benefits from the shape cache (e.g. animated text, or
+    // text that is dynamically measured for UI).
+    pipeline.font_system_mut().shape_run_cache.trim(2);
+}
diff --git a/examples/ui/text_debug.rs b/examples/ui/text_debug.rs
index 0e4fbe1baca75..e2f596c35290f 100644
--- a/examples/ui/text_debug.rs
+++ b/examples/ui/text_debug.rs
@@ -1,5 +1,7 @@
 //! Shows various text layout options.
 
+use std::{collections::VecDeque, time::Duration};
+
 use bevy::{
     color::palettes::css::*,
     diagnostic::{DiagnosticsStore, FrameTimeDiagnosticsPlugin},
@@ -154,7 +156,15 @@ fn infotext_system(mut commands: Commands, asset_server: Res<AssetServer>) {
         builder.spawn((
             TextBundle::from_sections([
                 TextSection::new(
-                    "This text changes in the bottom right",
+                    "",
+                    TextStyle {
+                        font: font.clone(),
+                        font_size: 25.0,
+                        ..default()
+                    },
+                ),
+                TextSection::new(
+                    "\nThis text changes in the bottom right",
                     TextStyle {
                         font: font.clone(),
                         font_size: 25.0,
@@ -223,10 +233,23 @@ fn infotext_system(mut commands: Commands, asset_server: Res<AssetServer>) {
 }
 
 fn change_text_system(
+    mut fps_history: Local<VecDeque<f64>>,
+    mut time_history: Local<VecDeque<Duration>>,
     time: Res<Time>,
     diagnostics: Res<DiagnosticsStore>,
     mut query: Query<&mut Text, With<TextChanges>>,
 ) {
+    time_history.push_front(time.elapsed());
+    time_history.truncate(120);
+    let avg_fps = (time_history.len() as f64)
+        / (time_history.front().copied().unwrap_or_default()
+            - time_history.back().copied().unwrap_or_default())
+        .as_secs_f64()
+        .max(0.0001);
+    fps_history.push_front(avg_fps);
+    fps_history.truncate(120);
+    let fps_variance = std_deviation(fps_history.make_contiguous()).unwrap_or_default();
+
     for mut text in &mut query {
         let mut fps = 0.0;
         if let Some(fps_diagnostic) = diagnostics.get(&FrameTimeDiagnosticsPlugin::FPS) {
@@ -244,12 +267,44 @@ fn change_text_system(
             }
         }
 
-        text.sections[0].value = format!(
-            "This text changes in the bottom right - {fps:.1} fps, {frame_time:.3} ms/frame",
+        text.sections[0].value =
+            format!("{avg_fps:.1} avg fps, {fps_variance:.1} frametime variance",);
+
+        text.sections[1].value = format!(
+            "\nThis text changes in the bottom right - {fps:.1} fps, {frame_time:.3} ms/frame",
         );
 
-        text.sections[3].value = format!("{fps:.1}");
+        text.sections[4].value = format!("{fps:.1}");
 
-        text.sections[5].value = format!("{frame_time:.3}");
+        text.sections[6].value = format!("{frame_time:.3}");
+    }
+}
+
+fn mean(data: &[f64]) -> Option<f64> {
+    let sum = data.iter().sum::<f64>();
+    let count = data.len();
+
+    match count {
+        positive if positive > 0 => Some(sum / count as f64),
+        _ => None,
+    }
+}
+
+fn std_deviation(data: &[f64]) -> Option<f64> {
+    match (mean(data), data.len()) {
+        (Some(data_mean), count) if count > 0 => {
+            let variance = data
+                .iter()
+                .map(|value| {
+                    let diff = data_mean - *value;
+
+                    diff * diff
+                })
+                .sum::<f64>()
+                / count as f64;
+
+            Some(variance.sqrt())
+        }
+        _ => None,
     }
 }

From 75343ef5842a51e6e5e3b9eeb9ed31422d2f1f48 Mon Sep 17 00:00:00 2001
From: Gino Valente <49806985+MrGVSV@users.noreply.github.com>
Date: Tue, 10 Sep 2024 16:39:05 -0700
Subject: [PATCH 3/4] bevy_reflect: Mention `FunctionRegistry` in
 `bevy_reflect::func` docs (#15147)

# Objective

The module docs for `bevy_reflect::func` don't mention the
`FunctionRegistry`.

## Solution

Add a section about the `FunctionRegistry` to the module-level
documentation.

## Testing

You can test locally by running:

```
cargo test --doc --package bevy_reflect --all-features
```
---
 crates/bevy_reflect/src/func/mod.rs | 31 ++++++++++++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_reflect/src/func/mod.rs b/crates/bevy_reflect/src/func/mod.rs
index a924231ff4cab..770f0fa0c2633 100644
--- a/crates/bevy_reflect/src/func/mod.rs
+++ b/crates/bevy_reflect/src/func/mod.rs
@@ -57,7 +57,7 @@
 //! Closures, on the other hand, are special functions that do capture their environment.
 //! These are always defined with anonymous function syntax.
 //!
-//! ```rust
+//! ```
 //! // A closure that captures an immutable reference to a variable
 //! let c = 123;
 //! let add = |a: i32, b: i32| a + b + c;
@@ -94,6 +94,35 @@
 //! For other functions that don't conform to one of the above signatures,
 //! [`DynamicFunction`] and [`DynamicFunctionMut`] can instead be created manually.
 //!
+//! # Function Registration
+//!
+//! This module also provides a [`FunctionRegistry`] that can be used to register functions and closures
+//! by name so that they may be retrieved and called dynamically.
+//!
+//! ```
+//! # use bevy_reflect::func::{ArgList, FunctionRegistry};
+//! fn add(a: i32, b: i32) -> i32 {
+//!     a + b
+//! }
+//!
+//! let mut registry = FunctionRegistry::default();
+//!
+//! // You can register functions and methods by their `std::any::type_name`:
+//! registry.register(add).unwrap();
+//!
+//! // Or you can register them by a custom name:
+//! registry.register_with_name("mul", |a: i32, b: i32| a * b).unwrap();
+//!
+//! // You can then retrieve and call these functions by name:
+//! let reflect_add = registry.get(std::any::type_name_of_val(&add)).unwrap();
+//! let value = reflect_add.call(ArgList::default().push_owned(10_i32).push_owned(5_i32)).unwrap();
+//! assert_eq!(value.unwrap_owned().try_downcast_ref::<i32>(), Some(&15));
+//!
+//! let reflect_mul = registry.get("mul").unwrap();
+//! let value = reflect_mul.call(ArgList::default().push_owned(10_i32).push_owned(5_i32)).unwrap();
+//! assert_eq!(value.unwrap_owned().try_downcast_ref::<i32>(), Some(&50));
+//! ```
+//!
 //! [`PartialReflect`]: crate::PartialReflect
 //! [`Reflect`]: crate::Reflect
 //! [lack of variadic generics]: https://poignardazur.github.io/2024/05/25/report-on-rustnl-variadics/

From 8e7ef64bb16347ea0258ac66790f950cacd04d7b Mon Sep 17 00:00:00 2001
From: Rich Churcher <rich.churcher@gmail.com>
Date: Wed, 11 Sep 2024 11:40:48 +1200
Subject: [PATCH 4/4] Split zoom/orbit into separate examples (#15135)

# Objective

As previously discussed, split camera zoom and orbiting examples to keep
things less cluttered. See discussion on #15092 for context.
---
 Cargo.toml                         |  13 ++-
 examples/README.md                 |   3 +-
 examples/camera/camera_orbit.rs    | 163 +++++++++++++++++++++++++++++
 examples/camera/projection_zoom.rs |  82 +++------------
 4 files changed, 189 insertions(+), 72 deletions(-)
 create mode 100644 examples/camera/camera_orbit.rs

diff --git a/Cargo.toml b/Cargo.toml
index 634ef2391dd88..0609e02c33e14 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3251,7 +3251,18 @@ doc-scrape-examples = true
 
 [package.metadata.example.projection_zoom]
 name = "Projection Zoom"
-description = "Shows how to zoom and orbit orthographic and perspective projection cameras."
+description = "Shows how to zoom orthographic and perspective projection cameras."
+category = "Camera"
+wasm = true
+
+[[example]]
+name = "camera_orbit"
+path = "examples/camera/camera_orbit.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.camera_orbit]
+name = "Camera Orbit"
+description = "Shows how to orbit a static scene using pitch, yaw, and roll."
 category = "Camera"
 wasm = true
 
diff --git a/examples/README.md b/examples/README.md
index 542a82764048d..92e03582aa205 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -254,8 +254,9 @@ Example | Description
 Example | Description
 --- | ---
 [2D top-down camera](../examples/camera/2d_top_down_camera.rs) | A 2D top-down camera smoothly following player movements
+[Camera Orbit](../examples/camera/camera_orbit.rs) | Shows how to orbit a static scene using pitch, yaw, and roll.
 [First person view model](../examples/camera/first_person_view_model.rs) | A first-person camera that uses a world model and a view model with different field of views (FOV)
-[Projection Zoom](../examples/camera/projection_zoom.rs) | Shows how to zoom and orbit orthographic and perspective projection cameras.
+[Projection Zoom](../examples/camera/projection_zoom.rs) | Shows how to zoom orthographic and perspective projection cameras.
 
 ## Dev tools
 
diff --git a/examples/camera/camera_orbit.rs b/examples/camera/camera_orbit.rs
new file mode 100644
index 0000000000000..c0e80e636a0a1
--- /dev/null
+++ b/examples/camera/camera_orbit.rs
@@ -0,0 +1,163 @@
+//! Shows how to orbit camera around a static scene using pitch, yaw, and roll.
+
+use std::{f32::consts::FRAC_PI_2, ops::Range};
+
+use bevy::prelude::*;
+
+#[derive(Debug, Default, Resource)]
+struct CameraSettings {
+    pub orbit_distance: f32,
+    // Multiply keyboard inputs by this factor
+    pub orbit_speed: f32,
+    // Clamp pitch to this range
+    pub pitch_range: Range<f32>,
+}
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .init_resource::<CameraSettings>()
+        .add_systems(Startup, (setup, instructions))
+        .add_systems(Update, orbit)
+        .run();
+}
+
+/// Set up a simple 3D scene
+fn setup(
+    mut camera_settings: ResMut<CameraSettings>,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    // Limiting pitch stops some unexpected rotation past 90° up or down.
+    let pitch_limit = FRAC_PI_2 - 0.01;
+
+    camera_settings.orbit_distance = 10.0;
+    camera_settings.orbit_speed = 1.0;
+    camera_settings.pitch_range = -pitch_limit..pitch_limit;
+
+    commands.spawn((
+        Name::new("Camera"),
+        Camera3dBundle {
+            transform: Transform::from_xyz(5.0, 5.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+            ..default()
+        },
+    ));
+
+    commands.spawn((
+        Name::new("Plane"),
+        PbrBundle {
+            mesh: meshes.add(Plane3d::default().mesh().size(5.0, 5.0)),
+            material: materials.add(StandardMaterial {
+                base_color: Color::srgb(0.3, 0.5, 0.3),
+                // Turning off culling keeps the plane visible when viewed from beneath.
+                cull_mode: None,
+                ..default()
+            }),
+            ..default()
+        },
+    ));
+
+    commands.spawn((
+        Name::new("Cube"),
+        PbrBundle {
+            mesh: meshes.add(Cuboid::default()),
+            material: materials.add(Color::srgb(0.8, 0.7, 0.6)),
+            transform: Transform::from_xyz(1.5, 0.51, 1.5),
+            ..default()
+        },
+    ));
+
+    commands.spawn((
+        Name::new("Light"),
+        PointLightBundle {
+            transform: Transform::from_xyz(3.0, 8.0, 5.0),
+            ..default()
+        },
+    ));
+}
+
+fn instructions(mut commands: Commands) {
+    commands
+        .spawn((
+            Name::new("Instructions"),
+            NodeBundle {
+                style: Style {
+                    align_items: AlignItems::Start,
+                    flex_direction: FlexDirection::Column,
+                    justify_content: JustifyContent::Start,
+                    width: Val::Percent(100.),
+                    ..default()
+                },
+                ..default()
+            },
+        ))
+        .with_children(|parent| {
+            parent.spawn(TextBundle::from_section(
+                "W or S: pitch",
+                TextStyle::default(),
+            ));
+            parent.spawn(TextBundle::from_section(
+                "A or D: yaw",
+                TextStyle::default(),
+            ));
+            parent.spawn(TextBundle::from_section(
+                "Q or E: roll",
+                TextStyle::default(),
+            ));
+        });
+}
+
+fn orbit(
+    mut camera: Query<&mut Transform, With<Camera>>,
+    camera_settings: Res<CameraSettings>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    time: Res<Time>,
+) {
+    let mut transform = camera.single_mut();
+
+    let mut delta_pitch = 0.0;
+    let mut delta_roll = 0.0;
+    let mut delta_yaw = 0.0;
+
+    if keyboard_input.pressed(KeyCode::KeyW) {
+        delta_pitch += camera_settings.orbit_speed;
+    }
+    if keyboard_input.pressed(KeyCode::KeyS) {
+        delta_pitch -= camera_settings.orbit_speed;
+    }
+
+    if keyboard_input.pressed(KeyCode::KeyQ) {
+        delta_roll -= camera_settings.orbit_speed;
+    }
+    if keyboard_input.pressed(KeyCode::KeyE) {
+        delta_roll += camera_settings.orbit_speed;
+    }
+
+    if keyboard_input.pressed(KeyCode::KeyA) {
+        delta_yaw -= camera_settings.orbit_speed;
+    }
+    if keyboard_input.pressed(KeyCode::KeyD) {
+        delta_yaw += camera_settings.orbit_speed;
+    }
+
+    // Incorporating the delta time between calls prevents this from being framerate-bound.
+    delta_pitch *= time.delta_seconds();
+    delta_roll *= time.delta_seconds();
+    delta_yaw *= time.delta_seconds();
+
+    // Obtain the existing pitch, yaw, and roll values from the transform.
+    let (yaw, pitch, roll) = transform.rotation.to_euler(EulerRot::YXZ);
+
+    // Establish the new yaw and pitch, preventing the pitch value from exceeding our limits.
+    let pitch = (pitch + delta_pitch).clamp(
+        camera_settings.pitch_range.start,
+        camera_settings.pitch_range.end,
+    );
+    let roll = roll + delta_roll;
+    let yaw = yaw + delta_yaw;
+    transform.rotation = Quat::from_euler(EulerRot::YXZ, yaw, pitch, roll);
+
+    // Adjust the translation to maintain the correct orientation toward the orbit target.
+    transform.translation = Vec3::ZERO - transform.forward() * camera_settings.orbit_distance;
+}
diff --git a/examples/camera/projection_zoom.rs b/examples/camera/projection_zoom.rs
index d490d971b8e98..108567ab55d58 100644
--- a/examples/camera/projection_zoom.rs
+++ b/examples/camera/projection_zoom.rs
@@ -1,17 +1,11 @@
-//! Shows how to zoom and orbit orthographic and perspective projection cameras.
+//! Shows how to zoom orthographic and perspective projection cameras.
 
-use std::{
-    f32::consts::{FRAC_PI_2, PI},
-    ops::Range,
-};
+use std::{f32::consts::PI, ops::Range};
 
 use bevy::{input::mouse::AccumulatedMouseScroll, prelude::*, render::camera::ScalingMode};
 
 #[derive(Debug, Default, Resource)]
 struct CameraSettings {
-    pub orbit_distance: f32,
-    // Multiply keyboard inputs by this factor
-    pub orbit_speed: f32,
     // Clamp fixed vertical scale to this range
     pub orthographic_zoom_range: Range<f32>,
     // Multiply mouse wheel inputs by this factor
@@ -20,8 +14,6 @@ struct CameraSettings {
     pub perspective_zoom_range: Range<f32>,
     // Multiply mouse wheel inputs by this factor
     pub perspective_zoom_speed: f32,
-    // Clamp pitch to this range
-    pub pitch_range: Range<f32>,
 }
 
 fn main() {
@@ -29,12 +21,13 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .init_resource::<CameraSettings>()
         .add_systems(Startup, (setup, instructions))
-        .add_systems(Update, (orbit, switch_projection, zoom))
+        .add_systems(Update, (switch_projection, zoom))
         .run();
 }
 
 /// Set up a simple 3D scene
 fn setup(
+    asset_server: Res<AssetServer>,
     mut camera_settings: ResMut<CameraSettings>,
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
@@ -51,17 +44,11 @@ fn setup(
     let min_zoom = 5.0;
     let max_zoom = 150.0;
 
-    // Limiting pitch stops some unexpected rotation past 90° up or down.
-    let pitch_limit = FRAC_PI_2 - 0.01;
-
-    camera_settings.orbit_distance = 10.0;
-    camera_settings.orbit_speed = 1.0;
     camera_settings.orthographic_zoom_range = min_zoom..max_zoom;
     camera_settings.orthographic_zoom_speed = 1.0;
     camera_settings.perspective_zoom_range = min_fov..max_fov;
     // Changes in FOV are much more noticeable due to its limited range in radians
     camera_settings.perspective_zoom_speed = 0.05;
-    camera_settings.pitch_range = -pitch_limit..pitch_limit;
 
     commands.spawn((
         Name::new("Camera"),
@@ -93,11 +80,13 @@ fn setup(
     ));
 
     commands.spawn((
-        Name::new("Cube"),
-        PbrBundle {
-            mesh: meshes.add(Cuboid::default()),
-            material: materials.add(Color::srgb(0.8, 0.7, 0.6)),
-            transform: Transform::from_xyz(1.5, 0.51, 1.5),
+        Name::new("Fox"),
+        SceneBundle {
+            scene: asset_server
+                .load(GltfAssetLabel::Scene(0).from_asset("models/animated/Fox.glb")),
+            // Note: the scale adjustment is purely an accident of our fox model, which renders
+            // HUGE unless mitigated!
+            transform: Transform::from_translation(Vec3::splat(0.0)).with_scale(Vec3::splat(0.025)),
             ..default()
         },
     ));
@@ -132,59 +121,12 @@ fn instructions(mut commands: Commands) {
                 TextStyle::default(),
             ));
             parent.spawn(TextBundle::from_section(
-                "W or S: pitch",
-                TextStyle::default(),
-            ));
-            parent.spawn(TextBundle::from_section(
-                "A or D: yaw",
+                "Space: switch between orthographic and perspective projections",
                 TextStyle::default(),
             ));
         });
 }
 
-fn orbit(
-    mut camera: Query<&mut Transform, With<Camera>>,
-    camera_settings: Res<CameraSettings>,
-    keyboard_input: Res<ButtonInput<KeyCode>>,
-    time: Res<Time>,
-) {
-    let mut transform = camera.single_mut();
-
-    let mut delta_pitch = 0.0;
-    let mut delta_yaw = 0.0;
-
-    if keyboard_input.pressed(KeyCode::KeyW) {
-        delta_pitch += camera_settings.orbit_speed;
-    }
-    if keyboard_input.pressed(KeyCode::KeyA) {
-        delta_yaw -= camera_settings.orbit_speed;
-    }
-    if keyboard_input.pressed(KeyCode::KeyS) {
-        delta_pitch -= camera_settings.orbit_speed;
-    }
-    if keyboard_input.pressed(KeyCode::KeyD) {
-        delta_yaw += camera_settings.orbit_speed;
-    }
-
-    // Incorporating the delta time between calls prevents this from being framerate-bound.
-    delta_pitch *= time.delta_seconds();
-    delta_yaw *= time.delta_seconds();
-
-    // Obtain the existing pitch, yaw, and roll values from the transform.
-    let (yaw, pitch, roll) = transform.rotation.to_euler(EulerRot::YXZ);
-
-    // Establish the new yaw and pitch, preventing the pitch value from exceeding our limits.
-    let pitch = (pitch + delta_pitch).clamp(
-        camera_settings.pitch_range.start,
-        camera_settings.pitch_range.end,
-    );
-    let yaw = yaw + delta_yaw;
-    transform.rotation = Quat::from_euler(EulerRot::YXZ, yaw, pitch, roll);
-
-    // Adjust the translation to maintain the correct orientation toward the orbit target.
-    transform.translation = Vec3::ZERO - transform.forward() * camera_settings.orbit_distance;
-}
-
 fn switch_projection(
     mut camera: Query<&mut Projection, With<Camera>>,
     camera_settings: Res<CameraSettings>,