Try #2425:

Author: bors[bot]

crates/bevy_scene/src/lib.rs

@@ -29,6 +29,7 @@ impl Plugin for ScenePlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.add_asset::<DynamicScene>()
             .add_asset::<Scene>()
+            .add_event::<SceneSpawnedEvent>()
             .init_asset_loader::<SceneLoader>()
             .init_resource::<SceneSpawner>()
             .add_system_to_stage(

crates/bevy_scene/src/scene_spawner.rs

@@ -26,6 +26,11 @@ impl InstanceId {
     }
 }
 
+#[derive(Debug)]
+pub struct SceneSpawnedEvent {
+    pub instance_id: InstanceId,
+}
+
 #[derive(Default)]
 pub struct SceneSpawner {
     spawned_scenes: HashMap<Handle<Scene>, Vec<InstanceId>>,
@@ -96,7 +101,7 @@ impl SceneSpawner {
         &mut self,
         world: &mut World,
         scene_handle: &Handle<DynamicScene>,
-    ) -> Result<(), SceneSpawnError> {
+    ) -> Result<InstanceId, SceneSpawnError> {
         let mut entity_map = EntityMap::default();
         Self::spawn_dynamic_internal(world, scene_handle, &mut entity_map)?;
         let instance_id = InstanceId::new();
@@ -107,7 +112,7 @@ impl SceneSpawner {
             .entry(scene_handle.clone())
             .or_insert_with(Vec::new);
         spawned.push(instance_id);
-        Ok(())
+        Ok(instance_id)
     }
 
     fn spawn_dynamic_internal(
@@ -235,31 +240,39 @@ impl SceneSpawner {
     }
 
     pub fn spawn_queued_scenes(&mut self, world: &mut World) -> Result<(), SceneSpawnError> {
-        let scenes_to_spawn = std::mem::take(&mut self.dynamic_scenes_to_spawn);
-
-        for scene_handle in scenes_to_spawn {
-            match self.spawn_dynamic_sync(world, &scene_handle) {
-                Ok(_) => {}
-                Err(SceneSpawnError::NonExistentScene { .. }) => {
-                    self.dynamic_scenes_to_spawn.push(scene_handle)
+        world.resource_scope(
+            |world, mut scene_spawned_event_writer: Mut<Events<SceneSpawnedEvent>>| {
+                let scenes_to_spawn = std::mem::take(&mut self.dynamic_scenes_to_spawn);
+
+                for scene_handle in scenes_to_spawn {
+                    match self.spawn_dynamic_sync(world, &scene_handle) {
+                        Ok(instance_id) => {
+                            scene_spawned_event_writer.send(SceneSpawnedEvent { instance_id });
+                        }
+                        Err(SceneSpawnError::NonExistentScene { .. }) => {
+                            self.dynamic_scenes_to_spawn.push(scene_handle);
+                        }
+                        Err(err) => return Err(err),
+                    }
                 }
-                Err(err) => return Err(err),
-            }
-        }
 
-        let scenes_to_spawn = std::mem::take(&mut self.scenes_to_spawn);
+                let scenes_to_spawn = std::mem::take(&mut self.scenes_to_spawn);
 
-        for (scene_handle, instance_id) in scenes_to_spawn {
-            match self.spawn_sync_internal(world, scene_handle, instance_id) {
-                Ok(_) => {}
-                Err(SceneSpawnError::NonExistentRealScene { handle }) => {
-                    self.scenes_to_spawn.push((handle, instance_id))
+                for (scene_handle, instance_id) in scenes_to_spawn {
+                    match self.spawn_sync_internal(world, scene_handle, instance_id) {
+                        Ok(instance_id) => {
+                            scene_spawned_event_writer.send(SceneSpawnedEvent { instance_id });
+                        }
+                        Err(SceneSpawnError::NonExistentRealScene { handle }) => {
+                            self.scenes_to_spawn.push((handle, instance_id))
+                        }
+                        Err(err) => return Err(err),
+                    }
                 }
-                Err(err) => return Err(err),
-            }
-        }
 
-        Ok(())
+                Ok(())
+            },
+        )
     }
 
     pub(crate) fn set_scene_instance_parent_sync(&mut self, world: &mut World) {

examples/scene/scene.rs

@@ -1,4 +1,4 @@
-use bevy::{prelude::*, reflect::TypeRegistry, utils::Duration};
+use bevy::{prelude::*, reflect::TypeRegistry, scene::SceneSpawnedEvent, utils::Duration};
 
 /// This example illustrates loading and saving scenes from files
 fn main() {
@@ -10,6 +10,7 @@ fn main() {
         .add_startup_system(load_scene_system.system())
         .add_startup_system(infotext_system.system())
         .add_system(log_system.system())
+        .add_system(scene_spawned_listener.system())
         .run();
 }
 
@@ -121,3 +122,9 @@ fn infotext_system(mut commands: Commands, asset_server: Res<AssetServer>) {
         ..Default::default()
     });
 }
+
+fn scene_spawned_listener(mut events: EventReader<SceneSpawnedEvent>) {
+    for event in events.iter() {
+        info!("{:?}", event);
+    }
+}