chore: migrate to Bevy 0.19

- Bump deps to 0.19-compatible versions: bevy 0.19, avian3d 0.7,
  bevy-inspector-egui 0.37, bevy_brp_extras 0.20, bevy_enhanced_input 0.26,
  bevy_kana 0.1, bevy_lagrange 0.0.4, bevy_liminal 0.0.2 (crates.io),
  bevy_window_manager 0.21
- Scenes now load as bevy_world_serialization::WorldAsset (GLTF #Scene0);
  Handle<Scene>->Handle<WorldAsset>, SceneRoot->WorldAssetRoot
- Rework nateroid death materials: the old GLTF scene-World introspection is
  gone in 0.19, so precompute fades the donut/icing materials the meshes
  actually use and classifies each mesh by name at swap time
- Camera input: OrbitCam button/trackpad fields moved to a separate
  OrbitCamInputMode::Preset(OrbitCamPreset::BlenderLike) component
- Outline: MeshOutline->Outline::jump_flood(..).build(), MeshOutlinePlugin->
  LiminalPlugin
- Adapt remaining API changes: FontSize enum, DirectionalLight
  shadow_maps_enabled, Hdr moved to bevy::camera, TextLayout::justify
- Fix deprecations: SystemCondition::or_else, egui_wants_pointer_input

Claude-Session: https://claude.ai/code/session_01ALGByx7bTLmFfbL8vpdi9s

Author: natepiano

Cargo.lock

@@ -36,15 +36,15 @@ wildcard_imports        = "allow" # Bevy prelude convention
 missing_docs = "deny"
 
 [dependencies]
-avian3d             = { version = "0.6.1", features = ["debug-plugin", "parallel", "simd"] }
-bevy                = { version = "0.18.1", features = ["bevy_dev_tools", "bevy_remote"] }
-bevy-inspector-egui = "0.36.0"
-bevy_brp_extras     = "0.19.0"
-bevy_enhanced_input = "0.25.0"
-bevy_kana           = { version = "0.0.6", features = ["input"] }
-bevy_lagrange       = { version = "0.0.3", features = ["fit_overlay"] }
-bevy_liminal        = { git = "https://github.com/natepiano/bevy_liminal", rev = "572cd0fc44879cf62223cfc91a5a08ee57bf7d32" }
-bevy_window_manager = "0.20.2"
+avian3d             = { version = "0.7.0", features = ["debug-plugin", "parallel", "simd"] }
+bevy                = { version = "0.19.0", features = ["bevy_dev_tools", "bevy_remote"] }
+bevy-inspector-egui = "0.37.0"
+bevy_brp_extras     = "0.20.1"
+bevy_enhanced_input = "0.26.0"
+bevy_kana           = { version = "0.1.0", features = ["input"] }
+bevy_lagrange       = { version = "0.0.4", features = ["fit_overlay"] }
+bevy_liminal        = "0.0.2"
+bevy_window_manager = "0.21.0"
 rand                = "0.10.1"
 
 # Enable high optimizations for dependencies (incl. Bevy), but not for our code:

Cargo.toml

@@ -10,10 +10,46 @@ use super::constants::ICING_MESH_NAME;
 use crate::actor::constants::NATEROID_DEATH_ALPHA_STEP;
 use crate::asset_loader::SceneAssets;
 
-/// Precomputed materials for `Nateroid` death animation at different transparency levels
+/// Precomputed `Nateroid` death-animation materials: one faded donut+icing set
+/// per transparency level. Fades the donut/icing materials the meshes actually
+/// use (applied by `apply_nateroid_materials_to_children`), matched per mesh.
 #[derive(Resource)]
 pub(crate) struct NateroidDeathMaterials {
-    pub(crate) materials: Vec<Vec<Handle<StandardMaterial>>>,
+    levels: Vec<NateroidDeathLevel>,
+}
+
+/// Faded donut and icing materials for a single transparency level.
+struct NateroidDeathLevel {
+    donut: Handle<StandardMaterial>,
+    icing: Handle<StandardMaterial>,
+}
+
+impl NateroidDeathLevel {
+    const fn handle(&self, mesh: NateroidMesh) -> &Handle<StandardMaterial> {
+        match mesh {
+            NateroidMesh::Donut => &self.donut,
+            NateroidMesh::Icing => &self.icing,
+        }
+    }
+}
+
+impl NateroidDeathMaterials {
+    /// Number of precomputed transparency levels.
+    pub const fn level_count(&self) -> usize { self.levels.len() }
+
+    /// Faded material for the given alpha `level`, matched to `mesh_name`
+    /// (donut/icing). Unknown mesh names fall back to the donut material.
+    pub fn material_for(
+        &self,
+        level: usize,
+        mesh_name: Option<&str>,
+    ) -> Option<Handle<StandardMaterial>> {
+        let level = self.levels.get(level)?;
+        let mesh = mesh_name
+            .and_then(NateroidMesh::classify)
+            .unwrap_or(NateroidMesh::Donut);
+        Some(level.handle(mesh).clone())
+    }
 }
 
 #[derive(Clone, Copy)]
@@ -154,17 +190,28 @@ pub(super) fn debug_mesh_components(
     }
 }
 
-/// System that precomputes death materials when assets are loaded
+/// Precomputes faded donut/icing materials for the death animation once assets
+/// are loaded. Fades the custom materials the meshes use rather than the GLTF
+/// originals (the GLTF scene's embedded `World` is no longer queryable in 0.19).
 pub(super) fn precompute_death_materials(
     mut commands: Commands,
     scene_assets: Res<SceneAssets>,
-    scenes: Res<Assets<Scene>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     nateroid_settings: Res<NateroidSettings>,
 ) {
-    // Get the nateroid scene
-    let Some(nateroid_scene) = scenes.get(&scene_assets.nateroid) else {
-        warn!("Nateroid scene not loaded yet");
+    let Some(donut_handle) = scene_assets.nateroid_donut_material.clone() else {
+        warn!("Nateroid donut material not created yet");
+        return;
+    };
+    let Some(icing_handle) = scene_assets.nateroid_icing_material.clone() else {
+        warn!("Nateroid icing material not created yet");
+        return;
+    };
+    let (Some(donut_base), Some(icing_base)) = (
+        materials.get(&donut_handle).cloned(),
+        materials.get(&icing_handle).cloned(),
+    ) else {
+        warn!("Nateroid base materials not loaded yet");
         return;
     };
 
@@ -174,57 +221,27 @@ pub(super) fn precompute_death_materials(
     let level_count =
         ((initial_alpha - target_alpha) * (1.0 / NATEROID_DEATH_ALPHA_STEP)).to_usize() + 1;
 
-    // Collect material handles from the scene's world using try_query
-    let mut material_handles = Vec::new();
-    if let Some(mut query_state) = nateroid_scene
-        .world
-        .try_query::<&MeshMaterial3d<StandardMaterial>>()
-    {
-        for mesh_material in query_state.iter(&nateroid_scene.world) {
-            material_handles.push(mesh_material.0.clone());
-        }
-    }
-
-    if material_handles.is_empty() {
-        warn!("No materials found in nateroid scene");
-        return;
-    }
-
-    debug!(
-        "Collected {} material handles from nateroid scene",
-        material_handles.len()
-    );
-
-    // Precompute materials for each alpha level
-    let mut precomputed_materials = Vec::with_capacity(level_count);
+    let mut levels = Vec::with_capacity(level_count);
     for level in 0..level_count {
         // FMA optimization (faster + more precise): initial_alpha - (level as f32 * step)
         let alpha = level
             .to_f32()
             .mul_add(-NATEROID_DEATH_ALPHA_STEP, initial_alpha);
-        let mut level_materials = Vec::with_capacity(material_handles.len());
-
-        for material_handle in &material_handles {
-            if let Some(original_material) = materials.get(material_handle) {
-                let mut cloned_material = original_material.clone();
-                cloned_material.base_color.set_alpha(alpha);
-                cloned_material.alpha_mode = AlphaMode::Blend;
-                level_materials.push(materials.add(cloned_material));
-            }
-        }
-
-        precomputed_materials.push(level_materials);
+        levels.push(NateroidDeathLevel {
+            donut: materials.add(faded_material(&donut_base, alpha)),
+            icing: materials.add(faded_material(&icing_base, alpha)),
+        });
     }
 
-    let material_set_count = precomputed_materials.len();
-    let materials_per_set_count = material_handles.len();
-
-    // Insert the resource
-    commands.insert_resource(NateroidDeathMaterials {
-        materials: precomputed_materials,
-    });
+    let level_count = levels.len();
+    commands.insert_resource(NateroidDeathMaterials { levels });
+    debug!("Precomputed {level_count} nateroid death-material levels (donut + icing)");
+}
 
-    debug!(
-        "Precomputed {material_set_count} material sets with {materials_per_set_count} materials each"
-    );
+/// Clones `base` into a translucent material at the given `alpha`.
+fn faded_material(base: &StandardMaterial, alpha: f32) -> StandardMaterial {
+    let mut material = base.clone();
+    material.base_color.set_alpha(alpha);
+    material.alpha_mode = AlphaMode::Blend;
+    material
 }

src/actor/nateroid/death_materials.rs

@@ -1,6 +1,8 @@
 use avian3d::prelude::*;
 use bevy::camera::visibility::RenderLayers;
 use bevy::prelude::*;
+use bevy::world_serialization::WorldAsset;
+use bevy::world_serialization::WorldAssetRoot;
 use bevy_inspector_egui::inspector_options::std_options::NumberDisplay;
 use bevy_inspector_egui::prelude::*;
 use bevy_inspector_egui::quick::ResourceInspectorPlugin;
@@ -140,7 +142,7 @@ pub(crate) struct ActorSettings {
     pub(crate) restitution_combine_rule: CoefficientCombine,
     pub(crate) rigid_body:               RigidBody,
     #[reflect(ignore)]
-    pub(crate) scene:                    Handle<Scene>,
+    pub(crate) scene:                    Handle<WorldAsset>,
     pub(crate) spawn_timer_seconds:      Option<f32>,
     pub(crate) transform:                Transform,
     #[reflect(ignore)]
@@ -206,7 +208,10 @@ fn create_spawn_timer(spawn_timer_seconds: Option<f32>) -> Option<Timer> {
     spawn_timer_seconds.map(|seconds| Timer::from_seconds(seconds, TimerMode::Repeating))
 }
 
-fn initialize_actor_settings(actor_settings: &mut ActorSettings, scene_handle: &Handle<Scene>) {
+fn initialize_actor_settings(
+    actor_settings: &mut ActorSettings,
+    scene_handle: &Handle<WorldAsset>,
+) {
     actor_settings.spawn_timer = create_spawn_timer(actor_settings.spawn_timer_seconds);
     actor_settings.scene = scene_handle.clone();
 }
@@ -237,7 +242,7 @@ pub(super) fn insert_configured_components(
         MaxAngularSpeed(settings.max_angular_velocity),
         MaxLinearSpeed(settings.max_linear_velocity),
         settings.render_layer.layers(),
-        SceneRoot(settings.scene.clone()),
+        WorldAssetRoot(settings.scene.clone()),
     ));
 
     // Apply damping if configured

src/actor/settings.rs

@@ -1,5 +1,6 @@
 use bevy::asset::LoadState;
 use bevy::prelude::*;
+use bevy::world_serialization::WorldAsset;
 
 use crate::constants::ENVIRONMENT_DIFFUSE_MAP_ASSET_PATH;
 use crate::constants::ENVIRONMENT_SPECULAR_MAP_ASSET_PATH;
@@ -42,15 +43,15 @@ pub(crate) enum AssetsState {
     Loaded,
 }
 
-// `SceneAssets` stores GLTF `Handle<Scene>` values whose scene graphs can spawn
-// multiple child meshes from a single actor asset.
+// `SceneAssets` stores GLTF `Handle<WorldAsset>` values whose scene graphs can
+// spawn multiple child meshes from a single actor asset.
 #[derive(Resource, Clone, Debug, Default)]
 pub(crate) struct SceneAssets {
-    pub(crate) missile:                  Handle<Scene>,
-    pub(crate) nateroid:                 Handle<Scene>,
+    pub(crate) missile:                  Handle<WorldAsset>,
+    pub(crate) nateroid:                 Handle<WorldAsset>,
     pub(crate) nateroid_donut_material:  Option<Handle<StandardMaterial>>,
     pub(crate) nateroid_icing_material:  Option<Handle<StandardMaterial>>,
-    pub(crate) spaceship:                Handle<Scene>,
+    pub(crate) spaceship:                Handle<WorldAsset>,
     pub(crate) environment_diffuse_map:  Handle<Image>,
     pub(crate) environment_specular_map: Handle<Image>,
 }

src/asset_loader.rs

@@ -39,9 +39,6 @@ pub(super) const CAMERA_SPLASH_START_PITCH: f32 = FRAC_PI_2;
 pub(super) const CAMERA_SPLASH_START_RADIUS: f32 = 3000.0;
 pub(super) const CAMERA_SPLASH_START_YAW: f32 = -PI;
 
-// camera trackpad
-pub(super) const CAMERA_TRACKPAD_SENSITIVITY: f32 = 0.8;
-
 // camera zoom
 /// Minimum zoom distance (allows zoom-to-fit to get very close)
 pub(super) const CAMERA_ZOOM_LOWER_LIMIT: f32 = 0.001;

src/camera/constants.rs

@@ -162,7 +162,7 @@ fn draw_camera_focus_gizmo(
                 commands.spawn((
                     Text::new(text),
                     TextFont {
-                        font_size: EDGE_MARKER_FONT_SIZE,
+                        font_size: FontSize::Px(EDGE_MARKER_FONT_SIZE),
                         ..default()
                     },
                     TextColor(focus_settings.color),

src/camera/focus_gizmo.rs

@@ -4,9 +4,9 @@ use bevy_inspector_egui::inspector_options::std_options::NumberDisplay;
 use bevy_inspector_egui::prelude::*;
 use bevy_inspector_egui::quick::ResourceInspectorPlugin;
 use bevy_kana::Position;
-use bevy_lagrange::InputControl;
 use bevy_lagrange::OrbitCam;
-use bevy_lagrange::TrackpadInput;
+use bevy_lagrange::OrbitCamInputMode;
+use bevy_lagrange::OrbitCamPreset;
 use bevy_liminal::OutlineCamera;
 
 use super::RenderLayer;
@@ -27,7 +27,6 @@ use super::constants::CAMERA_SPLASH_START_FOCUS;
 use super::constants::CAMERA_SPLASH_START_PITCH;
 use super::constants::CAMERA_SPLASH_START_RADIUS;
 use super::constants::CAMERA_SPLASH_START_YAW;
-use super::constants::CAMERA_TRACKPAD_SENSITIVITY;
 use super::constants::CAMERA_ZOOM_LOWER_LIMIT;
 use super::constants::CAMERA_ZOOM_SENSITIVITY;
 use super::constants::CAMERA_ZOOM_SMOOTHNESS;
@@ -180,20 +179,12 @@ pub(super) fn spawn_game_camera(
             OrbitCam {
                 focus: Vec3::ZERO,
                 target_radius: camera_settings.splash_start.radius,
-                button_orbit: MouseButton::Middle,
-                button_pan: MouseButton::Middle,
-                modifier_pan: Some(KeyCode::ShiftLeft),
                 zoom_sensitivity: CAMERA_ZOOM_SENSITIVITY,
                 zoom_lower_limit: CAMERA_ZOOM_LOWER_LIMIT,
-                input_control: Some(InputControl {
-                    trackpad: Some(TrackpadInput {
-                        sensitivity: CAMERA_TRACKPAD_SENSITIVITY,
-                        ..TrackpadInput::blender_default()
-                    }),
-                    ..default()
-                }),
                 ..default()
             },
+            // Middle-drag orbit, Shift+middle-drag pan, Blender-style trackpad.
+            OrbitCamInputMode::Preset(OrbitCamPreset::BlenderLike),
             Camera {
                 order: CameraOrder::Game.order(),
                 // can't obscure the star camera with this on

src/camera/game.rs

@@ -220,7 +220,10 @@ fn spawn_directional_light(
         .spawn(DirectionalLight {
             color: directional_light_settings.color,
             illuminance: directional_light_settings.illuminance,
-            shadows_enabled: matches!(directional_light_settings.shadow_switch, ShadowSwitch::On),
+            shadow_maps_enabled: matches!(
+                directional_light_settings.shadow_switch,
+                ShadowSwitch::On
+            ),
             shadow_depth_bias: SHADOW_DEPTH_BIAS,
             shadow_normal_bias: SHADOW_NORMAL_BIAS,
             ..default()
@@ -282,7 +285,7 @@ fn manage_lighting(
                 // Update the existing `DirectionalLight`.
                 light.color = directional_light_settings.color;
                 light.illuminance = directional_light_settings.illuminance;
-                light.shadows_enabled =
+                light.shadow_maps_enabled =
                     matches!(directional_light_settings.shadow_switch, ShadowSwitch::On);
             },
             (Some((entity, _, _)), LightSwitch::Off) => {

src/camera/lights.rs

@@ -14,7 +14,7 @@ mod zoom;
 use bevy::picking::mesh_picking::MeshPickingPlugin;
 use bevy::prelude::*;
 use bevy_lagrange::LagrangePlugin;
-use bevy_liminal::MeshOutlinePlugin;
+use bevy_liminal::LiminalPlugin;
 pub(crate) use constants::ZOOM_MARGIN;
 use focus_gizmo::FocusGizmoPlugin;
 pub(crate) use game::CameraSettings;
@@ -34,7 +34,7 @@ impl Plugin for CameraPlugin {
     fn build(&self, app: &mut App) {
         app.add_plugins(MeshPickingPlugin)
             .add_plugins(LagrangePlugin)
-            .add_plugins(MeshOutlinePlugin)
+            .add_plugins(LiminalPlugin)
             .add_plugins(GameCameraPlugin)
             .add_plugins(ZoomPlugin)
             .add_plugins(FocusGizmoPlugin)