Send the nested assets.

Author: andriyDev

crates/bevy_asset/src/lib.rs

@@ -1007,6 +1007,20 @@ mod tests {
         // Re-open a and b gates to allow c to load embedded deps (gates are closed after each load)
         gate_opener.open(a_path);
         gate_opener.open(b_path);
+
+        // Wait for the C-load task to finish. If we don't do this, it's possible for nested asset A
+        // to be sent in one frame and for the nested asset B to be sent in the next frame. This
+        // causes an alternative order of events (but one that is just as valid), which would make
+        // this test flaky.
+        while !asset_server
+            .data
+            .infos
+            .read()
+            .pending_tasks
+            .iter()
+            .any(|(_, task)| task.is_finished())
+        {}
+
         run_app_until(&mut app, |world| {
             let a_text = get::<CoolText>(world, a_id)?;
             let (a_load, a_deps, a_rec_deps) = asset_server.get_load_states(a_id).unwrap();
@@ -1131,9 +1145,19 @@ mod tests {
             AssetEvent::Added {
                 id: id_results.b_id,
             },
+            // This extra LoadedWithDependencies happens because asset B got replaced when C was
+            // loaded (and we only see the modify after since events on `Assets` only merge in a
+            // system, so they look like they happen at the wrong time).
+            AssetEvent::LoadedWithDependencies {
+                id: id_results.b_id,
+            },
             AssetEvent::Added {
                 id: id_results.c_id,
             },
+            AssetEvent::Modified { id: a_id },
+            AssetEvent::Modified {
+                id: id_results.b_id,
+            },
             AssetEvent::LoadedWithDependencies {
                 id: id_results.d_id,
             },

crates/bevy_asset/src/server/mod.rs

@@ -651,7 +651,7 @@ impl AssetServer {
         };
 
         let nested_direct_loaded_assets = RwLock::new(NestedAssets::default());
-        match self
+        let result = match self
             .load_with_meta_loader_and_reader(
                 &base_path,
                 meta.as_ref(),
@@ -686,7 +686,7 @@ impl AssetServer {
                     handle.unwrap()
                 };
 
-                self.send_loaded_asset(base_handle.id(), loaded_asset);
+                self.send_loaded_asset(Some(base_handle.id()), loaded_asset);
                 Ok(final_handle)
             }
             Err(err) => {
@@ -697,23 +697,44 @@ impl AssetServer {
                 });
                 Err(err)
             }
+        };
+
+        // Even if the asset failed to load, the nested assets still loaded correctly, so we might
+        // as well send those assets to "refresh" them.
+        for (path, asset) in nested_direct_loaded_assets.into_inner().0 {
+            // Even if the handle is None, one of its subassets may be loaded, so we should send the
+            // whole complete asset.
+            let handle = self
+                .data
+                .infos
+                .read()
+                .get_path_and_type_id_handle(&path, asset.asset.asset_type_id());
+            self.send_loaded_asset(handle.map(|handle| handle.id()), asset);
         }
+
+        result
     }
 
     /// Sends a load event for the given `loaded_asset` and does the same recursively for all
     /// labeled assets.
-    fn send_loaded_asset(&self, id: UntypedAssetId, mut complete_asset: CompleteErasedLoadedAsset) {
+    fn send_loaded_asset(
+        &self,
+        id: Option<UntypedAssetId>,
+        mut complete_asset: CompleteErasedLoadedAsset,
+    ) {
         for (_, labeled_asset) in complete_asset.labeled_assets.drain() {
             self.send_asset_event(InternalAssetEvent::Loaded {
                 id: labeled_asset.handle.id(),
                 loaded_asset: labeled_asset.asset,
             });
         }
 
-        self.send_asset_event(InternalAssetEvent::Loaded {
-            id,
-            loaded_asset: complete_asset.asset,
-        });
+        if let Some(id) = id {
+            self.send_asset_event(InternalAssetEvent::Loaded {
+                id,
+                loaded_asset: complete_asset.asset,
+            });
+        }
     }
 
     /// Kicks off a reload of the asset stored at the given path. This will only reload the asset if it currently loaded.