Struct bevy::prelude::DynamicScene

pub struct DynamicScene {
    pub resources: Vec<Box<dyn Reflect>>,
    pub entities: Vec<DynamicEntity>,
}

A collection of serializable resources and dynamic entities.

Each dynamic entity in the collection contains its own run-time defined set of components. To spawn a dynamic scene, you can use either:

• SceneSpawner::spawn_dynamic
• adding the DynamicSceneBundle to an entity
• adding the Handle<DynamicScene> to an entity (the scene will only be visible if the entity already has Transform and GlobalTransform components)
• using the DynamicSceneBuilder to construct a DynamicScene from World.

Fields

resources: Vec<Box<dyn Reflect>>

Resources stored in the dynamic scene.

entities: Vec<DynamicEntity>

Entities contained in the dynamic scene.

Implementations

impl DynamicScene

pub fn from_scene(scene: &Scene) -> DynamicScene

Create a new dynamic scene from a given scene.

pub fn from_world(world: &World) -> DynamicScene

Create a new dynamic scene from a given world.

Examples found in repository

examples/scene/scene.rs (line 124)

fn save_scene_system(world: &mut World) {
    // Scenes can be created from any ECS World.
    // You can either create a new one for the scene or use the current World.
    // For demonstration purposes, we'll create a new one.
    let mut scene_world = World::new();

    // The `TypeRegistry` resource contains information about all registered types (including components).
    // This is used to construct scenes, so we'll want to ensure that our previous type registrations
    // exist in this new scene world as well.
    // To do this, we can simply clone the `AppTypeRegistry` resource.
    let type_registry = world.resource::<AppTypeRegistry>().clone();
    scene_world.insert_resource(type_registry);

    let mut component_b = ComponentB::from_world(world);
    component_b.value = "hello".to_string();
    scene_world.spawn((
        component_b,
        ComponentA { x: 1.0, y: 2.0 },
        Transform::IDENTITY,
        Name::new("joe"),
    ));
    scene_world.spawn(ComponentA { x: 3.0, y: 4.0 });
    scene_world.insert_resource(ResourceA { score: 1 });

    // With our sample world ready to go, we can now create our scene using DynamicScene or DynamicSceneBuilder.
    // For simplicity, we will create our scene using DynamicScene:
    let scene = DynamicScene::from_world(&scene_world);

    // Scenes can be serialized like this:
    let type_registry = world.resource::<AppTypeRegistry>();
    let type_registry = type_registry.read();
    let serialized_scene = scene.serialize(&type_registry).unwrap();

    // Showing the scene in the console
    info!("{}", serialized_scene);

    // Writing the scene to a new file. Using a task to avoid calling the filesystem APIs in a system
    // as they are blocking
    // This can't work in WASM as there is no filesystem access
    #[cfg(not(target_arch = "wasm32"))]
    IoTaskPool::get()
        .spawn(async move {
            // Write the scene RON data to file
            File::create(format!("assets/{NEW_SCENE_FILE_PATH}"))
                .and_then(|mut file| file.write(serialized_scene.as_bytes()))
                .expect("Error while writing scene to file");
        })
        .detach();
}

pub fn write_to_world_with( &self, world: &mut World, entity_map: &mut HashMap<Entity, Entity, EntityHash>, type_registry: &AppTypeRegistry ) -> Result<(), SceneSpawnError>

Write the resources, the dynamic entities, and their corresponding components to the given world.

This method will return a SceneSpawnError if a type either is not registered in the provided AppTypeRegistry resource, or doesn’t reflect the Component or Resource trait.

pub fn write_to_world( &self, world: &mut World, entity_map: &mut HashMap<Entity, Entity, EntityHash> ) -> Result<(), SceneSpawnError>

Write the resources, the dynamic entities, and their corresponding components to the given world.

This method will return a SceneSpawnError if a type either is not registered in the world’s AppTypeRegistry resource, or doesn’t reflect the Component trait.

pub fn serialize(&self, registry: &TypeRegistry) -> Result<String, Error>

Available on crate feature serialize only.

Serialize this dynamic scene into the official Bevy scene format (.scn / .scn.ron).

The Bevy scene format is based on Rusty Object Notation (RON). It describes the scene in a human-friendly format. To deserialize the scene, use the SceneLoader.

Examples found in repository

examples/scene/scene.rs (line 129)

fn save_scene_system(world: &mut World) {
    // Scenes can be created from any ECS World.
    // You can either create a new one for the scene or use the current World.
    // For demonstration purposes, we'll create a new one.
    let mut scene_world = World::new();

    // The `TypeRegistry` resource contains information about all registered types (including components).
    // This is used to construct scenes, so we'll want to ensure that our previous type registrations
    // exist in this new scene world as well.
    // To do this, we can simply clone the `AppTypeRegistry` resource.
    let type_registry = world.resource::<AppTypeRegistry>().clone();
    scene_world.insert_resource(type_registry);

    let mut component_b = ComponentB::from_world(world);
    component_b.value = "hello".to_string();
    scene_world.spawn((
        component_b,
        ComponentA { x: 1.0, y: 2.0 },
        Transform::IDENTITY,
        Name::new("joe"),
    ));
    scene_world.spawn(ComponentA { x: 3.0, y: 4.0 });
    scene_world.insert_resource(ResourceA { score: 1 });

    // With our sample world ready to go, we can now create our scene using DynamicScene or DynamicSceneBuilder.
    // For simplicity, we will create our scene using DynamicScene:
    let scene = DynamicScene::from_world(&scene_world);

    // Scenes can be serialized like this:
    let type_registry = world.resource::<AppTypeRegistry>();
    let type_registry = type_registry.read();
    let serialized_scene = scene.serialize(&type_registry).unwrap();

    // Showing the scene in the console
    info!("{}", serialized_scene);

    // Writing the scene to a new file. Using a task to avoid calling the filesystem APIs in a system
    // as they are blocking
    // This can't work in WASM as there is no filesystem access
    #[cfg(not(target_arch = "wasm32"))]
    IoTaskPool::get()
        .spawn(async move {
            // Write the scene RON data to file
            File::create(format!("assets/{NEW_SCENE_FILE_PATH}"))
                .and_then(|mut file| file.write(serialized_scene.as_bytes()))
                .expect("Error while writing scene to file");
        })
        .detach();
}

Trait Implementations

impl Default for DynamicScene

fn default() -> DynamicScene

Returns the “default value” for a type.

impl TypePath for DynamicScene

where DynamicScene: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl VisitAssetDependencies for DynamicScene

fn visit_dependencies(&self, visit: &mut impl FnMut(UntypedAssetId))

impl Asset for DynamicScene