Split Main world and Render world Entity space

crates/bevy_app/src/sub_app.rs

@@ -102,6 +102,21 @@ impl SubApp {
         Self::default()
     }
 
+    /// Returns a default, empty [`SubApp`] using an entity alloc mask.
+    pub fn new_with_entity_alloc_mask(mask: u32) -> Self {
+        let mut world = World::new_with_entity_alloc_mask(mask);
+        world.init_resource::<Schedules>();
+        Self {
+            world,
+            plugin_registry: Vec::default(),
+            plugin_names: HashSet::default(),
+            plugin_build_depth: 0,
+            plugins_state: PluginsState::Adding,
+            update_schedule: None,
+            extract: None,
+        }
+    }
+
     /// This method is a workaround. Each [`SubApp`] can have its own plugins, but [`Plugin`]
     /// works on an [`App`] as a whole.
     fn run_as_app<F>(&mut self, f: F)

crates/bevy_ecs/src/entity/mod.rs

@@ -59,7 +59,9 @@ use crate::{
 };
 #[cfg(feature = "serialize")]
 use serde::{Deserialize, Serialize};
-use std::{fmt, hash::Hash, mem, num::NonZeroU32, sync::atomic::Ordering};
+use std::{
+    fmt, hash::Hash, iter::StepBy, mem, num::NonZeroU32, ops::Range, sync::atomic::Ordering,
+};
 
 #[cfg(target_has_atomic = "64")]
 use std::sync::atomic::AtomicI64 as AtomicIdCursor;
@@ -453,7 +455,8 @@ pub struct ReserveEntitiesIterator<'a> {
     index_iter: std::slice::Iter<'a, u32>,
 
     // New Entity indices to hand out, outside the range of meta.len().
-    index_range: std::ops::Range<u32>,
+    index_range: StepBy<Range<u32>>,
+    mask: u32,
 }
 
 impl<'a> Iterator for ReserveEntitiesIterator<'a> {
@@ -465,7 +468,11 @@ impl<'a> Iterator for ReserveEntitiesIterator<'a> {
             .map(|&index| {
                 Entity::from_raw_and_generation(index, self.meta[index as usize].generation)
             })
-            .or_else(|| self.index_range.next().map(Entity::from_raw))
+            .or_else(|| {
+                self.index_range
+                    .next()
+                    .map(|i| Entity::from_raw(i | self.mask))
+            })
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
@@ -477,6 +484,10 @@ impl<'a> Iterator for ReserveEntitiesIterator<'a> {
 impl<'a> ExactSizeIterator for ReserveEntitiesIterator<'a> {}
 impl<'a> core::iter::FusedIterator for ReserveEntitiesIterator<'a> {}
 
+pub const RESERVED_BITS: usize = 1;
+pub const ENTITY_ALLOC_STEP: usize = 1 << RESERVED_BITS;
+pub const INDEX_HIGH_MASK: u32 = u32::MAX << RESERVED_BITS;
+
 /// A [`World`]'s internal metadata store on all of its entities.
 ///
 /// Contains metadata on:
@@ -533,6 +544,7 @@ pub struct Entities {
     free_cursor: AtomicIdCursor,
     /// Stores the number of free entities for [`len`](Entities::len)
     len: u32,
+    mask: u32,
 }
 
 impl Entities {
@@ -542,6 +554,18 @@ impl Entities {
             pending: Vec::new(),
             free_cursor: AtomicIdCursor::new(0),
             len: 0,
+            mask: 0,
+        }
+    }
+
+    pub(crate) fn new_with_mask(mask: u32) -> Self {
+        assert!((mask as usize) < ENTITY_ALLOC_STEP);
+        Entities {
+            meta: Vec::new(),
+            pending: Vec::new(),
+            free_cursor: AtomicIdCursor::new(0),
+            len: 0,
+            mask,
         }
     }
 
@@ -577,7 +601,8 @@ impl Entities {
             // to go, yielding `meta.len()+0 .. meta.len()+3`.
             let base = self.meta.len() as IdCursor;
 
-            let new_id_end = u32::try_from(base - range_start).expect("too many entities");
+            let new_id_end = u32::try_from(base - (range_start * ENTITY_ALLOC_STEP as i64))
+                .expect("too many entities");
 
             // `new_id_end` is in range, so no need to check `start`.
             let new_id_start = (base - range_end.min(0)) as u32;
@@ -588,7 +613,8 @@ impl Entities {
         ReserveEntitiesIterator {
             meta: &self.meta[..],
             index_iter: self.pending[freelist_range].iter(),
-            index_range: new_id_start..new_id_end,
+            index_range: (new_id_start..new_id_end).step_by(ENTITY_ALLOC_STEP),
+            mask: self.mask,
         }
     }
 
@@ -608,7 +634,9 @@ impl Entities {
             // As `self.free_cursor` goes more and more negative, we return IDs farther
             // and farther beyond `meta.len()`.
             Entity::from_raw(
-                u32::try_from(self.meta.len() as IdCursor - n).expect("too many entities"),
+                u32::try_from(self.meta.len() as IdCursor - (n * ENTITY_ALLOC_STEP as i64))
+                    .expect("too many entities")
+                    | self.mask,
             )
         }
     }
@@ -631,43 +659,10 @@ impl Entities {
             Entity::from_raw_and_generation(index, self.meta[index as usize].generation)
         } else {
             let index = u32::try_from(self.meta.len()).expect("too many entities");
-            self.meta.push(EntityMeta::EMPTY);
-            Entity::from_raw(index)
-        }
-    }
-
-    /// Allocate a specific entity ID, overwriting its generation.
-    ///
-    /// Returns the location of the entity currently using the given ID, if any. Location should be
-    /// written immediately.
-    pub fn alloc_at(&mut self, entity: Entity) -> Option<EntityLocation> {
-        self.verify_flushed();
-
-        let loc = if entity.index() as usize >= self.meta.len() {
-            self.pending
-                .extend((self.meta.len() as u32)..entity.index());
-            let new_free_cursor = self.pending.len() as IdCursor;
-            *self.free_cursor.get_mut() = new_free_cursor;
             self.meta
-                .resize(entity.index() as usize + 1, EntityMeta::EMPTY);
-            self.len += 1;
-            None
-        } else if let Some(index) = self.pending.iter().position(|item| *item == entity.index()) {
-            self.pending.swap_remove(index);
-            let new_free_cursor = self.pending.len() as IdCursor;
-            *self.free_cursor.get_mut() = new_free_cursor;
-            self.len += 1;
-            None
-        } else {
-            Some(mem::replace(
-                &mut self.meta[entity.index() as usize].location,
-                EntityMeta::EMPTY.location,
-            ))
-        };
-
-        self.meta[entity.index() as usize].generation = entity.generation;
-
-        loc
+                .extend((0..ENTITY_ALLOC_STEP).map(|_| EntityMeta::EMPTY));
+            Entity::from_raw(index | self.mask)
+        }
     }
 
     /// Allocate a specific entity ID, overwriting its generation.
@@ -680,12 +675,13 @@ impl Entities {
         self.verify_flushed();
 
         let result = if entity.index() as usize >= self.meta.len() {
-            self.pending
-                .extend((self.meta.len() as u32)..entity.index());
+            let padding = (entity.index() + 1).next_multiple_of(ENTITY_ALLOC_STEP as u32);
+            self.pending.extend(
+                (self.meta.len() as u32..padding).filter(|v| (v & !INDEX_HIGH_MASK) == self.mask),
+            );
             let new_free_cursor = self.pending.len() as IdCursor;
             *self.free_cursor.get_mut() = new_free_cursor;
-            self.meta
-                .resize(entity.index() as usize + 1, EntityMeta::EMPTY);
+            self.meta.resize(padding as usize, EntityMeta::EMPTY);
             self.len += 1;
             AllocAtWithoutReplacement::DidNotExist
         } else if let Some(index) = self.pending.iter().position(|item| *item == entity.index()) {
@@ -731,11 +727,13 @@ impl Entities {
 
         let loc = mem::replace(&mut meta.location, EntityMeta::EMPTY.location);
 
-        self.pending.push(entity.index());
+        if entity.index() & !INDEX_HIGH_MASK == self.mask {
+            self.pending.push(entity.index());
 
-        let new_free_cursor = self.pending.len() as IdCursor;
-        *self.free_cursor.get_mut() = new_free_cursor;
-        self.len -= 1;
+            let new_free_cursor = self.pending.len() as IdCursor;
+            *self.free_cursor.get_mut() = new_free_cursor;
+            self.len -= 1;
+        }
         Some(loc)
     }
 
@@ -834,7 +832,8 @@ impl Entities {
             // If this entity was manually created, then free_cursor might be positive
             // Returning None handles that case correctly
             let num_pending = usize::try_from(-free_cursor).ok()?;
-            (idu < self.meta.len() + num_pending).then_some(Entity::from_raw(index))
+            (idu < self.meta.len() + num_pending * ENTITY_ALLOC_STEP)
+                .then_some(Entity::from_raw(index))
         }
     }
 
@@ -860,7 +859,7 @@ impl Entities {
             current_free_cursor as usize
         } else {
             let old_meta_len = self.meta.len();
-            let new_meta_len = old_meta_len + -current_free_cursor as usize;
+            let new_meta_len = old_meta_len + (-current_free_cursor as usize) * ENTITY_ALLOC_STEP;
             self.meta.resize(new_meta_len, EntityMeta::EMPTY);
             self.len += -current_free_cursor as u32;
             for (index, meta) in self.meta.iter_mut().enumerate().skip(old_meta_len) {
@@ -902,6 +901,7 @@ impl Entities {
     pub unsafe fn flush_and_reserve_invalid_assuming_no_entities(&mut self, count: usize) {
         let free_cursor = self.free_cursor.get_mut();
         *free_cursor = 0;
+        let count = count.next_multiple_of(ENTITY_ALLOC_STEP);
         self.meta.reserve(count);
         // SAFETY: The EntityMeta struct only contains integers, and it is valid to have all bytes set to u8::MAX
         unsafe {

crates/bevy_ecs/src/world/mod.rs

@@ -187,6 +187,35 @@ impl World {
         World::default()
     }
 
+    /// Creates a new empty [`World`].
+    ///
+    /// # Panics
+    ///
+    /// If [`usize::MAX`] [`World`]s have been created.
+    /// This guarantee allows System Parameters to safely uniquely identify a [`World`],
+    /// since its [`WorldId`] is unique
+    pub fn new_with_entity_alloc_mask(mask: u32) -> Self {
+        let mut world = Self {
+            id: WorldId::new().expect("More `bevy` `World`s have been created than is supported"),
+            entities: Entities::new_with_mask(mask),
+            components: Default::default(),
+            archetypes: Archetypes::new(),
+            storages: Default::default(),
+            bundles: Default::default(),
+            observers: Observers::default(),
+            removed_components: Default::default(),
+            // Default value is `1`, and `last_change_tick`s default to `0`, such that changes
+            // are detected on first system runs and for direct world queries.
+            change_tick: AtomicU32::new(1),
+            last_change_tick: Tick::new(0),
+            last_check_tick: Tick::new(0),
+            last_trigger_id: 0,
+            command_queue: RawCommandQueue::new(),
+        };
+        world.bootstrap();
+        world
+    }
+
     /// Retrieves this [`World`]'s unique ID
     #[inline]
     pub fn id(&self) -> WorldId {

crates/bevy_gizmos/src/lib.rs

@@ -105,6 +105,7 @@ use bevy_render::{
         ShaderType, VertexFormat,
     },
     renderer::RenderDevice,
+    world_sync::TemporaryRenderEntity,
     Extract, ExtractSchedule, Render, RenderApp, RenderSet,
 };
 
@@ -452,6 +453,7 @@ fn extract_gizmo_data(
             (*handle).clone_weak(),
             #[cfg(any(feature = "bevy_pbr", feature = "bevy_sprite"))]
             config::GizmoMeshConfig::from(config),
+            TemporaryRenderEntity,
         ));
     }
 }

crates/bevy_pbr/src/lib.rs

@@ -420,6 +420,9 @@ impl Plugin for PbrPlugin {
             )
             .init_resource::<LightMeta>();
 
+        render_app.world_mut().observe(add_light_view_entities);
+        render_app.world_mut().observe(remove_light_view_entities);
+
         let shadow_pass_node = ShadowPassNode::new(render_app.world_mut());
         let mut graph = render_app.world_mut().resource_mut::<RenderGraph>();
         let draw_3d_graph = graph.get_sub_graph_mut(Core3d).unwrap();