SceneSpawner: add unload() and unload_sync()

This allows you to unload scenes.

Refs: bevyengine#255

crates/bevy_scene/src/scene_spawner.rs

@@ -28,6 +28,7 @@ pub struct SceneSpawner {
  scene_asset_event_reader: EventReader<AssetEvent<Scene>>,
  scenes_to_spawn: Vec<Handle<Scene>>,
  scenes_to_load: Vec<Handle<Scene>>,
+ scenes_to_unload: Vec<Handle<Scene>>,
 }
 
 #[derive(Error, Debug)]
@@ -47,6 +48,10 @@ impl SceneSpawner {
  self.scenes_to_load.push(scene_handle);
  }
 
+ pub fn unload(&mut self, scene_handle: Handle<Scene>) {
+ self.scenes_to_unload.push(scene_handle);
+ }
+
  pub fn load_sync(
  &mut self,
  world: &mut World,
@@ -58,6 +63,28 @@ impl SceneSpawner {
  Ok(())
  }
 
+ pub fn unload_sync(
+ &mut self,
+ world: &mut World,
+ scene_handle: Handle<Scene>,
+ ) -> Result<(), SceneSpawnError> {
+ if let Some(instance_ids) = self.spawned_scenes.get(&scene_handle) {
+ for instance_id in instance_ids {
+ if let Some(instance) = self.spawned_instances.get(&instance_id) {
+ for entity in instance.entity_map.values() {
+ let _ = world.despawn(*entity); // Ignore the result, unload only cares if it exists.
+ }
+ }
+ }
+
+ self.loaded_scenes
+ .retain(|handle| handle.id != scene_handle.id);
+ self.spawned_scenes
+ .retain(|handle, _| handle.id != scene_handle.id);
+ }
+ Ok(())
+ }
+
  pub fn spawn_sync(
  &mut self,
  world: &mut World,
@@ -152,19 +179,32 @@ impl SceneSpawner {
  world: &mut World,
  resources: &Resources,
  ) -> Result<(), SceneSpawnError> {
- let scenes_to_load = self.scenes_to_load.drain(..).collect::<Vec<_>>();
- let mut non_existent_scenes = Vec::new();
+ let mut scenes_to_load = Vec::new();
+ std::mem::swap(&mut self.scenes_to_load, &mut scenes_to_load);
+
  for scene_handle in scenes_to_load {
  match self.load_sync(world, resources, scene_handle) {
  Ok(_) => {}
  Err(SceneSpawnError::NonExistentScene { .. }) => {
- non_existent_scenes.push(scene_handle)
+ self.scenes_to_spawn.push(scene_handle)
  }
  Err(err) => return Err(err),
  }
  }
 
- self.scenes_to_load = non_existent_scenes;
+ Ok(())
+ }
+
+ pub fn unload_queued_scenes(&mut self, world: &mut World) -> Result<(), SceneSpawnError> {
+ let mut scenes_to_unload = Vec::new();
+ std::mem::swap(&mut self.scenes_to_unload, &mut scenes_to_unload);
+
+ for scene_handle in scenes_to_unload {
+ match self.unload_sync(world, scene_handle) {
+ Ok(_) => {}
+ Err(err) => return Err(err),
+ }
+ }
  Ok(())
  }
 
@@ -173,19 +213,19 @@ impl SceneSpawner {
  world: &mut World,
  resources: &Resources,
  ) -> Result<(), SceneSpawnError> {
- let scenes_to_spawn = self.scenes_to_spawn.drain(..).collect::<Vec<_>>();
- let mut non_existent_scenes = Vec::new();
+ let mut scenes_to_spawn = Vec::new();
+ std::mem::swap(&mut self.scenes_to_spawn, &mut scenes_to_spawn);
+
  for scene_handle in scenes_to_spawn {
  match self.spawn_sync(world, resources, scene_handle) {
  Ok(_) => {}
  Err(SceneSpawnError::NonExistentScene { .. }) => {
- non_existent_scenes.push(scene_handle)
+ self.scenes_to_spawn.push(scene_handle)
  }
  Err(err) => return Err(err),
  }
  }
 
- self.scenes_to_spawn = non_existent_scenes;
  Ok(())
  }
 }
@@ -209,6 +249,7 @@ pub fn scene_spawner_system(world: &mut World, resources: &mut Resources) {
  }
  }
 
+ scene_spawner.unload_queued_scenes(world).unwrap();
  scene_spawner.load_queued_scenes(world, resources).unwrap();
  scene_spawner.spawn_queued_scenes(world, resources).unwrap();
  scene_spawner