Store Resources as components on singleton entities

crates/bevy_ecs/macros/src/component.rs

@@ -32,18 +32,92 @@ pub fn derive_resource(input: TokenStream) -> TokenStream {
         return err.into_compile_error().into();
     }
 
+    // implement the Component trait
+    let map_entities = map_entities(
+        &ast.data,
+        &bevy_ecs_path,
+        Ident::new("this", Span::call_site()),
+        false,
+        false,
+        None
+    ).map(|map_entities_impl| quote! {
+        fn map_entities<M: #bevy_ecs_path::entity::EntityMapper>(this: &mut Self, mapper: &mut M) {
+            use #bevy_ecs_path::entity::MapEntities;
+            #map_entities_impl
+        }
+    });
+
+    let storage = storage_path(&bevy_ecs_path, StorageTy::Table);
+
+    let on_add_path = Some(quote!(<Self as #bevy_ecs_path::resource::Resource>::on_add_hook));
+    let on_remove_path = None;
+    let on_insert_path = None;
+    let on_replace_path = None;
+    let on_despawn_path =
+        Some(quote!(<Self as #bevy_ecs_path::resource::Resource>::on_despawn_hook));
+
+    let on_add = hook_register_function_call(&bevy_ecs_path, quote! {on_add}, on_add_path);
+    let on_remove = hook_register_function_call(&bevy_ecs_path, quote! {on_remove}, on_remove_path);
+    let on_insert = hook_register_function_call(&bevy_ecs_path, quote! {on_insert}, on_insert_path);
+    let on_replace =
+        hook_register_function_call(&bevy_ecs_path, quote! {on_replace}, on_replace_path);
+    let on_despawn =
+        hook_register_function_call(&bevy_ecs_path, quote! {on_despawn}, on_despawn_path);
+
     ast.generics
         .make_where_clause()
         .predicates
         .push(parse_quote! { Self: Send + Sync + 'static });
 
+    let mut register_required = Vec::with_capacity(1);
+    register_required.push(quote! {
+        required_components.register_required::<#bevy_ecs_path::resource::IsResource>(<#bevy_ecs_path::resource::IsResource as Default>::default);
+    });
+
     let struct_name = &ast.ident;
     let (impl_generics, type_generics, where_clause) = &ast.generics.split_for_impl();
 
-    TokenStream::from(quote! {
+    // This puts `register_required` before `register_recursive_requires` to ensure that the constructors of _all_ top
+    // level components are initialized first, giving them precedence over recursively defined constructors for the same component type
+    let component_derive_token_stream = TokenStream::from(quote! {
+        impl #impl_generics #bevy_ecs_path::component::Component for #struct_name #type_generics #where_clause {
+            const STORAGE_TYPE: #bevy_ecs_path::component::StorageType = #storage;
+            type Mutability = #bevy_ecs_path::component::Mutable;
+            fn register_required_components(
+                _requiree: #bevy_ecs_path::component::ComponentId,
+                required_components: &mut #bevy_ecs_path::component::RequiredComponentsRegistrator,
+            ) {
+                #(#register_required)*
+            }
+
+            #on_add
+            #on_insert
+            #on_replace
+            #on_remove
+            #on_despawn
+
+            fn clone_behavior() -> #bevy_ecs_path::component::ComponentCloneBehavior {
+                #bevy_ecs_path::component::ComponentCloneBehavior::Default
+            }
+
+            #map_entities
+
+            fn relationship_accessor() -> Option<#bevy_ecs_path::relationship::ComponentRelationshipAccessor<Self>> {
+                None
+            }
+        }
+    });
+
+    // implement the Resource trait
+    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

@@ -677,7 +677,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

@@ -302,19 +302,7 @@ impl ComponentDescriptor {
     ///
     /// The [`StorageType`] for resources is always [`StorageType::Table`].
     pub fn new_resource<T: Resource>() -> Self {
-        Self {
-            name: DebugName::type_name::<T>(),
-            // PERF: `SparseStorage` may actually be a more
-            // reasonable choice as `storage_type` for resources.
-            storage_type: StorageType::Table,
-            is_send_and_sync: true,
-            type_id: Some(TypeId::of::<T>()),
-            layout: Layout::new::<T>(),
-            drop: needs_drop::<T>().then_some(Self::drop_ptr::<T> as _),
-            mutable: true,
-            clone_behavior: ComponentCloneBehavior::Default,
-            relationship_accessor: None,
-        }
+        Self::new::<T>()
     }
 
     pub(super) fn new_non_send<T: Any>(storage_type: StorageType) -> Self {
@@ -362,7 +350,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>,
 }
@@ -407,7 +394,7 @@ impl Components {
     #[inline]
     pub fn num_queued(&self) -> usize {
         let queued = self.queued.read().unwrap_or_else(PoisonError::into_inner);
-        queued.components.len() + queued.dynamic_registrations.len() + queued.resources.len()
+        queued.components.len() + queued.dynamic_registrations.len()
     }
 
     /// Returns `true` if there are any components registered with this instance. Otherwise, this returns `false`.
@@ -423,7 +410,7 @@ impl Components {
             .queued
             .get_mut()
             .unwrap_or_else(PoisonError::into_inner);
-        queued.components.len() + queued.dynamic_registrations.len() + queued.resources.len()
+        queued.components.len() + queued.dynamic_registrations.len()
     }
 
     /// A faster version of [`Self::any_queued`].
@@ -470,7 +457,6 @@ impl Components {
                 queued
                     .components
                     .values()
-                    .chain(queued.resources.values())
                     .chain(queued.dynamic_registrations.iter())
                     .find(|queued| queued.id == id)
                     .map(|queued| Cow::Owned(queued.descriptor.clone()))
@@ -492,7 +478,6 @@ impl Components {
                 queued
                     .components
                     .values()
-                    .chain(queued.resources.values())
                     .chain(queued.dynamic_registrations.iter())
                     .find(|queued| queued.id == id)
                     .map(|queued| queued.descriptor.name.clone())
@@ -602,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.
@@ -680,11 +665,11 @@ 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)
-                .resources
+                .components
                 .get(&type_id)
                 .map(|queued| queued.id)
         })
@@ -728,7 +713,7 @@ impl Components {
     /// The [`ComponentId`] must be unique.
     /// The [`TypeId`] and [`ComponentId`] must not be registered or queued.
     #[inline]
-    pub(super) unsafe fn register_resource_unchecked(
+    pub(super) unsafe fn register_non_send_unchecked(
         &mut self,
         type_id: TypeId,
         component_id: ComponentId,
@@ -738,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

@@ -138,21 +138,6 @@ impl<'w> ComponentsRegistrator<'w> {
             registrator.register(self);
         }
 
-        // resources
-        while let Some(registrator) = {
-            let queued = self
-                .components
-                .queued
-                .get_mut()
-                .unwrap_or_else(PoisonError::into_inner);
-            queued.resources.keys().next().copied().map(|type_id| {
-                // SAFETY: the id just came from a valid iterator.
-                unsafe { queued.resources.remove(&type_id).debug_checked_unwrap() }
-            })
-        } {
-            registrator.register(self);
-        }
-
         // dynamic
         let queued = &mut self
             .components
@@ -286,15 +271,9 @@ impl<'w> ComponentsRegistrator<'w> {
     /// # See also
     ///
     /// * [`Components::resource_id()`]
-    /// * [`ComponentsRegistrator::register_resource_with_descriptor()`]
     #[inline]
     pub fn register_resource<T: Resource>(&mut self) -> ComponentId {
-        // SAFETY: The [`ComponentDescriptor`] matches the [`TypeId`]
-        unsafe {
-            self.register_resource_with(TypeId::of::<T>(), || {
-                ComponentDescriptor::new_resource::<T>()
-            })
-        }
+        self.register_component::<T>()
     }
 
     /// Registers a [non-send resource](crate::system::NonSend) of type `T` with this instance.
@@ -304,24 +283,24 @@ impl<'w> ComponentsRegistrator<'w> {
     pub fn register_non_send<T: Any>(&mut self) -> ComponentId {
         // SAFETY: The [`ComponentDescriptor`] matches the [`TypeId`]
         unsafe {
-            self.register_resource_with(TypeId::of::<T>(), || {
+            self.register_non_send_with(TypeId::of::<T>(), || {
                 ComponentDescriptor::new_non_send::<T>(StorageType::default())
             })
         }
     }
 
-    /// Same as [`Components::register_resource_unchecked`] but handles safety.
+    /// Same as [`Components::register_non_send_unchecked`] but handles safety.
     ///
     /// # Safety
     ///
     /// The [`ComponentDescriptor`] must match the [`TypeId`].
     #[inline]
-    unsafe fn register_resource_with(
+    unsafe fn register_non_send_with(
         &mut self,
         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;
         }
 
@@ -330,7 +309,7 @@ impl<'w> ComponentsRegistrator<'w> {
             .queued
             .get_mut()
             .unwrap_or_else(PoisonError::into_inner)
-            .resources
+            .components
             .remove(&type_id)
         {
             // If we are trying to register something that has already been queued, we respect the queue.
@@ -342,12 +321,12 @@ impl<'w> ComponentsRegistrator<'w> {
         // SAFETY: The resource is not currently registered, the id is fresh, and the [`ComponentDescriptor`] matches the [`TypeId`]
         unsafe {
             self.components
-                .register_resource_unchecked(type_id, id, descriptor());
+                .register_non_send_unchecked(type_id, id, descriptor());
         }
         id
     }
 
-    /// Registers a [`Resource`] described by `descriptor`.
+    /// Registers a non-send resource described by `descriptor`.
     ///
     /// # Note
     ///
@@ -357,9 +336,9 @@ impl<'w> ComponentsRegistrator<'w> {
     /// # See also
     ///
     /// * [`Components::resource_id()`]
-    /// * [`ComponentsRegistrator::register_resource()`]
+    /// * [`ComponentsRegistrator::register_non_send()`]
     #[inline]
-    pub fn register_resource_with_descriptor(
+    pub fn register_non_send_with_descriptor(
         &mut self,
         descriptor: ComponentDescriptor,
     ) -> ComponentId {
@@ -419,7 +398,6 @@ impl QueuedRegistration {
 #[derive(Default)]
 pub struct QueuedComponents {
     pub(super) components: TypeIdMap<QueuedRegistration>,
-    pub(super) resources: TypeIdMap<QueuedRegistration>,
     pub(super) dynamic_registrations: Vec<QueuedRegistration>,
 }
 
@@ -430,17 +408,15 @@ impl Debug for QueuedComponents {
             .iter()
             .map(|(type_id, queued)| (type_id, queued.id))
             .collect::<Vec<_>>();
-        let resources = self
-            .resources
-            .iter()
-            .map(|(type_id, queued)| (type_id, queued.id))
-            .collect::<Vec<_>>();
         let dynamic_registrations = self
             .dynamic_registrations
             .iter()
             .map(|queued| queued.id)
             .collect::<Vec<_>>();
-        write!(f, "components: {components:?}, resources: {resources:?}, dynamic_registrations: {dynamic_registrations:?}")
+        write!(
+            f,
+            "components: {components:?}, dynamic_registrations: {dynamic_registrations:?}"
+        )
     }
 }
 
@@ -526,7 +502,7 @@ impl<'w> ComponentsQueuedRegistrator<'w> {
             .queued
             .write()
             .unwrap_or_else(PoisonError::into_inner)
-            .resources
+            .components
             .entry(type_id)
             .or_insert_with(|| {
                 // SAFETY: The id was just generated.
@@ -633,7 +609,7 @@ impl<'w> ComponentsQueuedRegistrator<'w> {
                         unsafe {
                             registrator
                                 .components
-                                .register_resource_unchecked(type_id, id, descriptor);
+                                .register_non_send_unchecked(type_id, id, descriptor);
                         }
                     },
                 )
@@ -667,15 +643,15 @@ impl<'w> ComponentsQueuedRegistrator<'w> {
                         unsafe {
                             registrator
                                 .components
-                                .register_resource_unchecked(type_id, id, descriptor);
+                                .register_non_send_unchecked(type_id, id, descriptor);
                         }
                     },
                 )
             }
         })
     }
 
-    /// This is a queued version of [`ComponentsRegistrator::register_resource_with_descriptor`].
+    /// This is a queued version of [`ComponentsRegistrator::register_non_send_with_descriptor`].
     /// This will reserve an id and queue the registration.
     /// These registrations will be carried out at the next opportunity.
     ///
@@ -684,7 +660,7 @@ impl<'w> ComponentsQueuedRegistrator<'w> {
     /// Technically speaking, the returned [`ComponentId`] is not valid, but it will become valid later.
     /// See type level docs for details.
     #[inline]
-    pub fn queue_register_resource_with_descriptor(
+    pub fn queue_register_non_send_with_descriptor(
         &self,
         descriptor: ComponentDescriptor,
     ) -> ComponentId {