resource storage

Author: SpecificProtagonist

benches/benches/bevy_ecs/resources.rs

@@ -19,7 +19,7 @@ fn create_world() -> World {
             let resource_id =
                 world.register_component_with_descriptor(ComponentDescriptor::new_with_layout(
                     "",
-                    StorageType::SparseSet,
+                    StorageType::Resource,
                     Layout::new::<()>(),
                     None,
                     true,

crates/bevy_ecs/macros/src/component.rs

@@ -47,7 +47,7 @@ pub fn derive_resource(input: TokenStream) -> TokenStream {
         }
     });
 
-    let storage = storage_path(&bevy_ecs_path, StorageTy::Table);
+    let storage = storage_path(&bevy_ecs_path, StorageTy::Resource);
 
     ast.generics
         .make_where_clause()
@@ -554,6 +554,7 @@ struct Attrs {
 enum StorageTy {
     Table,
     SparseSet,
+    Resource,
 }
 
 struct Require {
@@ -747,6 +748,7 @@ fn storage_path(bevy_ecs_path: &Path, ty: StorageTy) -> TokenStream2 {
     let storage_type = match ty {
         StorageTy::Table => Ident::new("Table", Span::call_site()),
         StorageTy::SparseSet => Ident::new("SparseSet", Span::call_site()),
+        StorageTy::Resource => Ident::new("Resource", Span::call_site()),
     };
 
     quote! { #bevy_ecs_path::component::StorageType::#storage_type }

crates/bevy_ecs/src/archetype.rs

@@ -390,7 +390,7 @@ pub struct Archetype {
 }
 
 impl Archetype {
-    /// `table_components` and `sparse_set_components` must be sorted
+    /// `table_components` must be sorted
     pub(crate) fn new(
         components: &Components,
         component_index: &mut ComponentIndex,
@@ -399,6 +399,7 @@ impl Archetype {
         table_id: TableId,
         table_components: impl Iterator<Item = ComponentId>,
         sparse_set_components: impl Iterator<Item = ComponentId>,
+        resource_components: impl Iterator<Item = ComponentId>,
     ) -> Self {
         let (min_table, _) = table_components.size_hint();
         let (min_sparse, _) = sparse_set_components.size_hint();
@@ -424,22 +425,23 @@ impl Archetype {
                 .insert(id, ArchetypeRecord { column: Some(idx) });
         }
 
-        for component_id in sparse_set_components {
+        for component_id in sparse_set_components.chain(resource_components) {
             // SAFETY: We are creating an archetype that includes this component so it must exist
             let info = unsafe { components.get_info_unchecked(component_id) };
             info.update_archetype_flags(&mut flags);
             observers.update_archetype_flags(component_id, &mut flags);
             archetype_components.insert(
                 component_id,
                 ArchetypeComponentInfo {
-                    storage_type: StorageType::SparseSet,
+                    storage_type: info.storage_type(),
                 },
             );
             component_index
                 .entry(component_id)
                 .or_default()
                 .insert(id, ArchetypeRecord { column: None });
         }
+
         Self {
             id,
             table_id,
@@ -523,6 +525,19 @@ impl Archetype {
             .map(|(id, _)| *id)
     }
 
+    /// Gets an iterator of all of the components stored in [`ResourceStorages`].
+    ///
+    /// All of the IDs are unique.
+    ///
+    /// [`ResourceStorages`]: crate::storage::ResourceStorages
+    #[inline]
+    pub fn resource_components(&self) -> impl Iterator<Item = ComponentId> + '_ {
+        self.components
+            .iter()
+            .filter(|(_, component)| component.storage_type == StorageType::Resource)
+            .map(|(id, _)| *id)
+    }
+
     /// Returns a slice of all of the components in the archetype.
     ///
     /// All of the IDs are unique.
@@ -754,10 +769,13 @@ impl ArchetypeGeneration {
     }
 }
 
+/// Components must be sorted
+/// (which allows `ArchetypeComponents` to be used as an archetype's identity).
 #[derive(Hash, PartialEq, Eq)]
 struct ArchetypeComponents {
     table_components: Box<[ComponentId]>,
     sparse_set_components: Box<[ComponentId]>,
+    resource_components: Box<[ComponentId]>,
 }
 
 /// Maps a [`ComponentId`] to the list of [`Archetypes`]([`Archetype`]) that contain the [`Component`](crate::component::Component),
@@ -804,6 +822,7 @@ impl Archetypes {
                 TableId::empty(),
                 Vec::new(),
                 Vec::new(),
+                Vec::new(),
             );
         }
         archetypes
@@ -896,22 +915,24 @@ impl Archetypes {
     /// Specifically, it returns a tuple where the first element
     /// is the [`ArchetypeId`] that the given inputs belong to, and the second element is a boolean indicating whether a new archetype was created.
     ///
-    /// `table_components` and `sparse_set_components` must be sorted
+    /// `table_components`, `sparse_set_components` and `resource_components` must be sorted
     ///
     /// # Safety
     /// [`TableId`] must exist in tables
-    /// `table_components` and `sparse_set_components` must exist in `components`
+    /// `table_components`, `sparse_set_components` and `resource_components` must exist in `components`
     pub(crate) unsafe fn get_id_or_insert(
         &mut self,
         components: &Components,
         observers: &Observers,
         table_id: TableId,
         table_components: Vec<ComponentId>,
         sparse_set_components: Vec<ComponentId>,
+        resource_components: Vec<ComponentId>,
     ) -> (ArchetypeId, bool) {
         let archetype_identity = ArchetypeComponents {
             sparse_set_components: sparse_set_components.into_boxed_slice(),
             table_components: table_components.into_boxed_slice(),
+            resource_components: resource_components.into_boxed_slice(),
         };
 
         let archetypes = &mut self.archetypes;
@@ -922,6 +943,7 @@ impl Archetypes {
                 let ArchetypeComponents {
                     table_components,
                     sparse_set_components,
+                    resource_components,
                 } = vacant.key();
                 let id = ArchetypeId::new(archetypes.len());
                 archetypes.push(Archetype::new(
@@ -932,6 +954,7 @@ impl Archetypes {
                     table_id,
                     table_components.iter().copied(),
                     sparse_set_components.iter().copied(),
+                    resource_components.iter().copied(),
                 ));
                 vacant.insert(id);
                 (id, true)

crates/bevy_ecs/src/bundle/info.rs

@@ -17,7 +17,7 @@ use crate::{
     },
     entity::Entity,
     query::DebugCheckedUnwrap as _,
-    storage::{SparseSetIndex, SparseSets, Storages, Table, TableRow},
+    storage::{ResourceStorages, SparseSetIndex, SparseSets, Storages, Table, TableRow},
 };
 
 /// For a specific [`World`], this stores a unique value identifying a type of a registered [`Bundle`].
@@ -240,6 +240,7 @@ impl BundleInfo {
         &self,
         table: &mut Table,
         sparse_sets: &mut SparseSets,
+        resource_storages: &mut ResourceStorages,
         bundle_component_status: &S,
         required_components: impl Iterator<Item = &'a RequiredComponentConstructor>,
         entity: Entity,
@@ -294,6 +295,22 @@ impl BundleInfo {
                         }
                     }
                 }
+                StorageType::Resource => {
+                    let resource_storage =
+                        // SAFETY: If component_id is in self.component_ids, BundleInfo::new ensures that
+                        // a resource storage exists for the component.
+                        unsafe { resource_storages.get_mut(component_id).debug_checked_unwrap() };
+                    match (status, insert_mode) {
+                        (ComponentStatus::Added, _) | (_, InsertMode::Replace) => {
+                            resource_storage.insert(entity, component_ptr, change_tick, caller);
+                        }
+                        (ComponentStatus::Existing, InsertMode::Keep) => {
+                            if let Some(drop_fn) = resource_storage.get_drop() {
+                                drop_fn(component_ptr);
+                            }
+                        }
+                    }
+                }
             }
             bundle_component += 1;
         });
@@ -302,6 +319,7 @@ impl BundleInfo {
             required_component.initialize(
                 table,
                 sparse_sets,
+                resource_storages,
                 change_tick,
                 table_row,
                 entity,
@@ -325,6 +343,7 @@ impl BundleInfo {
     pub(crate) unsafe fn initialize_required_component(
         table: &mut Table,
         sparse_sets: &mut SparseSets,
+        resource_storages: &mut ResourceStorages,
         change_tick: Tick,
         table_row: TableRow,
         entity: Entity,
@@ -349,6 +368,13 @@ impl BundleInfo {
                         unsafe { sparse_sets.get_mut(component_id).debug_checked_unwrap() };
                     sparse_set.insert(entity, component_ptr, change_tick, caller);
                 }
+                StorageType::Resource => {
+                    let resource_storage=
+                        // SAFETY: If component_id is in required_components, BundleInfo::new requires that
+                        // a sparse set exists for the component.
+                        unsafe { resource_storages.get_mut(component_id).debug_checked_unwrap() };
+                    resource_storage.insert(entity, component_ptr, change_tick, caller);
+                }
             }
         }
     }