Add entities alongside resources

benches/benches/bevy_ecs/world/world_get.rs

@@ -51,9 +51,10 @@ pub fn world_entity(criterion: &mut Criterion) {
     for entity_count in RANGE.map(|i| i * 10_000) {
         group.bench_function(format!("{entity_count}_entities"), |bencher| {
             let world = setup::<Table>(entity_count);
+            let offset = world.resource_count();
 
             bencher.iter(|| {
-                for i in 0..entity_count {
+                for i in offset..(entity_count + offset) {
                     let entity =
                         // SAFETY: Range is exclusive.
                         Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
@@ -74,9 +75,10 @@ pub fn world_get(criterion: &mut Criterion) {
     for entity_count in RANGE.map(|i| i * 10_000) {
         group.bench_function(format!("{entity_count}_entities_table"), |bencher| {
             let world = setup::<Table>(entity_count);
+            let offset = world.resource_count();
 
             bencher.iter(|| {
-                for i in 0..entity_count {
+                for i in offset..(entity_count + offset) {
                     let entity =
                         // SAFETY: Range is exclusive.
                         Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
@@ -86,9 +88,10 @@ pub fn world_get(criterion: &mut Criterion) {
         });
         group.bench_function(format!("{entity_count}_entities_sparse"), |bencher| {
             let world = setup::<Sparse>(entity_count);
+            let offset = world.resource_count();
 
             bencher.iter(|| {
-                for i in 0..entity_count {
+                for i in offset..(entity_count + offset) {
                     let entity =
                         // SAFETY: Range is exclusive.
                         Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
@@ -109,10 +112,11 @@ pub fn world_query_get(criterion: &mut Criterion) {
     for entity_count in RANGE.map(|i| i * 10_000) {
         group.bench_function(format!("{entity_count}_entities_table"), |bencher| {
             let mut world = setup::<Table>(entity_count);
+            let offset = world.resource_count();
             let mut query = world.query::<&Table>();
 
             bencher.iter(|| {
-                for i in 0..entity_count {
+                for i in offset..(entity_count + offset) {
                     let entity =
                         // SAFETY: Range is exclusive.
                         Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
@@ -137,9 +141,10 @@ pub fn world_query_get(criterion: &mut Criterion) {
                 &WideTable<4>,
                 &WideTable<5>,
             )>();
+            let offset = world.resource_count();
 
             bencher.iter(|| {
-                for i in 0..entity_count {
+                for i in offset..(entity_count + offset) {
                     let entity =
                         // SAFETY: Range is exclusive.
                         Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
@@ -149,10 +154,11 @@ pub fn world_query_get(criterion: &mut Criterion) {
         });
         group.bench_function(format!("{entity_count}_entities_sparse"), |bencher| {
             let mut world = setup::<Sparse>(entity_count);
+            let offset = world.resource_count();
             let mut query = world.query::<&Sparse>();
 
             bencher.iter(|| {
-                for i in 0..entity_count {
+                for i in offset..(entity_count + offset) {
                     let entity =
                         // SAFETY: Range is exclusive.
                         Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));
@@ -177,9 +183,10 @@ pub fn world_query_get(criterion: &mut Criterion) {
                 &WideSparse<4>,
                 &WideSparse<5>,
             )>();
+            let offset = world.resource_count();
 
             bencher.iter(|| {
-                for i in 0..entity_count {
+                for i in offset..(entity_count + offset) {
                     // SAFETY: Range is exclusive.
                     let entity =
                         Entity::from_raw(EntityRow::new(unsafe { NonMaxU32::new_unchecked(i) }));

crates/bevy_ecs/src/component/info.rs

@@ -1,5 +1,5 @@
 use alloc::{borrow::Cow, vec::Vec};
-use bevy_platform::{collections::HashSet, sync::PoisonError};
+use bevy_platform::{collections::HashMap, collections::HashSet, sync::PoisonError};
 use bevy_ptr::OwningPtr;
 #[cfg(feature = "bevy_reflect")]
 use bevy_reflect::Reflect;
@@ -18,6 +18,7 @@ use crate::{
         RequiredComponents, StorageType,
     },
     lifecycle::ComponentHooks,
+    prelude::Entity,
     query::DebugCheckedUnwrap as _,
     resource::Resource,
     storage::SparseSetIndex,
@@ -346,6 +347,9 @@ pub struct Components {
     pub(super) components: Vec<Option<ComponentInfo>>,
     pub(super) indices: TypeIdMap<ComponentId>,
     pub(super) resource_indices: TypeIdMap<ComponentId>,
+    /// A lookup for the entities on which resources are stored.
+    /// It uses `ComponentId`s instead of `TypeId`s for untyped APIs
+    pub(crate) resource_entities: HashMap<ComponentId, Entity>,
     // This is kept internal and local to verify that no deadlocks can occor.
     pub(super) queued: bevy_platform::sync::RwLock<QueuedComponents>,
 }

crates/bevy_ecs/src/entity_disabling.rs

@@ -70,6 +70,7 @@
 use crate::{
     component::{ComponentId, Components, StorageType},
     query::FilteredAccess,
+    resource::IsResource,
     world::{FromWorld, World},
 };
 use bevy_ecs_macros::{Component, Resource};
@@ -143,6 +144,8 @@ impl FromWorld for DefaultQueryFilters {
         let mut filters = DefaultQueryFilters::empty();
         let disabled_component_id = world.register_component::<Disabled>();
         filters.register_disabling_component(disabled_component_id);
+        let is_resource_component_id = world.register_component::<IsResource>();
+        filters.register_disabling_component(is_resource_component_id);
         filters
     }
 }

crates/bevy_ecs/src/lib.rs

@@ -378,9 +378,9 @@ mod tests {
         let mut world = World::new();
         let e = world.spawn((TableStored("abc"), A(123))).id();
         let f = world.spawn((TableStored("def"), A(456))).id();
-        assert_eq!(world.entities.len(), 2);
+        assert_eq!(world.entity_count(), 2);
         assert!(world.despawn(e));
-        assert_eq!(world.entities.len(), 1);
+        assert_eq!(world.entity_count(), 1);
         assert!(world.get::<TableStored>(e).is_none());
         assert!(world.get::<A>(e).is_none());
         assert_eq!(world.get::<TableStored>(f).unwrap().0, "def");
@@ -393,9 +393,9 @@ mod tests {
 
         let e = world.spawn((TableStored("abc"), SparseStored(123))).id();
         let f = world.spawn((TableStored("def"), SparseStored(456))).id();
-        assert_eq!(world.entities.len(), 2);
+        assert_eq!(world.entity_count(), 2);
         assert!(world.despawn(e));
-        assert_eq!(world.entities.len(), 1);
+        assert_eq!(world.entity_count(), 1);
         assert!(world.get::<TableStored>(e).is_none());
         assert!(world.get::<SparseStored>(e).is_none());
         assert_eq!(world.get::<TableStored>(f).unwrap().0, "def");
@@ -1786,7 +1786,7 @@ mod tests {
     fn try_insert_batch() {
         let mut world = World::default();
         let e0 = world.spawn(A(0)).id();
-        let e1 = Entity::from_raw_u32(1).unwrap();
+        let e1 = Entity::from_raw_u32(2).unwrap();
 
         let values = vec![(e0, (A(1), B(0))), (e1, (A(0), B(1)))];
 
@@ -1810,7 +1810,7 @@ mod tests {
     fn try_insert_batch_if_new() {
         let mut world = World::default();
         let e0 = world.spawn(A(0)).id();
-        let e1 = Entity::from_raw_u32(1).unwrap();
+        let e1 = Entity::from_raw_u32(2).unwrap();
 
         let values = vec![(e0, (A(1), B(0))), (e1, (A(0), B(1)))];
 

crates/bevy_ecs/src/name.rs

@@ -278,7 +278,7 @@ mod tests {
         let mut query = world.query::<NameOrEntity>();
         let d1 = query.get(&world, e1).unwrap();
         // NameOrEntity Display for entities without a Name should be {index}v{generation}
-        assert_eq!(d1.to_string(), "0v0");
+        assert_eq!(d1.to_string(), "1v0");
         let d2 = query.get(&world, e2).unwrap();
         // NameOrEntity Display for entities with a Name should be the Name
         assert_eq!(d2.to_string(), "MyName");

crates/bevy_ecs/src/query/builder.rs

@@ -275,6 +275,7 @@ impl<'w, D: QueryData, F: QueryFilter> QueryBuilder<'w, D, F> {
 mod tests {
     use crate::{
         prelude::*,
+        resource::IsResource,
         world::{EntityMutExcept, EntityRefExcept, FilteredEntityMut, FilteredEntityRef},
     };
     use std::dbg;
@@ -332,6 +333,7 @@ mod tests {
     #[test]
     fn builder_or() {
         let mut world = World::new();
+
         world.spawn((A(0), B(0)));
         world.spawn(B(0));
         world.spawn(C(0));
@@ -485,6 +487,7 @@ mod tests {
 
         let mut query = QueryBuilder::<(FilteredEntityMut, EntityMutExcept<A>)>::new(&mut world)
             .data::<EntityMut>()
+            .filter::<Without<IsResource>>()
             .build();
 
         // Removing `EntityMutExcept<A>` just leaves A
@@ -496,6 +499,7 @@ mod tests {
 
         let mut query = QueryBuilder::<(FilteredEntityMut, EntityRefExcept<A>)>::new(&mut world)
             .data::<EntityMut>()
+            .filter::<Without<IsResource>>()
             .build();
 
         // Removing `EntityRefExcept<A>` just leaves A, plus read access

crates/bevy_ecs/src/query/iter.rs

@@ -2669,6 +2669,7 @@ mod tests {
     #[test]
     fn query_iter_sorts() {
         let mut world = World::new();
+
         for i in 0..100 {
             world.spawn(A(i as f32));
             world.spawn((A(i as f32), Sparse(i)));

crates/bevy_ecs/src/query/state.rs

@@ -1777,6 +1777,7 @@ mod tests {
         component::Component,
         entity_disabling::DefaultQueryFilters,
         prelude::*,
+        resource::IsResource,
         system::{QueryLens, RunSystemOnce},
         world::{FilteredEntityMut, FilteredEntityRef},
     };
@@ -1850,6 +1851,7 @@ mod tests {
     #[test]
     fn can_transmute_empty_tuple() {
         let mut world = World::new();
+
         world.register_component::<A>();
         let entity = world.spawn(A(10)).id();
 
@@ -2172,9 +2174,7 @@ mod tests {
         world.spawn((B(0), C(0)));
         world.spawn(C(0));
 
-        let mut df = DefaultQueryFilters::empty();
-        df.register_disabling_component(world.register_component::<C>());
-        world.insert_resource(df);
+        world.register_disabling_component::<C>();
 
         // Without<C> only matches the first entity
         let mut query = QueryState::<()>::new(&mut world);
@@ -2219,6 +2219,7 @@ mod tests {
         let mut df = DefaultQueryFilters::empty();
         df.register_disabling_component(world.register_component::<Sparse>());
         world.insert_resource(df);
+        world.register_disabling_component::<IsResource>();
 
         let mut query = QueryState::<()>::new(&mut world);
         // The query doesn't ask for sparse components, but the default filters adds
@@ -2229,6 +2230,7 @@ mod tests {
         let mut df = DefaultQueryFilters::empty();
         df.register_disabling_component(world.register_component::<Table>());
         world.insert_resource(df);
+        world.register_disabling_component::<IsResource>();
 
         let mut query = QueryState::<()>::new(&mut world);
         // If the filter is instead a table components, the query can still be dense

crates/bevy_ecs/src/resource.rs

@@ -1,5 +1,10 @@
 //! Resources are unique, singleton-like data types that can be accessed from systems and stored in the [`World`](crate::world::World).
 
+use crate::prelude::Component;
+use crate::prelude::ReflectComponent;
+use bevy_reflect::prelude::ReflectDefault;
+use bevy_reflect::Reflect;
+use core::marker::PhantomData;
 // The derive macro for the `Resource` trait
 pub use bevy_ecs_macros::Resource;
 
@@ -73,3 +78,89 @@ pub use bevy_ecs_macros::Resource;
     note = "consider annotating `{Self}` with `#[derive(Resource)]`"
 )]
 pub trait Resource: Send + Sync + 'static {}
+
+/// A marker component for the entity that stores the resource of type `T`.
+///
+/// This component is automatically inserted when a resource of type `T` is inserted into the world,
+/// and can be used to find the entity that stores a particular resource.
+///
+/// By contrast, the [`IsResource`] component is used to find all entities that store resources,
+/// regardless of the type of resource they store.
+///
+/// This component comes with a hook that ensures that at most one entity has this component for any given `R`:
+/// adding this component to an entity (or spawning an entity with this component) will despawn any other entity with this component.
+#[derive(Component, Debug)]
+#[require(IsResource)]
+#[cfg_attr(feature = "bevy_reflect", derive(Reflect), reflect(Component, Default))]
+pub struct ResourceEntity<R: Resource>(#[reflect(ignore)] PhantomData<R>);
+
+impl<R: Resource> Default for ResourceEntity<R> {
+    fn default() -> Self {
+        ResourceEntity(PhantomData)
+    }
+}
+
+/// A marker component for entities which store resources.
+///
+/// By contrast, the [`ResourceEntity<R>`] component is used to find the entity that stores a particular resource.
+/// This component is required by the [`ResourceEntity<R>`] component, and will automatically be added.
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Component, Default, Debug)
+)]
+#[derive(Component, Default, Debug)]
+pub struct IsResource;
+
+/// Used in conjunction with [`ResourceEntity<R>`], when no type information is available.
+/// This is used by [`World::insert_resource_by_id`](crate::world::World).
+#[derive(Resource)]
+pub(crate) struct TypeErasedResource;
+
+#[cfg(test)]
+mod tests {
+    use crate::change_detection::MaybeLocation;
+    use crate::ptr::OwningPtr;
+    use crate::resource::Resource;
+    use crate::world::World;
+    use bevy_platform::prelude::String;
+
+    #[test]
+    fn unique_resource_entities() {
+        #[derive(Default, Resource)]
+        struct TestResource1;
+
+        #[derive(Resource)]
+        #[expect(dead_code, reason = "field needed for testing")]
+        struct TestResource2(String);
+
+        #[derive(Resource)]
+        #[expect(dead_code, reason = "field needed for testing")]
+        struct TestResource3(u8);
+
+        let mut world = World::new();
+        let start = world.entities().len();
+        world.init_resource::<TestResource1>();
+        assert_eq!(world.entities().len(), start + 1);
+        world.insert_resource(TestResource2(String::from("Foo")));
+        assert_eq!(world.entities().len(), start + 2);
+        // like component registration, which just makes it known to the world that a component exists,
+        // registering a resource should not spawn an entity.
+        let id = world.register_resource::<TestResource3>();
+        assert_eq!(world.entities().len(), start + 2);
+        OwningPtr::make(20_u8, |ptr| {
+            // SAFETY: id was just initialized and corresponds to a resource.
+            unsafe {
+                world.insert_resource_by_id(id, ptr, MaybeLocation::caller());
+            }
+        });
+        assert_eq!(world.entities().len(), start + 3);
+        assert!(world.remove_resource_by_id(id).is_some());
+        assert_eq!(world.entities().len(), start + 2);
+        world.remove_resource::<TestResource1>();
+        assert_eq!(world.entities().len(), start + 1);
+        // make sure that trying to add a resource twice results, doesn't change the entity count
+        world.insert_resource(TestResource2(String::from("Bar")));
+        assert_eq!(world.entities().len(), start + 1);
+    }
+}

crates/bevy_ecs/src/system/system.rs

@@ -494,9 +494,9 @@ mod tests {
     #[test]
     fn command_processing() {
         let mut world = World::new();
-        assert_eq!(world.entities.len(), 0);
+        assert_eq!(world.entity_count(), 0);
         world.run_system_once(spawn_entity).unwrap();
-        assert_eq!(world.entities.len(), 1);
+        assert_eq!(world.entity_count(), 1);
     }
 
     #[test]