debounce asset events for scene reloading (#20430)

# Objective

- examples `many_foxes` and `morph_targets` have stopped working since
#18358
- any case that load several parts of a complex asset and a scene, and
do setup on asset load will fail
- Fixes #20383

## Solution

- Debounce scene asset events so that we ignore modified event happening
too quickly after each others

## Testing

- run examples `many_foxes` or `morph_targets`

## Alternative

I *don't* think this is a good long term fix, but this should be fixed
in the 0.17 and I think alternatives are worse / too complex.

Alternatives are:
- Revert #18358. Normal scene loading is more important than hot
reloading
- Implement partial asset loading in the asset server and the gltf
loader so that when we load `file.gltf#Animation0`, only the animation
data is loaded. This would be a very good change, but too big to do for
the 0.17
- Have the asset server load parent assets only once, even when loading
subassets. This would be a good change and less complex, but I think
worse than the previous idea and kinda not compatible with it

---------

Co-authored-by: Alice Cecile <[email protected]>

Author: mockersf

crates/bevy_scene/src/lib.rs

@@ -196,6 +196,10 @@ mod tests {
             .unwrap();
 
         app.update();
+        // TODO: multiple updates to avoid debounced asset events. See comment on SceneSpawner::debounced_scene_asset_events
+        app.update();
+        app.update();
+        app.update();
 
         let child_root = app
             .world()
@@ -336,6 +340,10 @@ mod tests {
             .unwrap();
 
         app.update();
+        // TODO: multiple updates to avoid debounced asset events. See comment on SceneSpawner::debounced_scene_asset_events
+        app.update();
+        app.update();
+        app.update();
 
         let child_root = app
             .world()

crates/bevy_scene/src/scene_spawner.rs

@@ -82,7 +82,18 @@ pub struct SceneSpawner {
     pub(crate) spawned_dynamic_scenes: HashMap<AssetId<DynamicScene>, HashSet<InstanceId>>,
     spawned_instances: HashMap<InstanceId, InstanceInfo>,
     scene_asset_event_reader: EventCursor<AssetEvent<Scene>>,
+    // TODO: temp fix for https://github.com/bevyengine/bevy/issues/12756 effect on scenes
+    // To handle scene hot reloading, they are unloaded/reloaded on asset modifications.
+    // When loading several subassets of a scene as is common with gltf, they each trigger a complete asset load,
+    // and each will trigger either a created or modified event for the parent asset. This causes the scene to be
+    // unloaded, losing its initial setup, and reloaded without it.
+    // Debouncing scene asset events let us ignore events that happen less than SCENE_ASSET_AGE_THRESHOLD frames
+    // apart and not reload the scene in those cases as it's unlikely to be an actual asset change.
+    debounced_scene_asset_events: HashMap<AssetId<Scene>, u32>,
     dynamic_scene_asset_event_reader: EventCursor<AssetEvent<DynamicScene>>,
+    // TODO: temp fix for https://github.com/bevyengine/bevy/issues/12756 effect on scenes
+    // See debounced_scene_asset_events
+    debounced_dynamic_scene_asset_events: HashMap<AssetId<DynamicScene>, u32>,
     scenes_to_spawn: Vec<(Handle<Scene>, InstanceId, Option<Entity>)>,
     dynamic_scenes_to_spawn: Vec<(Handle<DynamicScene>, InstanceId, Option<Entity>)>,
     scenes_to_despawn: Vec<AssetId<Scene>>,
@@ -552,21 +563,45 @@ pub fn scene_spawner_system(world: &mut World) {
             .scene_asset_event_reader
             .read(scene_asset_events)
         {
-            if let AssetEvent::Modified { id } = event
-                && scene_spawner.spawned_scenes.contains_key(id)
-            {
-                updated_spawned_scenes.push(*id);
+            match event {
+                AssetEvent::Added { id } => {
+                    scene_spawner.debounced_scene_asset_events.insert(*id, 0);
+                }
+                AssetEvent::Modified { id } => {
+                    if scene_spawner
+                        .debounced_scene_asset_events
+                        .insert(*id, 0)
+                        .is_none()
+                        && scene_spawner.spawned_scenes.contains_key(id)
+                    {
+                        updated_spawned_scenes.push(*id);
+                    }
+                }
+                _ => {}
             }
         }
         let mut updated_spawned_dynamic_scenes = Vec::new();
         for event in scene_spawner
             .dynamic_scene_asset_event_reader
             .read(dynamic_scene_asset_events)
         {
-            if let AssetEvent::Modified { id } = event
-                && scene_spawner.spawned_dynamic_scenes.contains_key(id)
-            {
-                updated_spawned_dynamic_scenes.push(*id);
+            match event {
+                AssetEvent::Added { id } => {
+                    scene_spawner
+                        .debounced_dynamic_scene_asset_events
+                        .insert(*id, 0);
+                }
+                AssetEvent::Modified { id } => {
+                    if scene_spawner
+                        .debounced_dynamic_scene_asset_events
+                        .insert(*id, 0)
+                        .is_none()
+                        && scene_spawner.spawned_dynamic_scenes.contains_key(id)
+                    {
+                        updated_spawned_dynamic_scenes.push(*id);
+                    }
+                }
+                _ => {}
             }
         }
 
@@ -582,6 +617,40 @@ pub fn scene_spawner_system(world: &mut World) {
             .update_spawned_dynamic_scenes(world, &updated_spawned_dynamic_scenes)
             .unwrap();
         scene_spawner.trigger_scene_ready_events(world);
+
+        const SCENE_ASSET_AGE_THRESHOLD: u32 = 2;
+        for asset_id in scene_spawner.debounced_scene_asset_events.clone().keys() {
+            let age = scene_spawner
+                .debounced_scene_asset_events
+                .get(asset_id)
+                .unwrap();
+            if *age > SCENE_ASSET_AGE_THRESHOLD {
+                scene_spawner.debounced_scene_asset_events.remove(asset_id);
+            } else {
+                scene_spawner
+                    .debounced_scene_asset_events
+                    .insert(*asset_id, *age + 1);
+            }
+        }
+        for asset_id in scene_spawner
+            .debounced_dynamic_scene_asset_events
+            .clone()
+            .keys()
+        {
+            let age = scene_spawner
+                .debounced_dynamic_scene_asset_events
+                .get(asset_id)
+                .unwrap();
+            if *age > SCENE_ASSET_AGE_THRESHOLD {
+                scene_spawner
+                    .debounced_dynamic_scene_asset_events
+                    .remove(asset_id);
+            } else {
+                scene_spawner
+                    .debounced_dynamic_scene_asset_events
+                    .insert(*asset_id, *age + 1);
+            }
+        }
     });
 }