[Merged by Bors] - Extract Resources into their own dedicated storage

crates/bevy_ecs/src/archetype.rs

@@ -5,7 +5,7 @@ use crate::{
     bundle::BundleId,
     component::{ComponentId, StorageType},
     entity::{Entity, EntityLocation},
-    storage::{Column, SparseArray, SparseSet, SparseSetIndex, TableId},
+    storage::{SparseArray, SparseSet, SparseSetIndex, TableId},
 };
 use std::{
     collections::HashMap,
@@ -18,7 +18,6 @@ pub struct ArchetypeId(usize);
 
 impl ArchetypeId {
     pub const EMPTY: ArchetypeId = ArchetypeId(0);
-    pub const RESOURCE: ArchetypeId = ArchetypeId(1);
     pub const INVALID: ArchetypeId = ArchetypeId(usize::MAX);
 
     #[inline]
@@ -140,8 +139,7 @@ pub struct Archetype {
     table_info: TableInfo,
     table_components: Box<[ComponentId]>,
     sparse_set_components: Box<[ComponentId]>,
-    pub(crate) unique_components: SparseSet<ComponentId, Column>,
-    pub(crate) components: SparseSet<ComponentId, ArchetypeComponentInfo>,
+    components: SparseSet<ComponentId, ArchetypeComponentInfo>,
 }
 
 impl Archetype {
@@ -188,7 +186,6 @@ impl Archetype {
             components,
             table_components,
             sparse_set_components,
-            unique_components: SparseSet::new(),
             entities: Default::default(),
             edges: Default::default(),
         }
@@ -224,16 +221,6 @@ impl Archetype {
         &self.sparse_set_components
     }
 
-    #[inline]
-    pub fn unique_components(&self) -> &SparseSet<ComponentId, Column> {
-        &self.unique_components
-    }
-
-    #[inline]
-    pub fn unique_components_mut(&mut self) -> &mut SparseSet<ComponentId, Column> {
-        &mut self.unique_components
-    }
-
     #[inline]
     pub fn components(&self) -> impl Iterator<Item = ComponentId> + '_ {
         self.components.indices()
@@ -392,17 +379,6 @@ impl Default for Archetypes {
             archetype_component_count: 0,
         };
         archetypes.get_id_or_insert(TableId::empty(), Vec::new(), Vec::new());
-
-        // adds the resource archetype. it is "special" in that it is inaccessible via a "hash",
-        // which prevents entities from being added to it
-        archetypes.archetypes.push(Archetype::new(
-            ArchetypeId::RESOURCE,
-            TableId::empty(),
-            Box::new([]),
-            Box::new([]),
-            Vec::new(),
-            Vec::new(),
-        ));
         archetypes
     }
 }
@@ -433,21 +409,6 @@ impl Archetypes {
         }
     }
 
-    #[inline]
-    pub fn resource(&self) -> &Archetype {
-        // SAFETY: resource archetype always exists
-        unsafe { self.archetypes.get_unchecked(ArchetypeId::RESOURCE.index()) }
-    }
-
-    #[inline]
-    pub(crate) fn resource_mut(&mut self) -> &mut Archetype {
-        // SAFETY: resource archetype always exists
-        unsafe {
-            self.archetypes
-                .get_unchecked_mut(ArchetypeId::RESOURCE.index())
-        }
-    }
-
     #[inline]
     pub fn is_empty(&self) -> bool {
         self.archetypes.is_empty()

crates/bevy_ecs/src/lib.rs

@@ -957,10 +957,12 @@ mod tests {
             .get_resource_id(TypeId::of::<Num>())
             .unwrap();
         let archetype_component_id = world
-            .archetypes()
-            .resource()
-            .get_archetype_component_id(resource_id)
-            .unwrap();
+            .storages()
+            .resources
+            .get(resource_id)
+            .unwrap()
+            .component_info()
+            .archetype_component_id;
 
         assert_eq!(world.resource::<Num>().0, 123);
         assert!(world.contains_resource::<Num>());
@@ -1024,10 +1026,12 @@ mod tests {
         );
 
         let current_archetype_component_id = world
-            .archetypes()
-            .resource()
-            .get_archetype_component_id(current_resource_id)
-            .unwrap();
+            .storages()
+            .resources
+            .get(resource_id)
+            .unwrap()
+            .component_info()
+            .archetype_component_id;
 
         assert_eq!(
             archetype_component_id, current_archetype_component_id,

crates/bevy_ecs/src/storage/mod.rs

@@ -1,9 +1,11 @@
 //! Storage layouts for ECS data.
 
 mod blob_vec;
+mod resource;
 mod sparse_set;
 mod table;
 
+pub use resource::*;
 pub use sparse_set::*;
 pub use table::*;
 
@@ -12,4 +14,5 @@ pub use table::*;
 pub struct Storages {
     pub sparse_sets: SparseSets,
     pub tables: Tables,
+    pub resources: Resources,
 }

crates/bevy_ecs/src/storage/resource.rs

@@ -0,0 +1,174 @@
+use crate::archetype::ArchetypeComponentId;
+use crate::archetype::ArchetypeComponentInfo;
+use crate::component::{ComponentId, ComponentTicks, Components, StorageType};
+use crate::storage::{Column, SparseSet};
+use bevy_ptr::{OwningPtr, Ptr, PtrMut, UnsafeCellDeref};
+use std::cell::UnsafeCell;
+
+/// The type-erased backing storage and metadata for a single resource within a [`World`].
+///
+/// [`World`]: crate::world::World
+pub struct ResourceData {
+    column: Column,
+    component_info: ArchetypeComponentInfo,
+}
+
+impl ResourceData {
+    /// Returns true if the resource is populated.
+    #[inline]
+    pub fn is_present(&self) -> bool {
+        !self.column.is_empty()
+    }
+
+    #[inline]
+    pub(crate) fn component_info(&self) -> &ArchetypeComponentInfo {
+        &self.component_info
+    }
+
+    /// Gets a read-only pointer to the underlying resource, if available.
+    #[inline]
+    pub fn get_data(&self) -> Option<Ptr<'_>> {
+        self.column.get_data(0)
+    }
+
+    /// Gets a mutable pointer to the underlying resource, if available.
+    #[inline]
+    pub fn get_data_mut(&mut self) -> Option<PtrMut<'_>> {
+        self.column.get_data_mut(0)
+    }
+
+    /// Gets a read-only reference to the change ticks of the underlying resource, if available.
+    #[inline]
+    pub fn get_ticks(&self) -> Option<&ComponentTicks> {
+        self.column
+            .get_ticks(0)
+            // SAFETY: If the first row exists, a valid ticks value has been written.
+            .map(|ticks| unsafe { ticks.deref() })
+    }
+
+    /// Gets a mutable reference to the change ticks of the underlying resource, if available.
+    #[inline]
+    pub fn get_ticks_mut(&mut self) -> Option<&mut ComponentTicks> {
+        self.column
+            .get_ticks(0)
+            // SAFETY: If the first row exists, a valid ticks value has been written.
+            // This function has exclusvie access to the underlying column.
+            .map(|ticks| unsafe { ticks.deref_mut() })
+    }
+
+    #[inline]
+    pub(crate) fn get_with_ticks(&self) -> Option<(Ptr<'_>, &UnsafeCell<ComponentTicks>)> {
+        self.column.get(0)
+    }
+
+    /// Inserts a value into the resource. If a value is already present
+    /// it will be replaced.
+    ///
+    /// # Safety
+    /// `value` must be valid for the underlying type for the resource.
+    #[inline]
+    pub unsafe fn insert(&mut self, value: OwningPtr<'_>, change_tick: u32) {
+        if self.is_present() {
+            self.column.replace(0, value, change_tick);
+        } else {
+            self.column.push(value, ComponentTicks::new(change_tick));
+        }
+    }
+
+    #[inline]
+    pub(crate) unsafe fn insert_with_ticks(
+        &mut self,
+        value: OwningPtr<'_>,
+        change_ticks: ComponentTicks,
+    ) {
+        if self.is_present() {
+            self.column.replace_untracked(0, value);
+            *self.column.get_ticks_unchecked(0).deref_mut() = change_ticks;
+        } else {
+            self.column.push(value, change_ticks);
+        }
+    }
+
+    /// Removes a value from the resource, if present.
+    #[inline]
+    #[must_use = "The returned pointer to the removed component should be used or dropped"]
+    pub fn remove(&mut self) -> Option<(OwningPtr<'_>, ComponentTicks)> {
+        self.column.swap_remove_and_forget(0)
+    }
+
+    #[inline]
+    pub(crate) fn remove_and_drop(&mut self) {
+        self.column.clear();
+    }
+}
+
+/// The backing store for all [`Resource`]s stored in the [`World`].
+///
+/// [`Resource`]: crate::system::Resource
+/// [`World`]: crate::world::World
+#[derive(Default)]
+pub struct Resources {
+    resources: SparseSet<ComponentId, ResourceData>,
+}
+
+impl Resources {
+    /// The total number of resoruces stored in the [`World`]
+    ///
+    /// [`World`]: crate::world::World
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.resources.len()
+    }
+
+    /// Returns true if there are no resources stored in the [`World`],
+    /// false otherwise.
+    ///
+    /// [`World`]: crate::world::World
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.resources.is_empty()
+    }
+
+    /// Gets a read-only [`Ptr`] to a resource, if available.
+    #[inline]
+    pub fn get(&self, component_id: ComponentId) -> Option<&ResourceData> {
+        self.resources.get(component_id)
+    }
+
+    /// Gets a read-only [`Ptr`] to a resource, if available.
+    #[inline]
+    pub fn get_mut(&mut self, component_id: ComponentId) -> Option<&mut ResourceData> {
+        self.resources.get_mut(component_id)
+    }
+
+    /// Fetches or initializes a new resource and returns back it's underlying column.
+    ///
+    /// # Panics
+    /// Will panic if `component_id` is not valid for the provided `components`
+    pub fn initialize_with<F>(
+        &mut self,
+        component_id: ComponentId,
+        components: &Components,
+        f: F,
+    ) -> &mut ResourceData
+    where
+        F: FnOnce() -> ArchetypeComponentId,
+    {
+        self.resources.get_or_insert_with(component_id, || {
+            let component_info = components.get_info(component_id).unwrap();
+            ResourceData {
+                column: Column::with_capacity(component_info, 1),
+                component_info: ArchetypeComponentInfo {
+                    archetype_component_id: f(),
+                    storage_type: StorageType::Table,
+                },
+            }
+        })
+    }
+
+    pub fn check_change_ticks(&mut self, change_tick: u32) {
+        for info in self.resources.values_mut() {
+            info.column.check_change_ticks(change_tick);
+        }
+    }
+}