Send SceneInstanceReady when spawning any kind of scene (bevyengine…

…#11741)

# Objective

- Emit an event regardless of scene type (`Scene` and `DynamicScene`).
- Also send the `InstanceId` along.

Follow-up to bevyengine#11002.
Fixes bevyengine#2218.

## Solution

- Send `SceneInstanceReady` regardless of scene type.
- Make `SceneInstanceReady::parent` `Option`al.
- Add `SceneInstanceReady::id`.

---

## Changelog

### Changed

- `SceneInstanceReady` is now sent for `Scene` as well.
`SceneInstanceReady::parent` is an `Option` and
`SceneInstanceReady::id`, an `InstanceId`, is added to identify the
corresponding `Scene`.

## Migration Guide

- `SceneInstanceReady { parent: Entity }` is now `SceneInstanceReady {
id: InstanceId, parent: Option<Entity> }`.

crates/bevy_scene/src/scene_spawner.rs

@@ -18,8 +18,10 @@ use uuid::Uuid;
 /// See also [`SceneSpawner::instance_is_ready`].
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Event)]
 pub struct SceneInstanceReady {
+ /// ID of the spawned instance.
+ pub id: InstanceId,
  /// Entity to which the scene was spawned as a child.
- pub parent: Entity,
+ pub parent: Option<Entity>,
 }
 
 /// Information about a scene instance.
@@ -63,8 +65,8 @@ pub struct SceneSpawner {
  pub(crate) spawned_dynamic_scenes: HashMap<AssetId<DynamicScene>, HashSet<InstanceId>>,
  pub(crate) spawned_instances: HashMap<InstanceId, InstanceInfo>,
  scene_asset_event_reader: ManualEventReader<AssetEvent<DynamicScene>>,
- dynamic_scenes_to_spawn: Vec<(Handle<DynamicScene>, InstanceId)>,
- scenes_to_spawn: Vec<(Handle<Scene>, InstanceId)>,
+ dynamic_scenes_to_spawn: Vec<(Handle<DynamicScene>, InstanceId, Option<Entity>)>,
+ scenes_to_spawn: Vec<(Handle<Scene>, InstanceId, Option<Entity>)>,
  scenes_to_despawn: Vec<AssetId<DynamicScene>>,
  instances_to_despawn: Vec<InstanceId>,
  scenes_with_parent: Vec<(InstanceId, Entity)>,
@@ -128,7 +130,8 @@ impl SceneSpawner {
  /// Schedule the spawn of a new instance of the provided dynamic scene.
  pub fn spawn_dynamic(&mut self, id: impl Into<Handle<DynamicScene>>) -> InstanceId {
  let instance_id = InstanceId::new();
- self.dynamic_scenes_to_spawn.push((id.into(), instance_id));
+ self.dynamic_scenes_to_spawn
+ .push((id.into(), instance_id, None));
  instance_id
  }
 
@@ -139,22 +142,24 @@ impl SceneSpawner {
  parent: Entity,
  ) -> InstanceId {
  let instance_id = InstanceId::new();
- self.dynamic_scenes_to_spawn.push((id.into(), instance_id));
+ self.dynamic_scenes_to_spawn
+ .push((id.into(), instance_id, Some(parent)));
  self.scenes_with_parent.push((instance_id, parent));
  instance_id
  }
 
  /// Schedule the spawn of a new instance of the provided scene.
  pub fn spawn(&mut self, id: impl Into<Handle<Scene>>) -> InstanceId {
  let instance_id = InstanceId::new();
- self.scenes_to_spawn.push((id.into(), instance_id));
+ self.scenes_to_spawn.push((id.into(), instance_id, None));
  instance_id
  }
 
  /// Schedule the spawn of a new instance of the provided scene as a child of `parent`.
  pub fn spawn_as_child(&mut self, id: impl Into<Handle<Scene>>, parent: Entity) -> InstanceId {
  let instance_id = InstanceId::new();
- self.scenes_to_spawn.push((id.into(), instance_id));
+ self.scenes_to_spawn
+ .push((id.into(), instance_id, Some(parent)));
  self.scenes_with_parent.push((instance_id, parent));
  instance_id
  }
@@ -296,7 +301,7 @@ 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 (handle, instance_id) in scenes_to_spawn {
+ for (handle, instance_id, parent) in scenes_to_spawn {
  let mut entity_map = EntityHashMap::default();
 
  match Self::spawn_dynamic_internal(world, handle.id(), &mut entity_map) {
@@ -308,21 +313,41 @@ impl SceneSpawner {
  .entry(handle.id())
  .or_insert_with(HashSet::new);
  spawned.insert(instance_id);
+
+ // Scenes with parents need more setup before they are ready.
+ // See `set_scene_instance_parent_sync()`.
+ if parent.is_none() {
+ world.send_event(SceneInstanceReady {
+ id: instance_id,
+ parent: None,
+ });
+ }
  }
  Err(SceneSpawnError::NonExistentScene { .. }) => {
- self.dynamic_scenes_to_spawn.push((handle, instance_id));
+ self.dynamic_scenes_to_spawn
+ .push((handle, instance_id, parent));
  }
  Err(err) => return Err(err),
  }
  }
 
  let scenes_to_spawn = std::mem::take(&mut self.scenes_to_spawn);
 
- for (scene_handle, instance_id) in scenes_to_spawn {
+ for (scene_handle, instance_id, parent) in scenes_to_spawn {
  match self.spawn_sync_internal(world, scene_handle.id(), instance_id) {
- Ok(_) => {}
+ Ok(_) => {
+ // Scenes with parents need more setup before they are ready.
+ // See `set_scene_instance_parent_sync()`.
+ if parent.is_none() {
+ world.send_event(SceneInstanceReady {
+ id: instance_id,
+ parent: None,
+ });
+ }
+ }
  Err(SceneSpawnError::NonExistentRealScene { .. }) => {
- self.scenes_to_spawn.push((scene_handle, instance_id));
+ self.scenes_to_spawn
+ .push((scene_handle, instance_id, parent));
  }
  Err(err) => return Err(err),
  }
@@ -356,7 +381,10 @@ impl SceneSpawner {
  }
  }
 
- world.send_event(SceneInstanceReady { parent });
+ world.send_event(SceneInstanceReady {
+ id: instance_id,
+ parent: Some(parent),
+ });
  } else {
  self.scenes_with_parent.push((instance_id, parent));
  }
@@ -403,10 +431,10 @@ pub fn scene_spawner_system(world: &mut World) {
  });
  scene_spawner
  .dynamic_scenes_to_spawn
- .retain(|(_, instance)| !dead_instances.contains(instance));
+ .retain(|(_, instance, _)| !dead_instances.contains(instance));
  scene_spawner
  .scenes_to_spawn
- .retain(|(_, instance)| !dead_instances.contains(instance));
+ .retain(|(_, instance, _)| !dead_instances.contains(instance));
 
  let scene_asset_events = world.resource::<Events<AssetEvent<DynamicScene>>>();
 
@@ -438,6 +466,7 @@ pub fn scene_spawner_system(world: &mut World) {
 #[cfg(test)]
 mod tests {
  use bevy_app::App;
+ use bevy_asset::Handle;
  use bevy_asset::{AssetPlugin, AssetServer};
  use bevy_ecs::event::EventReader;
  use bevy_ecs::prelude::ReflectComponent;
@@ -505,28 +534,150 @@ mod tests {
  #[reflect(Component)]
  struct ComponentA;
 
- #[test]
- fn event() {
+ fn setup() -> App {
  let mut app = App::new();
  app.add_plugins((AssetPlugin::default(), ScenePlugin));
 
  app.register_type::<ComponentA>();
  app.world_mut().spawn(ComponentA);
  app.world_mut().spawn(ComponentA);
 
+ app
+ }
+
+ fn build_scene(app: &mut App) -> Handle<Scene> {
+ app.world_mut().run_system_once(
+ |world: &World,
+ type_registry: Res<'_, AppTypeRegistry>,
+ asset_server: Res<'_, AssetServer>| {
+ asset_server.add(
+ Scene::from_dynamic_scene(&DynamicScene::from_world(world), &type_registry)
+ .unwrap(),
+ )
+ },
+ )
+ }
+
+ #[test]
+ fn event_scene() {
+ let mut app = setup();
+
  // Build scene.
- let scene =
+ let scene = build_scene(&mut app);
+
+ // Spawn scene.
+ let scene_id =
  app.world_mut()
- .run_system_once(|world: &World, asset_server: Res<'_, AssetServer>| {
- asset_server.add(DynamicScene::from_world(world))
+ .run_system_once(move |mut scene_spawner: ResMut<'_, SceneSpawner>| {
+ scene_spawner.spawn(scene.clone())
  });
 
+ // Check for event arrival.
+ app.update();
+ app.world_mut().run_system_once(
+ move |mut ev_scene: EventReader<'_, '_, SceneInstanceReady>| {
+ let mut events = ev_scene.read();
+
+ let event = events.next().expect("found no `SceneInstanceReady` event");
+ assert_eq!(
+ event.id, scene_id,
+ "`SceneInstanceReady` contains the wrong `InstanceId`"
+ );
+
+ assert!(events.next().is_none(), "found more than one event");
+ },
+ );
+ }
+
+ #[test]
+ fn event_scene_as_child() {
+ let mut app = setup();
+
+ // Build scene.
+ let scene = build_scene(&mut app);
+
+ // Spawn scene as child.
+ let (scene_id, scene_entity) = app.world_mut().run_system_once(
+ move |mut commands: Commands<'_, '_>, mut scene_spawner: ResMut<'_, SceneSpawner>| {
+ let entity = commands.spawn_empty().id();
+ let id = scene_spawner.spawn_as_child(scene.clone(), entity);
+ (id, entity)
+ },
+ );
+
+ // Check for event arrival.
+ app.update();
+ app.world_mut().run_system_once(
+ move |mut ev_scene: EventReader<'_, '_, SceneInstanceReady>| {
+ let mut events = ev_scene.read();
+
+ let event = events.next().expect("found no `SceneInstanceReady` event");
+ assert_eq!(
+ event.id, scene_id,
+ "`SceneInstanceReady` contains the wrong `InstanceId`"
+ );
+ assert_eq!(
+ event.parent,
+ Some(scene_entity),
+ "`SceneInstanceReady` contains the wrong parent entity"
+ );
+
+ assert!(events.next().is_none(), "found more than one event");
+ },
+ );
+ }
+
+ fn build_dynamic_scene(app: &mut App) -> Handle<DynamicScene> {
+ app.world_mut()
+ .run_system_once(|world: &World, asset_server: Res<'_, AssetServer>| {
+ asset_server.add(DynamicScene::from_world(world))
+ })
+ }
+
+ #[test]
+ fn event_dynamic_scene() {
+ let mut app = setup();
+
+ // Build scene.
+ let scene = build_dynamic_scene(&mut app);
+
  // Spawn scene.
- let scene_entity = app.world_mut().run_system_once(
+ let scene_id =
+ app.world_mut()
+ .run_system_once(move |mut scene_spawner: ResMut<'_, SceneSpawner>| {
+ scene_spawner.spawn_dynamic(scene.clone())
+ });
+
+ // Check for event arrival.
+ app.update();
+ app.world_mut().run_system_once(
+ move |mut ev_scene: EventReader<'_, '_, SceneInstanceReady>| {
+ let mut events = ev_scene.read();
+
+ let event = events.next().expect("found no `SceneInstanceReady` event");
+ assert_eq!(
+ event.id, scene_id,
+ "`SceneInstanceReady` contains the wrong `InstanceId`"
+ );
+
+ assert!(events.next().is_none(), "found more than one event");
+ },
+ );
+ }
+
+ #[test]
+ fn event_dynamic_scene_as_child() {
+ let mut app = setup();
+
+ // Build scene.
+ let scene = build_dynamic_scene(&mut app);
+
+ // Spawn scene as child.
+ let (scene_id, scene_entity) = app.world_mut().run_system_once(
  move |mut commands: Commands<'_, '_>, mut scene_spawner: ResMut<'_, SceneSpawner>| {
- let scene_entity = commands.spawn_empty().id();
- scene_spawner.spawn_dynamic_as_child(scene.clone(), scene_entity);
- scene_entity
+ let entity = commands.spawn_empty().id();
+ let id = scene_spawner.spawn_dynamic_as_child(scene.clone(), entity);
+ (id, entity)
  },
  );
 
@@ -536,13 +687,17 @@ mod tests {
  move |mut ev_scene: EventReader<'_, '_, SceneInstanceReady>| {
  let mut events = ev_scene.read();
 
+ let event = events.next().expect("found no `SceneInstanceReady` event");
  assert_eq!(
- events.next().expect("found no `SceneInstanceReady` event"),
- &SceneInstanceReady {
- parent: scene_entity
- },
+ event.id, scene_id,
+ "`SceneInstanceReady` contains the wrong `InstanceId`"
+ );
+ assert_eq!(
+ event.parent,
+ Some(scene_entity),
  "`SceneInstanceReady` contains the wrong parent entity"
  );
+
  assert!(events.next().is_none(), "found more than one event");
  },
  );