From 68f85d8f1dff5481e1d8f274a78da27cfca443f5 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Thu, 10 Mar 2022 20:21:20 +0100
Subject: [PATCH 01/17] Add a scene viewer tool

---
 Cargo.toml                     |   2 +-
 tools/scene-viewer/Cargo.toml  |  14 ++
 tools/scene-viewer/src/main.rs | 233 +++++++++++++++++++++++++++++++++
 3 files changed, 248 insertions(+), 1 deletion(-)
 create mode 100644 tools/scene-viewer/Cargo.toml
 create mode 100644 tools/scene-viewer/src/main.rs

diff --git a/Cargo.toml b/Cargo.toml
index e03574f666edf..d5d5456f88c78 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@ repository = "https://github.com/bevyengine/bevy"
 
 [workspace]
 exclude = ["benches", "crates/bevy_ecs_compile_fail_tests"]
-members = ["crates/*", "examples/ios", "tools/ci", "errors"]
+members = ["crates/*", "examples/ios", "tools/ci", "tools/scene-viewer", "errors"]
 
 [features]
 default = [
diff --git a/tools/scene-viewer/Cargo.toml b/tools/scene-viewer/Cargo.toml
new file mode 100644
index 0000000000000..81a117d80f86e
--- /dev/null
+++ b/tools/scene-viewer/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "scene-viewer"
+version = "0.1.0"
+edition = "2021"
+description = "Scene viewer tool for Bevy"
+publish = false
+license = "MIT OR Apache-2.0"
+
+[features]
+default = []
+jpeg = ["bevy/jpeg"]
+
+[dependencies]
+bevy = { path = "../../" }
diff --git a/tools/scene-viewer/src/main.rs b/tools/scene-viewer/src/main.rs
new file mode 100644
index 0000000000000..4d95df14b705f
--- /dev/null
+++ b/tools/scene-viewer/src/main.rs
@@ -0,0 +1,233 @@
+use bevy::{asset::AssetServerSettings, input::mouse::MouseMotion, prelude::*};
+
+fn main() {
+    println!(
+        "
+Controls:
+    WSAD   - forward/back/strafe left/right
+    LShift - 'run'
+    E      - up
+    Q      - down
+    L      - animate light direction
+    U      - toggle shadows
+    5/6    - decrease/increase shadow projection width
+    7/8    - decrease/increase shadow projection height
+    9/0    - decrease/increase shadow projection near/far
+"
+    );
+    App::new()
+        .insert_resource(AmbientLight {
+            color: Color::WHITE,
+            brightness: 1.0 / 5.0f32,
+        })
+        .insert_resource(AssetServerSettings {
+            asset_folder: "../../".to_string(),
+            watch_for_changes: true,
+        })
+        .insert_resource(WindowDescriptor {
+            title: "bevy scene viewer".to_string(),
+            ..default()
+        })
+        .add_plugins(DefaultPlugins)
+        .add_startup_system(setup)
+        .add_system(update_lights)
+        .add_system(camera_controller)
+        .run();
+}
+
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
+    let scene_path = std::env::args()
+        .nth(1)
+        .unwrap_or_else(|| "assets/models/FlightHelmet/FlightHelmet.gltf#Scene0".to_string());
+    commands.spawn_scene(asset_server.load(&scene_path));
+    commands
+        .spawn_bundle(PerspectiveCameraBundle {
+            transform: Transform::from_xyz(0.0, 0.0, 1.0).looking_at(Vec3::ZERO, Vec3::Y),
+            ..default()
+        })
+        .insert(CameraController::default());
+    const HALF_SIZE: f32 = 1.0;
+    commands.spawn_bundle(DirectionalLightBundle {
+        directional_light: DirectionalLight {
+            shadow_projection: OrthographicProjection {
+                left: -HALF_SIZE,
+                right: HALF_SIZE,
+                bottom: -HALF_SIZE,
+                top: HALF_SIZE,
+                near: -10.0 * HALF_SIZE,
+                far: 10.0 * HALF_SIZE,
+                ..default()
+            },
+            shadows_enabled: false,
+            ..default()
+        },
+        ..default()
+    });
+}
+
+const SCALE_STEP: f32 = 0.1;
+
+fn update_lights(
+    key_input: Res<Input<KeyCode>>,
+    time: Res<Time>,
+    mut query: Query<(&mut Transform, &mut DirectionalLight)>,
+    mut animate_directional_light: Local<bool>,
+) {
+    let mut projection_adjustment = Vec3::ONE;
+    if key_input.just_pressed(KeyCode::Key5) {
+        projection_adjustment.x -= SCALE_STEP;
+    } else if key_input.just_pressed(KeyCode::Key6) {
+        projection_adjustment.x += SCALE_STEP;
+    } else if key_input.just_pressed(KeyCode::Key7) {
+        projection_adjustment.y -= SCALE_STEP;
+    } else if key_input.just_pressed(KeyCode::Key8) {
+        projection_adjustment.y += SCALE_STEP;
+    } else if key_input.just_pressed(KeyCode::Key9) {
+        projection_adjustment.z -= SCALE_STEP;
+    } else if key_input.just_pressed(KeyCode::Key0) {
+        projection_adjustment.z += SCALE_STEP;
+    }
+    for (_, mut light) in query.iter_mut() {
+        light.shadow_projection.left *= projection_adjustment.x;
+        light.shadow_projection.right *= projection_adjustment.x;
+        light.shadow_projection.bottom *= projection_adjustment.y;
+        light.shadow_projection.top *= projection_adjustment.y;
+        light.shadow_projection.near *= projection_adjustment.z;
+        light.shadow_projection.far *= projection_adjustment.z;
+        if key_input.just_pressed(KeyCode::U) {
+            light.shadows_enabled = !light.shadows_enabled;
+        }
+    }
+
+    if key_input.just_pressed(KeyCode::L) {
+        *animate_directional_light = !*animate_directional_light;
+    }
+    if *animate_directional_light {
+        for (mut transform, _) in query.iter_mut() {
+            transform.rotation = Quat::from_euler(
+                EulerRot::ZYX,
+                0.0,
+                time.seconds_since_startup() as f32 * std::f32::consts::TAU / 10.0,
+                -std::f32::consts::FRAC_PI_4,
+            );
+        }
+    }
+}
+
+#[derive(Component)]
+struct CameraController {
+    pub enabled: bool,
+    pub sensitivity: f32,
+    pub key_forward: KeyCode,
+    pub key_back: KeyCode,
+    pub key_left: KeyCode,
+    pub key_right: KeyCode,
+    pub key_up: KeyCode,
+    pub key_down: KeyCode,
+    pub key_run: KeyCode,
+    pub walk_speed: f32,
+    pub run_speed: f32,
+    pub friction: f32,
+    pub pitch: f32,
+    pub yaw: f32,
+    pub velocity: Vec3,
+}
+
+impl Default for CameraController {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            sensitivity: 0.5,
+            key_forward: KeyCode::W,
+            key_back: KeyCode::S,
+            key_left: KeyCode::A,
+            key_right: KeyCode::D,
+            key_up: KeyCode::E,
+            key_down: KeyCode::Q,
+            key_run: KeyCode::LShift,
+            walk_speed: 5.0,
+            run_speed: 15.0,
+            friction: 0.5,
+            pitch: 0.0,
+            yaw: 0.0,
+            velocity: Vec3::ZERO,
+        }
+    }
+}
+
+fn camera_controller(
+    time: Res<Time>,
+    mut mouse_events: EventReader<MouseMotion>,
+    key_input: Res<Input<KeyCode>>,
+    mut query: Query<(&mut Transform, &mut CameraController), With<Camera>>,
+) {
+    let dt = time.delta_seconds();
+
+    // Handle mouse input
+    let mut mouse_delta = Vec2::ZERO;
+    for mouse_event in mouse_events.iter() {
+        mouse_delta += mouse_event.delta;
+    }
+
+    for (mut transform, mut options) in query.iter_mut() {
+        if !options.enabled {
+            continue;
+        }
+
+        // Handle key input
+        let mut axis_input = Vec3::ZERO;
+        if key_input.pressed(options.key_forward) {
+            axis_input.z += 1.0;
+        }
+        if key_input.pressed(options.key_back) {
+            axis_input.z -= 1.0;
+        }
+        if key_input.pressed(options.key_right) {
+            axis_input.x += 1.0;
+        }
+        if key_input.pressed(options.key_left) {
+            axis_input.x -= 1.0;
+        }
+        if key_input.pressed(options.key_up) {
+            axis_input.y += 1.0;
+        }
+        if key_input.pressed(options.key_down) {
+            axis_input.y -= 1.0;
+        }
+
+        // Apply movement update
+        if axis_input != Vec3::ZERO {
+            let max_speed = if key_input.pressed(options.key_run) {
+                options.run_speed
+            } else {
+                options.walk_speed
+            };
+            options.velocity = axis_input.normalize() * max_speed;
+        } else {
+            let friction = options.friction.clamp(0.0, 1.0);
+            options.velocity *= 1.0 - friction;
+            if options.velocity.length_squared() < 1e-6 {
+                options.velocity = Vec3::ZERO;
+            }
+        }
+        let forward = transform.forward();
+        let right = transform.right();
+        transform.translation += options.velocity.x * dt * right
+            + options.velocity.y * dt * Vec3::Y
+            + options.velocity.z * dt * forward;
+
+        if mouse_delta != Vec2::ZERO {
+            // Apply look update
+            let (pitch, yaw) = (
+                (options.pitch - mouse_delta.y * 0.5 * options.sensitivity * dt).clamp(
+                    -0.99 * std::f32::consts::FRAC_PI_2,
+                    0.99 * std::f32::consts::FRAC_PI_2,
+                ),
+                options.yaw - mouse_delta.x * options.sensitivity * dt,
+            );
+            transform.rotation = Quat::from_euler(EulerRot::ZYX, 0.0, yaw, pitch);
+            options.pitch = pitch;
+            options.yaw = yaw;
+        }
+    }
+}

From a004896ffa449dacc941809a796fff90f80ead90 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Fri, 11 Mar 2022 15:44:31 +0100
Subject: [PATCH 02/17] Move scene_viewer to examples/tools

---
 Cargo.toml                                         |  7 +++++--
 .../src/main.rs => examples/tools/scene_viewer.rs  |  2 +-
 tools/scene-viewer/Cargo.toml                      | 14 --------------
 3 files changed, 6 insertions(+), 17 deletions(-)
 rename tools/scene-viewer/src/main.rs => examples/tools/scene_viewer.rs (99%)
 delete mode 100644 tools/scene-viewer/Cargo.toml

diff --git a/Cargo.toml b/Cargo.toml
index d5d5456f88c78..677fa1d1cf92e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@ repository = "https://github.com/bevyengine/bevy"
 
 [workspace]
 exclude = ["benches", "crates/bevy_ecs_compile_fail_tests"]
-members = ["crates/*", "examples/ios", "tools/ci", "tools/scene-viewer", "errors"]
+members = ["crates/*", "examples/ios", "tools/ci", "errors"]
 
 [features]
 default = [
@@ -507,6 +507,10 @@ path = "examples/shader/compute_shader_game_of_life.rs"
 name = "bevymark"
 path = "examples/tools/bevymark.rs"
 
+[[example]]
+name = "scene_viewer"
+path = "examples/tools/scene_viewer.rs"
+
 # Transforms
 [[example]]
 name = "global_vs_local_translation"
@@ -527,7 +531,6 @@ path = "examples/transforms/transform.rs"
 [[example]]
 name = "translation"
 path = "examples/transforms/translation.rs"
-
 # UI (User Interface)
 [[example]]
 name = "button"
diff --git a/tools/scene-viewer/src/main.rs b/examples/tools/scene_viewer.rs
similarity index 99%
rename from tools/scene-viewer/src/main.rs
rename to examples/tools/scene_viewer.rs
index 4d95df14b705f..eea04a28d97fc 100644
--- a/tools/scene-viewer/src/main.rs
+++ b/examples/tools/scene_viewer.rs
@@ -21,7 +21,7 @@ Controls:
             brightness: 1.0 / 5.0f32,
         })
         .insert_resource(AssetServerSettings {
-            asset_folder: "../../".to_string(),
+            asset_folder: std::env::var("CARGO_MANIFEST_DIR").unwrap(),
             watch_for_changes: true,
         })
         .insert_resource(WindowDescriptor {
diff --git a/tools/scene-viewer/Cargo.toml b/tools/scene-viewer/Cargo.toml
deleted file mode 100644
index 81a117d80f86e..0000000000000
--- a/tools/scene-viewer/Cargo.toml
+++ /dev/null
@@ -1,14 +0,0 @@
-[package]
-name = "scene-viewer"
-version = "0.1.0"
-edition = "2021"
-description = "Scene viewer tool for Bevy"
-publish = false
-license = "MIT OR Apache-2.0"
-
-[features]
-default = []
-jpeg = ["bevy/jpeg"]
-
-[dependencies]
-bevy = { path = "../../" }

From e054934f2b783ae6d7ce0279e7774d6edd7b9a93 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Fri, 11 Mar 2022 15:46:57 +0100
Subject: [PATCH 03/17] Document the scene_viewer example tool

---
 examples/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/examples/README.md b/examples/README.md
index 9f2e01ae800e9..805f058021b53 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -247,6 +247,7 @@ Example | File | Description
 Example | File | Description
 --- | --- | ---
 `bevymark` | [`tools/bevymark.rs`](./tools/bevymark.rs) | A heavy sprite rendering workload to benchmark your system with Bevy
+`scene_viewer` | [`tools/scene_viewer.rs`](./tools/scene_viewer.rs) | A simple way to view glTF models with Bevy. Just run `cargo run --release --example scene_viewer -- /path/to/model.gltf#Scene0`, replacing the path as appropriate. With no arguments it will load the FieldHelmet glTF model from the repository assets subdirectory.
 
 ## Transforms
 

From 1809a018abc15633558713cb307a816062bb4231 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Sat, 12 Mar 2022 15:18:00 +0100
Subject: [PATCH 04/17] scene_viewer: Use the camera from the scene, else spawn
 one that focuses the scene

---
 examples/tools/scene_viewer.rs | 150 +++++++++++++++++++++++++++------
 1 file changed, 126 insertions(+), 24 deletions(-)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index eea04a28d97fc..ef3ddd7652024 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -1,4 +1,12 @@
-use bevy::{asset::AssetServerSettings, input::mouse::MouseMotion, prelude::*};
+use bevy::{
+    asset::{AssetServerSettings, LoadState},
+    input::mouse::MouseMotion,
+    prelude::*,
+    render::{
+        camera::{CameraPlugin, CameraProjection},
+        primitives::{Aabb, Frustum},
+    },
+};
 
 fn main() {
     println!(
@@ -30,39 +38,133 @@ Controls:
         })
         .add_plugins(DefaultPlugins)
         .add_startup_system(setup)
+        .add_system_to_stage(CoreStage::PreUpdate, scene_load_check)
+        .add_system_to_stage(CoreStage::PreUpdate, camera_spawn_check)
+        .add_system(camera_controller_check.label("camera_controller_check"))
         .add_system(update_lights)
-        .add_system(camera_controller)
+        .add_system(camera_controller.after("camera_controller_check"))
         .run();
 }
 
+struct SceneHandle {
+    handle: Option<Handle<Scene>>,
+    has_camera: bool,
+}
+
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     let scene_path = std::env::args()
         .nth(1)
         .unwrap_or_else(|| "assets/models/FlightHelmet/FlightHelmet.gltf#Scene0".to_string());
-    commands.spawn_scene(asset_server.load(&scene_path));
-    commands
-        .spawn_bundle(PerspectiveCameraBundle {
-            transform: Transform::from_xyz(0.0, 0.0, 1.0).looking_at(Vec3::ZERO, Vec3::Y),
-            ..default()
-        })
-        .insert(CameraController::default());
-    const HALF_SIZE: f32 = 1.0;
-    commands.spawn_bundle(DirectionalLightBundle {
-        directional_light: DirectionalLight {
-            shadow_projection: OrthographicProjection {
-                left: -HALF_SIZE,
-                right: HALF_SIZE,
-                bottom: -HALF_SIZE,
-                top: HALF_SIZE,
-                near: -10.0 * HALF_SIZE,
-                far: 10.0 * HALF_SIZE,
+    commands.insert_resource(SceneHandle {
+        handle: Some(asset_server.load(&scene_path)),
+        has_camera: false,
+    });
+}
+
+fn scene_load_check(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut scenes: ResMut<Assets<Scene>>,
+    mut scene_handle: ResMut<SceneHandle>,
+) {
+    if scene_handle.handle.is_some()
+        && asset_server.get_load_state(scene_handle.handle.as_ref().unwrap()) == LoadState::Loaded
+    {
+        let mut to_remove = Vec::new();
+
+        let scene = scenes
+            .get_mut(scene_handle.handle.as_ref().unwrap())
+            .unwrap();
+        let mut query = scene.world.query::<(Entity, &Camera)>();
+        for (entity, camera) in query.iter(&scene.world) {
+            match camera.name.as_deref() {
+                Some(CameraPlugin::CAMERA_3D) if !scene_handle.has_camera => {
+                    scene_handle.has_camera = true;
+                    println!("Model has a 3D camera");
+                }
+                Some(CameraPlugin::CAMERA_2D) if !scene_handle.has_camera => {
+                    scene_handle.has_camera = true;
+                    println!("Model has a 2D camera");
+                }
+                _ => {
+                    to_remove.push(entity);
+                }
+            }
+        }
+
+        for entity in to_remove.drain(..) {
+            scene.world.entity_mut(entity).despawn_recursive();
+        }
+
+        commands.spawn_scene(scene_handle.handle.take().unwrap());
+        println!("Spawning scene");
+    }
+}
+
+fn camera_spawn_check(
+    mut commands: Commands,
+    mut scene_handle: ResMut<SceneHandle>,
+    meshes: Query<(&GlobalTransform, Option<&Aabb>), With<Handle<Mesh>>>,
+) {
+    // scene_handle.handle.is_none() indicates that the scene has been spawned
+    // If the scene did not contain a camera, find an approximate bounding box of the scene from
+    // its meshes and spawn a camera that fits it in view
+    if scene_handle.handle.is_none() && !scene_handle.has_camera {
+        if meshes.iter().any(|(_, maybe_aabb)| maybe_aabb.is_none()) {
+            return;
+        }
+
+        let mut min = Vec3::splat(f32::MAX);
+        let mut max = Vec3::splat(f32::MIN);
+        for (transform, maybe_aabb) in meshes.iter() {
+            let aabb = maybe_aabb.unwrap();
+            // This isn't fully correct for finding the min/max but should be good enough
+            min = min.min(transform.mul_vec3(aabb.min()));
+            max = max.max(transform.mul_vec3(aabb.max()));
+        }
+
+        let size = (max - min).length();
+        let center = 0.5 * (max + min);
+
+        let transform = Transform::from_translation(center + size * Vec3::new(1.0, 0.5, 1.0))
+            .looking_at(center, Vec3::Y);
+        let view = transform.compute_matrix();
+        let mut perspective_projection = PerspectiveProjection::default();
+        perspective_projection.far = perspective_projection.far.max(size * 10.0);
+        let view_projection = view.inverse() * perspective_projection.get_projection_matrix();
+        let frustum = Frustum::from_view_projection(
+            &view_projection,
+            &transform.translation,
+            &transform.back(),
+            perspective_projection.far(),
+        );
+
+        println!("Spawning a 3D perspective camera");
+        commands.spawn_bundle(PerspectiveCameraBundle {
+            camera: Camera {
+                name: Some(CameraPlugin::CAMERA_3D.to_string()),
+                near: perspective_projection.near,
+                far: perspective_projection.far,
                 ..default()
             },
-            shadows_enabled: false,
-            ..default()
-        },
-        ..default()
-    });
+            perspective_projection,
+            frustum,
+            transform,
+            ..PerspectiveCameraBundle::new_3d()
+        });
+
+        scene_handle.has_camera = true;
+    }
+}
+
+// TODO: Register all types in CameraController so that it can be registered
+fn camera_controller_check(
+    mut commands: Commands,
+    camera: Query<Entity, (With<Camera>, Without<CameraController>)>,
+) {
+    if let Ok(entity) = camera.get_single() {
+        commands.entity(entity).insert(CameraController::default());
+    }
 }
 
 const SCALE_STEP: f32 = 0.1;

From b69d915c44464b7ec65f96d0745d5f0f589fde13 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Sat, 12 Mar 2022 15:36:17 +0100
Subject: [PATCH 05/17] scene_viewer: Update on top of camera marker changes

---
 examples/tools/scene_viewer.rs | 34 ++++++++++------------------------
 1 file changed, 10 insertions(+), 24 deletions(-)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index ef3ddd7652024..49bd1b932317a 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -3,7 +3,7 @@ use bevy::{
     input::mouse::MouseMotion,
     prelude::*,
     render::{
-        camera::{CameraPlugin, CameraProjection},
+        camera::{Camera2d, Camera3d, CameraProjection},
         primitives::{Aabb, Frustum},
     },
 };
@@ -70,31 +70,18 @@ fn scene_load_check(
     if scene_handle.handle.is_some()
         && asset_server.get_load_state(scene_handle.handle.as_ref().unwrap()) == LoadState::Loaded
     {
-        let mut to_remove = Vec::new();
-
         let scene = scenes
             .get_mut(scene_handle.handle.as_ref().unwrap())
             .unwrap();
-        let mut query = scene.world.query::<(Entity, &Camera)>();
-        for (entity, camera) in query.iter(&scene.world) {
-            match camera.name.as_deref() {
-                Some(CameraPlugin::CAMERA_3D) if !scene_handle.has_camera => {
-                    scene_handle.has_camera = true;
-                    println!("Model has a 3D camera");
-                }
-                Some(CameraPlugin::CAMERA_2D) if !scene_handle.has_camera => {
-                    scene_handle.has_camera = true;
-                    println!("Model has a 2D camera");
-                }
-                _ => {
-                    to_remove.push(entity);
-                }
-            }
-        }
-
-        for entity in to_remove.drain(..) {
-            scene.world.entity_mut(entity).despawn_recursive();
-        }
+        let mut query = scene
+            .world
+            .query::<(Option<&Camera2d>, Option<&Camera3d>)>();
+        scene_handle.has_camera =
+            query
+                .iter(&scene.world)
+                .any(|(maybe_camera2d, maybe_camera3d)| {
+                    maybe_camera2d.is_some() || maybe_camera3d.is_some()
+                });
 
         commands.spawn_scene(scene_handle.handle.take().unwrap());
         println!("Spawning scene");
@@ -142,7 +129,6 @@ fn camera_spawn_check(
         println!("Spawning a 3D perspective camera");
         commands.spawn_bundle(PerspectiveCameraBundle {
             camera: Camera {
-                name: Some(CameraPlugin::CAMERA_3D.to_string()),
                 near: perspective_projection.near,
                 far: perspective_projection.far,
                 ..default()

From 774273c37e52f94bfbb9cdd7f91d374d617a4831 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Sat, 12 Mar 2022 23:46:48 +0100
Subject: [PATCH 06/17] scene_viewer: Improve scene bounds calculation

---
 examples/tools/scene_viewer.rs | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index 49bd1b932317a..e1989bb5ca593 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -4,7 +4,7 @@ use bevy::{
     prelude::*,
     render::{
         camera::{Camera2d, Camera3d, CameraProjection},
-        primitives::{Aabb, Frustum},
+        primitives::{Aabb, Frustum, Sphere},
     },
 };
 
@@ -105,9 +105,16 @@ fn camera_spawn_check(
         let mut max = Vec3::splat(f32::MIN);
         for (transform, maybe_aabb) in meshes.iter() {
             let aabb = maybe_aabb.unwrap();
-            // This isn't fully correct for finding the min/max but should be good enough
-            min = min.min(transform.mul_vec3(aabb.min()));
-            max = max.max(transform.mul_vec3(aabb.max()));
+            // If the Aabb had not been rotated, applying the non-uniform scale would produce the
+            // correct bounds. However, it could very well be rotated and so we first convert to
+            // a Sphere, and then back to an Aabb to find the conservative min and max points.
+            let sphere = Sphere {
+                center: transform.mul_vec3(aabb.center),
+                radius: (transform.scale * aabb.half_extents).length(),
+            };
+            let aabb = Aabb::from(sphere);
+            min = min.min(aabb.min());
+            max = max.max(aabb.max());
         }
 
         let size = (max - min).length();

From 37a111e49f5428e8b8834a7ed60b41971901c713 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Sat, 12 Mar 2022 23:49:41 +0100
Subject: [PATCH 07/17] scene_viewer: Spawn a directional light if there is
 none in the scene

---
 examples/tools/scene_viewer.rs | 97 +++++++++++++++++++++++++---------
 1 file changed, 71 insertions(+), 26 deletions(-)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index e1989bb5ca593..4d4656304b535 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -49,6 +49,7 @@ Controls:
 struct SceneHandle {
     handle: Option<Handle<Scene>>,
     has_camera: bool,
+    has_light: bool,
 }
 
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
@@ -58,6 +59,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     commands.insert_resource(SceneHandle {
         handle: Some(asset_server.load(&scene_path)),
         has_camera: false,
+        has_light: false,
     });
 }
 
@@ -82,6 +84,15 @@ fn scene_load_check(
                 .any(|(maybe_camera2d, maybe_camera3d)| {
                     maybe_camera2d.is_some() || maybe_camera3d.is_some()
                 });
+        let mut query = scene
+            .world
+            .query::<(Option<&DirectionalLight>, Option<&PointLight>)>();
+        scene_handle.has_light =
+            query
+                .iter(&scene.world)
+                .any(|(maybe_directional_light, maybe_point_light)| {
+                    maybe_directional_light.is_some() || maybe_point_light.is_some()
+                });
 
         commands.spawn_scene(scene_handle.handle.take().unwrap());
         println!("Spawning scene");
@@ -96,7 +107,7 @@ fn camera_spawn_check(
     // scene_handle.handle.is_none() indicates that the scene has been spawned
     // If the scene did not contain a camera, find an approximate bounding box of the scene from
     // its meshes and spawn a camera that fits it in view
-    if scene_handle.handle.is_none() && !scene_handle.has_camera {
+    if scene_handle.handle.is_none() && (!scene_handle.has_camera || !scene_handle.has_light) {
         if meshes.iter().any(|(_, maybe_aabb)| maybe_aabb.is_none()) {
             return;
         }
@@ -118,35 +129,69 @@ fn camera_spawn_check(
         }
 
         let size = (max - min).length();
-        let center = 0.5 * (max + min);
+        let aabb = Aabb::from_min_max(min, max);
+
+        if !scene_handle.has_camera {
+            let transform =
+                Transform::from_translation(aabb.center + size * Vec3::new(0.5, 0.25, 0.5))
+                    .looking_at(aabb.center, Vec3::Y);
+            let view = transform.compute_matrix();
+            let mut perspective_projection = PerspectiveProjection::default();
+            perspective_projection.far = perspective_projection.far.max(size * 10.0);
+            let view_projection = view.inverse() * perspective_projection.get_projection_matrix();
+            let frustum = Frustum::from_view_projection(
+                &view_projection,
+                &transform.translation,
+                &transform.back(),
+                perspective_projection.far(),
+            );
 
-        let transform = Transform::from_translation(center + size * Vec3::new(1.0, 0.5, 1.0))
-            .looking_at(center, Vec3::Y);
-        let view = transform.compute_matrix();
-        let mut perspective_projection = PerspectiveProjection::default();
-        perspective_projection.far = perspective_projection.far.max(size * 10.0);
-        let view_projection = view.inverse() * perspective_projection.get_projection_matrix();
-        let frustum = Frustum::from_view_projection(
-            &view_projection,
-            &transform.translation,
-            &transform.back(),
-            perspective_projection.far(),
-        );
+            println!("Spawning a 3D perspective camera");
+            commands.spawn_bundle(PerspectiveCameraBundle {
+                camera: Camera {
+                    near: perspective_projection.near,
+                    far: perspective_projection.far,
+                    ..default()
+                },
+                perspective_projection,
+                frustum,
+                transform,
+                ..PerspectiveCameraBundle::new_3d()
+            });
 
-        println!("Spawning a 3D perspective camera");
-        commands.spawn_bundle(PerspectiveCameraBundle {
-            camera: Camera {
-                near: perspective_projection.near,
-                far: perspective_projection.far,
+            scene_handle.has_camera = true;
+        }
+
+        if !scene_handle.has_light {
+            // The same approach as above but now for the scene
+            let sphere = Sphere {
+                center: aabb.center,
+                radius: aabb.half_extents.length(),
+            };
+            let aabb = Aabb::from(sphere);
+            let min = aabb.min();
+            let max = aabb.max();
+
+            println!("Spawning a directional light");
+            commands.spawn_bundle(DirectionalLightBundle {
+                directional_light: DirectionalLight {
+                    shadow_projection: OrthographicProjection {
+                        left: min.x,
+                        right: max.x,
+                        bottom: min.y,
+                        top: max.y,
+                        near: min.z,
+                        far: max.z,
+                        ..default()
+                    },
+                    shadows_enabled: false,
+                    ..default()
+                },
                 ..default()
-            },
-            perspective_projection,
-            frustum,
-            transform,
-            ..PerspectiveCameraBundle::new_3d()
-        });
+            });
 
-        scene_handle.has_camera = true;
+            scene_handle.has_light = true;
+        }
     }
 }
 

From e84d4584e72abe5b0fd4ef907ba3c0f1c3b06ee1 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Sun, 13 Mar 2022 00:09:06 +0100
Subject: [PATCH 08/17] scene_viewer: Tweak light animation period

---
 examples/tools/scene_viewer.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index 4d4656304b535..9bfb0b9da61e6 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -247,7 +247,7 @@ fn update_lights(
             transform.rotation = Quat::from_euler(
                 EulerRot::ZYX,
                 0.0,
-                time.seconds_since_startup() as f32 * std::f32::consts::TAU / 10.0,
+                time.seconds_since_startup() as f32 * std::f32::consts::TAU / 30.0,
                 -std::f32::consts::FRAC_PI_4,
             );
         }

From 5f49554eb2d44bd9b4ea080d0325791043bd68a7 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Sun, 13 Mar 2022 00:10:28 +0100
Subject: [PATCH 09/17] scene_viewer: More safety

---
 examples/tools/scene_viewer.rs | 59 +++++++++++++++++-----------------
 1 file changed, 30 insertions(+), 29 deletions(-)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index 9bfb0b9da61e6..947a2fdea4446 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -47,7 +47,8 @@ Controls:
 }
 
 struct SceneHandle {
-    handle: Option<Handle<Scene>>,
+    handle: Handle<Scene>,
+    is_loaded: bool,
     has_camera: bool,
     has_light: bool,
 }
@@ -57,7 +58,8 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
         .nth(1)
         .unwrap_or_else(|| "assets/models/FlightHelmet/FlightHelmet.gltf#Scene0".to_string());
     commands.insert_resource(SceneHandle {
-        handle: Some(asset_server.load(&scene_path)),
+        handle: asset_server.load(&scene_path),
+        is_loaded: false,
         has_camera: false,
         has_light: false,
     });
@@ -69,33 +71,33 @@ fn scene_load_check(
     mut scenes: ResMut<Assets<Scene>>,
     mut scene_handle: ResMut<SceneHandle>,
 ) {
-    if scene_handle.handle.is_some()
-        && asset_server.get_load_state(scene_handle.handle.as_ref().unwrap()) == LoadState::Loaded
+    if !scene_handle.is_loaded
+        && asset_server.get_load_state(&scene_handle.handle) == LoadState::Loaded
     {
-        let scene = scenes
-            .get_mut(scene_handle.handle.as_ref().unwrap())
-            .unwrap();
-        let mut query = scene
-            .world
-            .query::<(Option<&Camera2d>, Option<&Camera3d>)>();
-        scene_handle.has_camera =
-            query
-                .iter(&scene.world)
-                .any(|(maybe_camera2d, maybe_camera3d)| {
-                    maybe_camera2d.is_some() || maybe_camera3d.is_some()
-                });
-        let mut query = scene
-            .world
-            .query::<(Option<&DirectionalLight>, Option<&PointLight>)>();
-        scene_handle.has_light =
-            query
-                .iter(&scene.world)
-                .any(|(maybe_directional_light, maybe_point_light)| {
-                    maybe_directional_light.is_some() || maybe_point_light.is_some()
-                });
+        if let Some(scene) = scenes.get_mut(&scene_handle.handle) {
+            let mut query = scene
+                .world
+                .query::<(Option<&Camera2d>, Option<&Camera3d>)>();
+            scene_handle.has_camera =
+                query
+                    .iter(&scene.world)
+                    .any(|(maybe_camera2d, maybe_camera3d)| {
+                        maybe_camera2d.is_some() || maybe_camera3d.is_some()
+                    });
+            let mut query = scene
+                .world
+                .query::<(Option<&DirectionalLight>, Option<&PointLight>)>();
+            scene_handle.has_light =
+                query
+                    .iter(&scene.world)
+                    .any(|(maybe_directional_light, maybe_point_light)| {
+                        maybe_directional_light.is_some() || maybe_point_light.is_some()
+                    });
 
-        commands.spawn_scene(scene_handle.handle.take().unwrap());
-        println!("Spawning scene");
+            commands.spawn_scene(scene_handle.handle.clone_weak());
+            scene_handle.is_loaded = true;
+            println!("Spawning scene");
+        }
     }
 }
 
@@ -104,10 +106,9 @@ fn camera_spawn_check(
     mut scene_handle: ResMut<SceneHandle>,
     meshes: Query<(&GlobalTransform, Option<&Aabb>), With<Handle<Mesh>>>,
 ) {
-    // scene_handle.handle.is_none() indicates that the scene has been spawned
     // If the scene did not contain a camera, find an approximate bounding box of the scene from
     // its meshes and spawn a camera that fits it in view
-    if scene_handle.handle.is_none() && (!scene_handle.has_camera || !scene_handle.has_light) {
+    if scene_handle.is_loaded && (!scene_handle.has_camera || !scene_handle.has_light) {
         if meshes.iter().any(|(_, maybe_aabb)| maybe_aabb.is_none()) {
             return;
         }

From 6999677c3853515f3744f1046ea63051150d7f12 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Sun, 13 Mar 2022 17:57:12 +0100
Subject: [PATCH 10/17] scene_viewer: Add CameraController to the first camera
 found

---
 examples/tools/scene_viewer.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index 947a2fdea4446..1264d54e8f161 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -200,9 +200,14 @@ fn camera_spawn_check(
 fn camera_controller_check(
     mut commands: Commands,
     camera: Query<Entity, (With<Camera>, Without<CameraController>)>,
+    mut found_camera: Local<bool>,
 ) {
-    if let Ok(entity) = camera.get_single() {
+    if *found_camera {
+        return;
+    }
+    if let Some(entity) = camera.iter().next() {
         commands.entity(entity).insert(CameraController::default());
+        *found_camera = true;
     }
 }
 

From ec14e576b41244aa4e183ebcb0aac6cb931aec3b Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Sun, 13 Mar 2022 17:59:02 +0100
Subject: [PATCH 11/17] scene_viewer: Initialize CameraController yaw, pitch
 with the Transform

---
 examples/tools/scene_viewer.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index 1264d54e8f161..6d1878888e9b0 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -263,6 +263,7 @@ fn update_lights(
 #[derive(Component)]
 struct CameraController {
     pub enabled: bool,
+    pub initialized: bool,
     pub sensitivity: f32,
     pub key_forward: KeyCode,
     pub key_back: KeyCode,
@@ -283,6 +284,7 @@ impl Default for CameraController {
     fn default() -> Self {
         Self {
             enabled: true,
+            initialized: false,
             sensitivity: 0.5,
             key_forward: KeyCode::W,
             key_back: KeyCode::S,
@@ -316,6 +318,12 @@ fn camera_controller(
     }
 
     for (mut transform, mut options) in query.iter_mut() {
+        if !options.initialized {
+            let (_roll, yaw, pitch) = transform.rotation.to_euler(EulerRot::ZYX);
+            options.yaw = yaw;
+            options.pitch = pitch;
+            options.initialized = true;
+        }
         if !options.enabled {
             continue;
         }

From 6b8111479987c5f71bf442bea23fa62f84f82452 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Mon, 14 Mar 2022 23:09:53 +0100
Subject: [PATCH 12/17] scene_viewer: Wait until scene has actually been
 spawned before proceeding

---
 examples/tools/scene_viewer.rs | 62 ++++++++++++++++++++--------------
 1 file changed, 36 insertions(+), 26 deletions(-)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index 6d1878888e9b0..f8845d4034761 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -6,6 +6,7 @@ use bevy::{
         camera::{Camera2d, Camera3d, CameraProjection},
         primitives::{Aabb, Frustum, Sphere},
     },
+    scene::InstanceId,
 };
 
 fn main() {
@@ -48,6 +49,7 @@ Controls:
 
 struct SceneHandle {
     handle: Handle<Scene>,
+    instance_id: Option<InstanceId>,
     is_loaded: bool,
     has_camera: bool,
     has_light: bool,
@@ -59,6 +61,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
         .unwrap_or_else(|| "assets/models/FlightHelmet/FlightHelmet.gltf#Scene0".to_string());
     commands.insert_resource(SceneHandle {
         handle: asset_server.load(&scene_path),
+        instance_id: None,
         is_loaded: false,
         has_camera: false,
         has_light: false,
@@ -66,38 +69,45 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 }
 
 fn scene_load_check(
-    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut scenes: ResMut<Assets<Scene>>,
     mut scene_handle: ResMut<SceneHandle>,
+    mut scene_spawner: ResMut<SceneSpawner>,
 ) {
-    if !scene_handle.is_loaded
-        && asset_server.get_load_state(&scene_handle.handle) == LoadState::Loaded
-    {
-        if let Some(scene) = scenes.get_mut(&scene_handle.handle) {
-            let mut query = scene
-                .world
-                .query::<(Option<&Camera2d>, Option<&Camera3d>)>();
-            scene_handle.has_camera =
-                query
-                    .iter(&scene.world)
-                    .any(|(maybe_camera2d, maybe_camera3d)| {
-                        maybe_camera2d.is_some() || maybe_camera3d.is_some()
-                    });
-            let mut query = scene
-                .world
-                .query::<(Option<&DirectionalLight>, Option<&PointLight>)>();
-            scene_handle.has_light =
-                query
-                    .iter(&scene.world)
-                    .any(|(maybe_directional_light, maybe_point_light)| {
-                        maybe_directional_light.is_some() || maybe_point_light.is_some()
-                    });
+    match scene_handle.instance_id {
+        None if asset_server.get_load_state(&scene_handle.handle) == LoadState::Loaded => {
+            if let Some(scene) = scenes.get_mut(&scene_handle.handle) {
+                let mut query = scene
+                    .world
+                    .query::<(Option<&Camera2d>, Option<&Camera3d>)>();
+                scene_handle.has_camera =
+                    query
+                        .iter(&scene.world)
+                        .any(|(maybe_camera2d, maybe_camera3d)| {
+                            maybe_camera2d.is_some() || maybe_camera3d.is_some()
+                        });
+                let mut query = scene
+                    .world
+                    .query::<(Option<&DirectionalLight>, Option<&PointLight>)>();
+                scene_handle.has_light =
+                    query
+                        .iter(&scene.world)
+                        .any(|(maybe_directional_light, maybe_point_light)| {
+                            maybe_directional_light.is_some() || maybe_point_light.is_some()
+                        });
 
-            commands.spawn_scene(scene_handle.handle.clone_weak());
-            scene_handle.is_loaded = true;
-            println!("Spawning scene");
+                scene_handle.instance_id =
+                    Some(scene_spawner.spawn(scene_handle.handle.clone_weak()));
+                println!("Spawning scene...");
+            }
+        }
+        Some(instance_id) if !scene_handle.is_loaded => {
+            if scene_spawner.instance_is_ready(instance_id) {
+                println!("...done!");
+                scene_handle.is_loaded = true;
+            }
         }
+        _ => {}
     }
 }
 

From fd89e9ec50553b983b04161f92761d1af5b3ee82 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Tue, 15 Mar 2022 20:30:29 +0100
Subject: [PATCH 13/17] scene_viewer: println -> info

---
 Cargo.toml                     | 1 +
 examples/tools/scene_viewer.rs | 8 ++++----
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 677fa1d1cf92e..cc7d80db0629d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -531,6 +531,7 @@ path = "examples/transforms/transform.rs"
 [[example]]
 name = "translation"
 path = "examples/transforms/translation.rs"
+
 # UI (User Interface)
 [[example]]
 name = "button"
diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index f8845d4034761..f28f24535c1bc 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -98,12 +98,12 @@ fn scene_load_check(
 
                 scene_handle.instance_id =
                     Some(scene_spawner.spawn(scene_handle.handle.clone_weak()));
-                println!("Spawning scene...");
+                info!("Spawning scene...");
             }
         }
         Some(instance_id) if !scene_handle.is_loaded => {
             if scene_spawner.instance_is_ready(instance_id) {
-                println!("...done!");
+                info!("...done!");
                 scene_handle.is_loaded = true;
             }
         }
@@ -157,7 +157,7 @@ fn camera_spawn_check(
                 perspective_projection.far(),
             );
 
-            println!("Spawning a 3D perspective camera");
+            info!("Spawning a 3D perspective camera");
             commands.spawn_bundle(PerspectiveCameraBundle {
                 camera: Camera {
                     near: perspective_projection.near,
@@ -183,7 +183,7 @@ fn camera_spawn_check(
             let min = aabb.min();
             let max = aabb.max();
 
-            println!("Spawning a directional light");
+            info!("Spawning a directional light");
             commands.spawn_bundle(DirectionalLightBundle {
                 directional_light: DirectionalLight {
                     shadow_projection: OrthographicProjection {

From c25be9fa46867226535bf9592b7218dc5ccb22fb Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Tue, 15 Mar 2022 20:30:55 +0100
Subject: [PATCH 14/17] scene_viewer: Automatically append #Scene0 if malformed
 or missing

---
 examples/tools/scene_viewer.rs | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index f28f24535c1bc..344707908563b 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -56,9 +56,19 @@ struct SceneHandle {
 }
 
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
-    let scene_path = std::env::args()
-        .nth(1)
-        .unwrap_or_else(|| "assets/models/FlightHelmet/FlightHelmet.gltf#Scene0".to_string());
+    let scene_path = std::env::args().nth(1).map_or_else(
+        || "assets/models/FlightHelmet/FlightHelmet.gltf#Scene0".to_string(),
+        |s| {
+            if let Some(index) = s.find("#Scene") {
+                if index + 6 < s.len() && s[index + 6..].chars().all(char::is_numeric) {
+                    return s;
+                }
+                return format!("{}#Scene0", &s[..index]);
+            }
+            format!("{}#Scene0", s)
+        },
+    );
+    info!("Loading {}", scene_path);
     commands.insert_resource(SceneHandle {
         handle: asset_server.load(&scene_path),
         instance_id: None,

From 28ae21e9accc035a8b2ece2fb3cf4633cfc2c0f3 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Sat, 19 Mar 2022 19:45:55 +0100
Subject: [PATCH 15/17] scene_viewer: Use a struct as a system label instead of
 a string

---
 examples/tools/scene_viewer.rs | 25 +++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index 344707908563b..0de3c32d7824d 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -1,6 +1,7 @@
 use bevy::{
     asset::{AssetServerSettings, LoadState},
     input::mouse::MouseMotion,
+    math::Vec3A,
     prelude::*,
     render::{
         camera::{Camera2d, Camera3d, CameraProjection},
@@ -9,6 +10,9 @@ use bevy::{
     scene::InstanceId,
 };
 
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemLabel)]
+struct CameraControllerCheckSystem;
+
 fn main() {
     println!(
         "
@@ -41,9 +45,9 @@ Controls:
         .add_startup_system(setup)
         .add_system_to_stage(CoreStage::PreUpdate, scene_load_check)
         .add_system_to_stage(CoreStage::PreUpdate, camera_spawn_check)
-        .add_system(camera_controller_check.label("camera_controller_check"))
+        .add_system(camera_controller_check.label(CameraControllerCheckSystem))
         .add_system(update_lights)
-        .add_system(camera_controller.after("camera_controller_check"))
+        .add_system(camera_controller.after(CameraControllerCheckSystem))
         .run();
 }
 
@@ -133,16 +137,16 @@ fn camera_spawn_check(
             return;
         }
 
-        let mut min = Vec3::splat(f32::MAX);
-        let mut max = Vec3::splat(f32::MIN);
+        let mut min = Vec3A::splat(f32::MAX);
+        let mut max = Vec3A::splat(f32::MIN);
         for (transform, maybe_aabb) in meshes.iter() {
             let aabb = maybe_aabb.unwrap();
             // If the Aabb had not been rotated, applying the non-uniform scale would produce the
             // correct bounds. However, it could very well be rotated and so we first convert to
             // a Sphere, and then back to an Aabb to find the conservative min and max points.
             let sphere = Sphere {
-                center: transform.mul_vec3(aabb.center),
-                radius: (transform.scale * aabb.half_extents).length(),
+                center: Vec3A::from(transform.mul_vec3(Vec3::from(aabb.center))),
+                radius: (Vec3A::from(transform.scale) * aabb.half_extents).length(),
             };
             let aabb = Aabb::from(sphere);
             min = min.min(aabb.min());
@@ -150,12 +154,13 @@ fn camera_spawn_check(
         }
 
         let size = (max - min).length();
-        let aabb = Aabb::from_min_max(min, max);
+        let aabb = Aabb::from_min_max(Vec3::from(min), Vec3::from(max));
 
         if !scene_handle.has_camera {
-            let transform =
-                Transform::from_translation(aabb.center + size * Vec3::new(0.5, 0.25, 0.5))
-                    .looking_at(aabb.center, Vec3::Y);
+            let transform = Transform::from_translation(
+                Vec3::from(aabb.center) + size * Vec3::new(0.5, 0.25, 0.5),
+            )
+            .looking_at(Vec3::from(aabb.center), Vec3::Y);
             let view = transform.compute_matrix();
             let mut perspective_projection = PerspectiveProjection::default();
             perspective_projection.far = perspective_projection.far.max(size * 10.0);

From fc24bc6e85787d72bf76b4409337fb8a8473b5b8 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Sat, 19 Mar 2022 19:51:49 +0100
Subject: [PATCH 16/17] scene_viewer: Use get_single_mut as there should be
 exactly one CameraController

---
 examples/tools/scene_viewer.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index 0de3c32d7824d..d5e9ad973dfe0 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -342,7 +342,7 @@ fn camera_controller(
         mouse_delta += mouse_event.delta;
     }
 
-    for (mut transform, mut options) in query.iter_mut() {
+    if let Ok((mut transform, mut options)) = query.get_single_mut() {
         if !options.initialized {
             let (_roll, yaw, pitch) = transform.rotation.to_euler(EulerRot::ZYX);
             options.yaw = yaw;
@@ -350,7 +350,7 @@ fn camera_controller(
             options.initialized = true;
         }
         if !options.enabled {
-            continue;
+            return;
         }
 
         // Handle key input

From 12bd35ebaeb6b9eab66d15c0261e86d786f1f2c5 Mon Sep 17 00:00:00 2001
From: Robert Swain <robert.swain@gmail.com>
Date: Sat, 19 Mar 2022 19:57:40 +0100
Subject: [PATCH 17/17] scnee_viewer: Remove obsolete TODO

---
 examples/tools/scene_viewer.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index d5e9ad973dfe0..b0e43bd4dd7e1 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -221,7 +221,6 @@ fn camera_spawn_check(
     }
 }
 
-// TODO: Register all types in CameraController so that it can be registered
 fn camera_controller_check(
     mut commands: Commands,
     camera: Query<Entity, (With<Camera>, Without<CameraController>)>,