Store Resources as components on singleton entities

benches/benches/bevy_ecs/scheduling/run_condition.rs

@@ -55,7 +55,7 @@ pub fn run_condition_no(criterion: &mut Criterion) {
     group.finish();
 }
 
-#[derive(Component, Resource)]
+#[derive(Resource)]
 struct TestBool(pub bool);
 
 pub fn run_condition_yes_with_query(criterion: &mut Criterion) {

crates/bevy_a11y/src/lib.rs

@@ -73,7 +73,8 @@ use bevy_ecs::{component::Component, message::Message, resource::Resource, sched
 
 #[cfg(feature = "bevy_reflect")]
 use {
-    bevy_ecs::reflect::ReflectResource, bevy_reflect::std_traits::ReflectDefault,
+    bevy_ecs::reflect::{ReflectComponent, ReflectResource},
+    bevy_reflect::std_traits::ReflectDefault,
     bevy_reflect::Reflect,
 };
 

crates/bevy_ecs/macros/src/component.rs

@@ -14,6 +14,11 @@ use syn::{
 };
 
 pub fn derive_resource(input: TokenStream) -> TokenStream {
+    // The resource derive *also* implements the Component trait
+    // We generate the Component implementation first, then add the Resource implementation,
+    // so then we can pick up all of the attributes from the Component derive
+    let component_derive_token_stream = derive_component(input.clone());
+
     let mut ast = parse_macro_input!(input as DeriveInput);
     let bevy_ecs_path: Path = crate::bevy_ecs_path();
 
@@ -25,10 +30,15 @@ pub fn derive_resource(input: TokenStream) -> TokenStream {
     let struct_name = &ast.ident;
     let (impl_generics, type_generics, where_clause) = &ast.generics.split_for_impl();
 
-    TokenStream::from(quote! {
+    let resource_impl_token_stream = TokenStream::from(quote! {
         impl #impl_generics #bevy_ecs_path::resource::Resource for #struct_name #type_generics #where_clause {
         }
-    })
+    });
+
+    resource_impl_token_stream
+        .into_iter()
+        .chain(component_derive_token_stream)
+        .collect()
 }
 
 /// Component derive syntax is documented on both the macro and the trait.

crates/bevy_ecs/macros/src/lib.rs

@@ -600,7 +600,10 @@ pub fn derive_message(input: TokenStream) -> TokenStream {
 }
 
 /// Implement the `Resource` trait.
-#[proc_macro_derive(Resource)]
+#[proc_macro_derive(
+    Resource,
+    attributes(component, require, relationship, relationship_target, entities)
+)]
 pub fn derive_resource(input: TokenStream) -> TokenStream {
     component::derive_resource(input)
 }
@@ -677,7 +680,7 @@ pub fn derive_resource(input: TokenStream) -> TokenStream {
 /// #[component(hook_name = function)]
 /// struct MyComponent;
 /// ```
-/// where `hook_name` is `on_add`, `on_insert`, `on_replace` or `on_remove`;  
+/// where `hook_name` is `on_add`, `on_insert`, `on_replace` or `on_remove`;
 /// `function` can be either a path, e.g. `some_function::<Self>`,
 /// or a function call that returns a function that can be turned into
 /// a `ComponentHook`, e.g. `get_closure("Hi!")`.

crates/bevy_ecs/src/component/info.rs

@@ -348,7 +348,6 @@ impl ComponentDescriptor {
 pub struct Components {
     pub(super) components: Vec<Option<ComponentInfo>>,
     pub(super) indices: TypeIdMap<ComponentId>,
-    pub(super) resource_indices: TypeIdMap<ComponentId>,
     // This is kept internal and local to verify that no deadlocks can occor.
     pub(super) queued: bevy_platform::sync::RwLock<QueuedComponents>,
 }
@@ -588,7 +587,7 @@ impl Components {
     /// Type-erased equivalent of [`Components::valid_resource_id()`].
     #[inline]
     pub fn get_valid_resource_id(&self, type_id: TypeId) -> Option<ComponentId> {
-        self.resource_indices.get(&type_id).copied()
+        self.indices.get(&type_id).copied()
     }
 
     /// Returns the [`ComponentId`] of the given [`Resource`] type `T` if it is fully registered.
@@ -666,7 +665,7 @@ impl Components {
     /// Type-erased equivalent of [`Components::resource_id()`].
     #[inline]
     pub fn get_resource_id(&self, type_id: TypeId) -> Option<ComponentId> {
-        self.resource_indices.get(&type_id).copied().or_else(|| {
+        self.indices.get(&type_id).copied().or_else(|| {
             self.queued
                 .read()
                 .unwrap_or_else(PoisonError::into_inner)
@@ -724,7 +723,7 @@ impl Components {
         unsafe {
             self.register_component_inner(component_id, descriptor);
         }
-        let prev = self.resource_indices.insert(type_id, component_id);
+        let prev = self.indices.insert(type_id, component_id);
         debug_assert!(prev.is_none());
     }
 

crates/bevy_ecs/src/component/register.rs

@@ -321,7 +321,7 @@ impl<'w> ComponentsRegistrator<'w> {
         type_id: TypeId,
         descriptor: impl FnOnce() -> ComponentDescriptor,
     ) -> ComponentId {
-        if let Some(id) = self.resource_indices.get(&type_id) {
+        if let Some(id) = self.indices.get(&type_id) {
             return *id;
         }
 

crates/bevy_ecs/src/entity_disabling.rs

@@ -106,7 +106,8 @@ use smallvec::SmallVec;
 
 #[cfg(feature = "bevy_reflect")]
 use {
-    crate::reflect::ReflectComponent, bevy_reflect::std_traits::ReflectDefault,
+    crate::reflect::{ReflectComponent, ReflectResource},
+    bevy_reflect::std_traits::ReflectDefault,
     bevy_reflect::Reflect,
 };
 
@@ -187,7 +188,11 @@ pub struct Internal;
 /// Think carefully about whether you need to use a new disabling component,
 /// and clearly communicate their presence in any libraries you publish.
 #[derive(Resource, Debug)]
-#[cfg_attr(feature = "bevy_reflect", derive(bevy_reflect::Reflect))]
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(bevy_reflect::Reflect),
+    reflect(Resource)
+)]
 pub struct DefaultQueryFilters {
     // We only expect a few components per application to act as disabling components, so we use a SmallVec here
     // to avoid heap allocation in most cases.

crates/bevy_ecs/src/lib.rs

@@ -178,7 +178,7 @@ mod tests {
     };
     use std::sync::Mutex;
 
-    #[derive(Component, Resource, Debug, PartialEq, Eq, Hash, Clone, Copy)]
+    #[derive(Resource, Debug, PartialEq, Eq, Hash, Clone, Copy)]
     struct A(usize);
     #[derive(Component, Debug, PartialEq, Eq, Hash, Clone, Copy)]
     struct B(usize);
@@ -1553,8 +1553,8 @@ mod tests {
         let mut world_a = World::new();
         let world_b = World::new();
         let mut query = world_a.query::<&A>();
-        let _ = query.get(&world_a, Entity::from_raw_u32(0).unwrap());
-        let _ = query.get(&world_b, Entity::from_raw_u32(0).unwrap());
+        let _ = query.get(&world_a, Entity::from_raw_u32(10_000).unwrap());
+        let _ = query.get(&world_b, Entity::from_raw_u32(10_000).unwrap());
     }
 
     #[test]
@@ -1794,7 +1794,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(10_000).unwrap();
 
         let values = vec![(e0, (A(1), B(0))), (e1, (A(0), B(1)))];
 
@@ -1818,7 +1818,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(10_000).unwrap();
 
         let values = vec![(e0, (A(1), B(0))), (e1, (A(0), B(1)))];
 

crates/bevy_ecs/src/message/messages.rs

@@ -10,7 +10,7 @@ use core::{
 };
 #[cfg(feature = "bevy_reflect")]
 use {
-    crate::reflect::ReflectResource,
+    crate::reflect::{ReflectComponent, ReflectResource},
     bevy_reflect::{std_traits::ReflectDefault, Reflect},
 };
 

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/resource.rs

@@ -1,5 +1,11 @@
 //! Resources are unique, singleton-like data types that can be accessed from systems and stored in the [`World`](crate::world::World).
 
+use crate::component::Mutable;
+use crate::entity_disabling::Internal;
+use crate::prelude::Component;
+use crate::prelude::ReflectComponent;
+use bevy_reflect::prelude::ReflectDefault;
+use bevy_reflect::Reflect;
 // The derive macro for the `Resource` trait
 pub use bevy_ecs_macros::Resource;
 
@@ -72,4 +78,62 @@ pub use bevy_ecs_macros::Resource;
     label = "invalid `Resource`",
     note = "consider annotating `{Self}` with `#[derive(Resource)]`"
 )]
-pub trait Resource: Send + Sync + 'static {}
+pub trait Resource: Component<Mutability = Mutable> {}
+
+/// A marker component for entities which store resources.
+#[cfg_attr(
+    feature = "bevy_reflect",
+    derive(Reflect),
+    reflect(Component, Default, Debug)
+)]
+#[derive(Component, Debug, Default)]
+#[require(Internal)]
+pub struct IsResource;
+
+#[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/schedule/mod.rs

@@ -795,7 +795,7 @@ mod tests {
         #[derive(Message)]
         struct E;
 
-        #[derive(Resource, Component)]
+        #[derive(Resource)]
         struct RC;
 
         fn empty_system() {}

crates/bevy_ecs/src/storage/mod.rs

@@ -41,8 +41,6 @@ pub struct Storages {
     pub sparse_sets: SparseSets,
     /// Backing storage for [`Table`] components.
     pub tables: Tables,
-    /// Backing storage for resources.
-    pub resources: Resources<true>,
     /// Backing storage for `!Send` resources.
     pub non_send_resources: Resources<false>,
 }

crates/bevy_ecs/src/storage/resource.rs

@@ -148,6 +148,10 @@ impl<const SEND: bool> ResourceData<SEND> {
     /// # Panics
     /// If `SEND` is false, this will panic if a value is present and is not accessed from the
     /// original thread it was inserted in.
+    #[expect(
+        dead_code,
+        reason = "To be removed later as part of resource-as-component efforts"
+    )]
     pub(crate) fn get_mut(&mut self, last_run: Tick, this_run: Tick) -> Option<MutUntyped<'_>> {
         let (ptr, ticks, caller) = self.get_with_ticks()?;
         Some(MutUntyped {
@@ -210,6 +214,10 @@ impl<const SEND: bool> ResourceData<SEND> {
     /// # Safety
     /// - `value` must be valid for the underlying type for the resource.
     #[inline]
+    #[expect(
+        dead_code,
+        reason = "To be removed later as part of resource-as-component efforts"
+    )]
     pub(crate) unsafe fn insert_with_ticks(
         &mut self,
         value: OwningPtr<'_>,

crates/bevy_ecs/src/system/builder.rs

@@ -622,7 +622,7 @@ mod tests {
         entity::Entities,
         error::Result,
         prelude::{Component, Query},
-        reflect::ReflectResource,
+        reflect::{ReflectComponent, ReflectResource},
         system::{Local, RunSystemOnce},
     };
     use alloc::vec;

crates/bevy_ecs/src/system/commands/mod.rs

@@ -2445,7 +2445,7 @@ mod tests {
         }
     }
 
-    #[derive(Component, Resource)]
+    #[derive(Resource)]
     struct W<T>(T);
 
     fn simple_command(world: &mut World) {

crates/bevy_ecs/src/system/mod.rs

@@ -432,17 +432,17 @@ mod tests {
         No,
     }
 
-    #[derive(Component, Resource, Debug, Eq, PartialEq, Default)]
+    #[derive(Resource, Debug, Eq, PartialEq, Default)]
     struct A;
-    #[derive(Component, Resource)]
+    #[derive(Resource)]
     struct B;
-    #[derive(Component, Resource)]
+    #[derive(Resource)]
     struct C;
-    #[derive(Component, Resource)]
+    #[derive(Resource)]
     struct D;
-    #[derive(Component, Resource)]
+    #[derive(Resource)]
     struct E;
-    #[derive(Component, Resource)]
+    #[derive(Resource)]
     struct F;
 
     #[derive(Component, Debug)]

crates/bevy_ecs/src/system/system.rs

@@ -459,10 +459,9 @@ mod tests {
 
     #[test]
     fn run_system_once() {
+        #[derive(Resource)]
         struct T(usize);
 
-        impl Resource for T {}
-
         fn system(In(n): In<usize>, mut commands: Commands) -> usize {
             commands.insert_resource(T(n));
             n + 1
@@ -522,8 +521,8 @@ mod tests {
 
     #[test]
     fn run_system_once_invalid_params() {
+        #[derive(Resource)]
         struct T;
-        impl Resource for T {}
         fn system(_: Res<T>) {}
 
         let mut world = World::default();