Struct bevy::scene::SceneSpawner

pub struct SceneSpawner { /* private fields */ }

Handles spawning and despawning scenes in the world, either synchronously or batched through the scene_spawner_system.

Synchronous methods: (Scene operations will take effect immediately)

• spawn_dynamic_sync
• spawn_sync
• despawn_sync
• despawn_instance_sync
• update_spawned_scenes
• spawn_queued_scenes
• despawn_queued_scenes
• despawn_queued_instances

Deferred methods: (Scene operations will be processed when the scene_spawner_system is run)

• spawn_dynamic
• spawn_dynamic_as_child
• spawn
• spawn_as_child
• despawn
• despawn_instance

Implementations

impl SceneSpawner

pub fn spawn_dynamic( &mut self, id: impl Into<Handle<DynamicScene>> ) -> InstanceId

Schedule the spawn of a new instance of the provided dynamic scene.

pub fn spawn_dynamic_as_child( &mut self, id: impl Into<Handle<DynamicScene>>, parent: Entity ) -> InstanceId

Schedule the spawn of a new instance of the provided dynamic scene as a child of parent.

pub fn spawn(&mut self, id: impl Into<Handle<Scene>>) -> InstanceId

Schedule the spawn of a new instance of the provided scene.

Examples found in repository

examples/tools/scene_viewer/scene_viewer_plugin.rs (line 128)

fn scene_load_check(
    asset_server: Res<AssetServer>,
    mut scenes: ResMut<Assets<Scene>>,
    gltf_assets: Res<Assets<Gltf>>,
    mut scene_handle: ResMut<SceneHandle>,
    mut scene_spawner: ResMut<SceneSpawner>,
) {
    match scene_handle.instance_id {
        None => {
            if asset_server.load_state(&scene_handle.gltf_handle) == LoadState::Loaded {
                let gltf = gltf_assets.get(&scene_handle.gltf_handle).unwrap();
                if gltf.scenes.len() > 1 {
                    info!(
                        "Displaying scene {} out of {}",
                        scene_handle.scene_index,
                        gltf.scenes.len()
                    );
                    info!("You can select the scene by adding '#Scene' followed by a number to the end of the file path (e.g '#Scene1' to load the second scene).");
                }

                let gltf_scene_handle =
                    gltf.scenes
                        .get(scene_handle.scene_index)
                        .unwrap_or_else(|| {
                            panic!(
                                "glTF file doesn't contain scene {}!",
                                scene_handle.scene_index
                            )
                        });
                let scene = scenes.get_mut(gltf_scene_handle).unwrap();

                let mut query = scene
                    .world
                    .query::<(Option<&DirectionalLight>, Option<&PointLight>)>();
                scene_handle.has_light =
                    query
                        .iter(&scene.world)
                        .any(|(maybe_directional_light, maybe_point_light)| {
                            maybe_directional_light.is_some() || maybe_point_light.is_some()
                        });

                scene_handle.instance_id =
                    Some(scene_spawner.spawn(gltf_scene_handle.clone_weak()));

                info!("Spawning scene...");
            }
        }
        Some(instance_id) if !scene_handle.is_loaded => {
            if scene_spawner.instance_is_ready(instance_id) {
                info!("...done!");
                scene_handle.is_loaded = true;
            }
        }
        Some(_) => {}
    }
}

pub fn spawn_as_child( &mut self, id: impl Into<Handle<Scene>>, parent: Entity ) -> InstanceId

Schedule the spawn of a new instance of the provided scene as a child of parent.

pub fn despawn(&mut self, id: impl Into<AssetId<DynamicScene>>)

Schedule the despawn of all instances of the provided dynamic scene.

pub fn despawn_instance(&mut self, instance_id: InstanceId)

Schedule the despawn of a scene instance, removing all its entities from the world.

pub fn despawn_sync( &mut self, world: &mut World, id: impl Into<AssetId<DynamicScene>> ) -> Result<(), SceneSpawnError>

Immediately despawns all instances of a dynamic scene.

pub fn despawn_instance_sync( &mut self, world: &mut World, instance_id: &InstanceId )

Immediately despawns a scene instance, removing all its entities from the world.

pub fn spawn_dynamic_sync( &mut self, world: &mut World, id: impl Into<AssetId<DynamicScene>> ) -> Result<InstanceId, SceneSpawnError>

Immediately spawns a new instance of the provided dynamic scene.

pub fn spawn_sync( &mut self, world: &mut World, id: AssetId<Scene> ) -> Result<InstanceId, SceneSpawnError>

Immediately spawns a new instance of the provided scene.

pub fn update_spawned_scenes( &mut self, world: &mut World, scene_ids: &[AssetId<DynamicScene>] ) -> Result<(), SceneSpawnError>

Iterate through all instances of the provided scenes and update those immediately.

Useful for updating already spawned scene instances after their corresponding scene has been modified.

pub fn despawn_queued_scenes( &mut self, world: &mut World ) -> Result<(), SceneSpawnError>

Immediately despawns all scenes scheduled for despawn by despawning their instances.

pub fn despawn_queued_instances(&mut self, world: &mut World)

Immediately despawns all scene instances scheduled for despawn.

pub fn spawn_queued_scenes( &mut self, world: &mut World ) -> Result<(), SceneSpawnError>

Immediately spawns all scenes scheduled for spawn.

pub fn instance_is_ready(&self, instance_id: InstanceId) -> bool

Check that an scene instance spawned previously is ready to use

Examples found in repository

examples/tools/scene_viewer/scene_viewer_plugin.rs (line 134)

fn scene_load_check(
    asset_server: Res<AssetServer>,
    mut scenes: ResMut<Assets<Scene>>,
    gltf_assets: Res<Assets<Gltf>>,
    mut scene_handle: ResMut<SceneHandle>,
    mut scene_spawner: ResMut<SceneSpawner>,
) {
    match scene_handle.instance_id {
        None => {
            if asset_server.load_state(&scene_handle.gltf_handle) == LoadState::Loaded {
                let gltf = gltf_assets.get(&scene_handle.gltf_handle).unwrap();
                if gltf.scenes.len() > 1 {
                    info!(
                        "Displaying scene {} out of {}",
                        scene_handle.scene_index,
                        gltf.scenes.len()
                    );
                    info!("You can select the scene by adding '#Scene' followed by a number to the end of the file path (e.g '#Scene1' to load the second scene).");
                }

                let gltf_scene_handle =
                    gltf.scenes
                        .get(scene_handle.scene_index)
                        .unwrap_or_else(|| {
                            panic!(
                                "glTF file doesn't contain scene {}!",
                                scene_handle.scene_index
                            )
                        });
                let scene = scenes.get_mut(gltf_scene_handle).unwrap();

                let mut query = scene
                    .world
                    .query::<(Option<&DirectionalLight>, Option<&PointLight>)>();
                scene_handle.has_light =
                    query
                        .iter(&scene.world)
                        .any(|(maybe_directional_light, maybe_point_light)| {
                            maybe_directional_light.is_some() || maybe_point_light.is_some()
                        });

                scene_handle.instance_id =
                    Some(scene_spawner.spawn(gltf_scene_handle.clone_weak()));

                info!("Spawning scene...");
            }
        }
        Some(instance_id) if !scene_handle.is_loaded => {
            if scene_spawner.instance_is_ready(instance_id) {
                info!("...done!");
                scene_handle.is_loaded = true;
            }
        }
        Some(_) => {}
    }
}

pub fn iter_instance_entities( &self, instance_id: InstanceId ) -> impl Iterator<Item = Entity>

Get an iterator over the entities in an instance, once it’s spawned.

Before the scene is spawned, the iterator will be empty. Use Self::instance_is_ready to check if the instance is ready.

Trait Implementations

impl Default for SceneSpawner

fn default() -> SceneSpawner

Returns the “default value” for a type.

impl Resource for SceneSpawner

where SceneSpawner: Send + Sync + 'static,