Create a DynamicScene from a world and an entity root

crates/bevy_scene/src/dynamic_scene.rs

@@ -3,9 +3,11 @@ use anyhow::Result;
 use bevy_app::AppTypeRegistry;
 use bevy_ecs::{
  entity::EntityMap,
+ prelude::Entity,
  reflect::{ReflectComponent, ReflectMapEntities},
  world::World,
 };
+use bevy_hierarchy::Children;
 use bevy_reflect::{Reflect, TypeRegistryArc, TypeUuid};
 use serde::Serialize;
 
@@ -33,12 +35,12 @@ pub struct DynamicEntity {
 
 impl DynamicScene {
  /// Create a new dynamic scene from a given scene.
- pub fn from_scene(scene: &Scene, type_registry: &TypeRegistryArc) -> Self {
+ pub fn from_scene(scene: &Scene, type_registry: &AppTypeRegistry) -> Self {
  Self::from_world(&scene.world, type_registry)
  }
 
  /// Create a new dynamic scene from a given world.
- pub fn from_world(world: &World, type_registry: &TypeRegistryArc) -> Self {
+ pub fn from_world(world: &World, type_registry: &AppTypeRegistry) -> Self {
  let mut scene = DynamicScene::default();
  let type_registry = type_registry.read();
 
@@ -76,17 +78,79 @@ impl DynamicScene {
  scene
  }
 
+ /// Create a new dynamic scene from a given world at a given root.
+ pub fn from_world_at_root(
+ world: &World,
+ root: Entity,
+ type_registry: &AppTypeRegistry,
+ ) -> Self {
+ let mut scene = DynamicScene::default();
+ let type_registry = type_registry.read();
+
+ // Extract all entities that are a descendent of root
+ let mut entities_of_interest = Vec::new();
+ let mut entities_to_process = vec![root];
+ while let Some(entity) = entities_to_process.pop() {
+ entities_of_interest.push(entity);
+ if let Some(children) = world.entity(entity).get::<Children>() {
+ entities_to_process.extend(children.iter());
+ }
+ }
+
+ for archetype in world.archetypes().iter() {
+ let entities_offset = scene.entities.len();
+
+ // Create a new dynamic entity for each entity of the given archetype
+ // and insert it into the dynamic scene.
+ for entity in archetype
+ .entities()
+ .iter()
+ .filter(|entity| entities_of_interest.contains(entity))
+ {
+ scene.entities.push(DynamicEntity {
+ entity: entity.id(),
+ components: Vec::new(),
+ });
+ }
+
+ // Add each reflection-powered component to the entity it belongs to.
+ for component_id in archetype.components() {
+ let reflect_component = world
+ .components()
+ .get_info(component_id)
+ .and_then(|info| type_registry.get(info.type_id().unwrap()))
+ .and_then(|registration| registration.data::<ReflectComponent>());
+ if let Some(reflect_component) = reflect_component {
+ for (i, entity) in archetype
+ .entities()
+ .iter()
+ .filter(|entity| entities_of_interest.contains(entity))
+ .enumerate()
+ {
+ if let Some(component) = reflect_component.reflect(world, *entity) {
+ scene.entities[entities_offset + i]
+ .components
+ .push(component.clone_value());
+ }
+ }
+ }
+ }
+ }
+
+ scene
+ }
+
  /// Write the dynamic entities and their corresponding components to the given world.
  ///
  /// This method will return a [`SceneSpawnError`] if a type either is not registered
  /// or doesn't reflect the [`Component`](bevy_ecs::component::Component) trait.
- pub fn write_to_world(
+ pub fn write_to_world_with(
  &self,
  world: &mut World,
  entity_map: &mut EntityMap,
+ type_registry: &AppTypeRegistry,
  ) -> Result<(), SceneSpawnError> {
- let registry = world.resource::<AppTypeRegistry>().clone();
- let type_registry = registry.read();
+ let type_registry = type_registry.read();
 
  for scene_entity in &self.entities {
  // Fetch the entity with the given entity id from the `entity_map`

crates/bevy_scene/src/scene.rs

@@ -1,20 +1,21 @@
 use bevy_app::AppTypeRegistry;
+use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
  entity::EntityMap,
  reflect::{ReflectComponent, ReflectMapEntities},
  world::World,
 };
 use bevy_reflect::TypeUuid;
 
-use crate::{InstanceInfo, SceneSpawnError};
+use crate::{DynamicScene, InstanceInfo, SceneSpawnError};
 
 /// To spawn a scene, you can use either:
 /// * [`SceneSpawner::spawn`](crate::SceneSpawner::spawn)
 /// * adding the [`SceneBundle`](crate::SceneBundle) to an entity
 /// * adding the [`Handle<Scene>`](bevy_asset::Handle) to an entity (the scene will only be
 /// visible if the entity already has [`Transform`](bevy_transform::components::Transform) and
 /// [`GlobalTransform`](bevy_transform::components::GlobalTransform) components)
-#[derive(Debug, TypeUuid)]
+#[derive(Debug, TypeUuid, Deref, DerefMut)]
 #[uuid = "c156503c-edd9-4ec7-8d33-dab392df03cd"]
 pub struct Scene {
  pub world: World,
@@ -25,6 +26,18 @@ impl Scene {
  Self { world }
  }
 
+ /// Create a new scene from a given dynamic scene.
+ pub fn from_dynamic_scene(
+ dynamic_scene: &DynamicScene,
+ type_registry: &AppTypeRegistry,
+ ) -> Result<Scene, SceneSpawnError> {
+ let mut world = World::new();
+ let mut entity_map = EntityMap::default();
+ dynamic_scene.write_to_world_with(&mut world, &mut entity_map, type_registry)?;
+
+ Ok(Self { world })
+ }
+
  /// Clone the scene.
  ///
  /// This method will return a [`SceneSpawnError`] if a type either is not registered in the

crates/bevy_scene/src/scene_spawner.rs

@@ -144,7 +144,11 @@ impl SceneSpawner {
  .ok_or_else(|| SceneSpawnError::NonExistentScene {
  handle: scene_handle.clone_weak(),
  })?;
- scene.write_to_world(world, entity_map)
+ scene.write_to_world_with(
+ world,
+ entity_map,
+ &world.resource::<AppTypeRegistry>().clone(),
+ )
  })
  }