move get_component[_with_type], get_ticks[_with_type], get_component_and_ticks[_with_type] to Storages

Author: jakobhellermann

crates/bevy_ecs/src/storage/mod.rs

@@ -9,10 +9,187 @@ pub use resource::*;
 pub use sparse_set::*;
 pub use table::*;
 
+use crate::{
+    archetype::Archetypes,
+    component::{ComponentId, ComponentTicks, Components, StorageType},
+    entity::{Entity, EntityLocation},
+};
+use bevy_ptr::Ptr;
+use std::{any::TypeId, cell::UnsafeCell};
+
 /// The raw data stores of a [World](crate::world::World)
 #[derive(Default)]
 pub struct Storages {
     pub sparse_sets: SparseSets,
     pub tables: Tables,
     pub resources: Resources,
 }
+
+impl Storages {
+    /// Get a raw pointer to a particular [`Component`] and its [`ComponentTicks`] identified by their [`TypeId`]
+    ///
+    /// # Safety
+    /// - `entity_location` must be within bounds of the given archetype and `entity` must exist inside
+    /// - `component_id` must be valid
+    /// - `Archetypes` and `Components` must come from the world this of this `Storages`
+    /// - the caller must ensure that no aliasing rules are violated
+    #[inline]
+    pub unsafe fn get_component_and_ticks_with_type(
+        &self,
+        archetypes: &Archetypes,
+        components: &Components,
+        type_id: TypeId,
+        entity: Entity,
+        location: EntityLocation,
+    ) -> Option<(Ptr<'_>, &UnsafeCell<ComponentTicks>)> {
+        let component_id = components.get_id(type_id)?;
+        self.get_component_and_ticks(archetypes, components, component_id, entity, location)
+    }
+
+    /// Get a raw pointer to a particular [`Component`] and its [`ComponentTicks`]
+    ///
+    /// # Safety
+    /// - `entity_location` must be within bounds of the given archetype and `entity` must exist inside
+    /// - `component_id` must be valid
+    /// - `Archetypes` and `Components` must come from the world this of this `Storages`
+    /// - the caller must ensure that no aliasing rules are violated
+    #[inline]
+    pub unsafe fn get_component_and_ticks(
+        &self,
+        archetypes: &Archetypes,
+        components: &Components,
+        component_id: ComponentId,
+        entity: Entity,
+        location: EntityLocation,
+    ) -> Option<(Ptr<'_>, &UnsafeCell<ComponentTicks>)> {
+        let archetype = &archetypes[location.archetype_id];
+        let component_info = unsafe { components.get_info_unchecked(component_id) };
+        match component_info.storage_type() {
+            StorageType::Table => {
+                let table = &self.tables[archetype.table_id()];
+                let components = table.get_column(component_id)?;
+                let table_row = archetype.entity_table_row(location.index);
+                // SAFETY: archetypes only store valid table_rows and the stored component type is T
+                Some(unsafe {
+                    (
+                        components.get_data_unchecked(table_row),
+                        components.get_ticks_unchecked(table_row),
+                    )
+                })
+            }
+            StorageType::SparseSet => self
+                .sparse_sets
+                .get(component_id)
+                .and_then(|sparse_set| sparse_set.get_with_ticks(entity)),
+        }
+    }
+
+    /// Get a raw pointer to a particular [`Component`] on a particular [`Entity`], identified by the component's [`Type`]
+    ///
+    /// # Safety
+    /// - `entity_location` must be within bounds of the given archetype and `entity` must exist inside
+    /// the archetype
+    /// - `Archetypes` and `Components` must come from the world this of this `Storages`
+    /// - the caller must ensure that no aliasing rules are violated
+    #[inline]
+    pub unsafe fn get_component_with_type(
+        &self,
+        archetypes: &Archetypes,
+        components: &Components,
+        type_id: TypeId,
+        entity: Entity,
+        location: EntityLocation,
+    ) -> Option<Ptr<'_>> {
+        let component_id = components.get_id(type_id)?;
+        self.get_component(archetypes, components, component_id, entity, location)
+    }
+
+    /// Get a raw pointer to a particular [`Component`] on a particular [`Entity`] in the provided [`World`].
+    ///
+    /// # Safety
+    /// - `entity_location` must be within bounds of the given archetype and `entity` must exist inside
+    /// the archetype
+    /// - `component_id` must be valid
+    /// - `Archetypes` and `Components` must come from the world this of this `Storages`
+    /// - the caller must ensure that no aliasing rules are violated
+    #[inline]
+    pub unsafe fn get_component(
+        &self,
+        archetypes: &Archetypes,
+        components: &Components,
+        component_id: ComponentId,
+        entity: Entity,
+        location: EntityLocation,
+    ) -> Option<Ptr<'_>> {
+        let archetype = &archetypes[location.archetype_id];
+        // SAFETY: component_id exists and is therefore valid
+        let component_info = unsafe { components.get_info_unchecked(component_id) };
+        match component_info.storage_type() {
+            StorageType::Table => {
+                let table = &self.tables[archetype.table_id()];
+                let components = table.get_column(component_id)?;
+                let table_row = archetype.entity_table_row(location.index);
+                // SAFETY: archetypes only store valid table_rows and the stored component type is T
+                Some(unsafe { components.get_data_unchecked(table_row) })
+            }
+            StorageType::SparseSet => self
+                .sparse_sets
+                .get(component_id)
+                .and_then(|sparse_set| sparse_set.get(entity)),
+        }
+    }
+
+    /// Get a raw pointer to the [`ComponentTicks`] on a particular [`Entity`], identified by the component's [`TypeId`]
+    ///
+    /// # Safety
+    /// - `entity_location` must be within bounds of the given archetype and `entity` must exist inside
+    /// the archetype
+    /// - `Archetypes` and `Components` must come from the world this of this `Storages`
+    /// - the caller must ensure that no aliasing rules are violated
+    #[inline]
+    pub unsafe fn get_ticks_with_type(
+        &self,
+        archetypes: &Archetypes,
+        components: &Components,
+        type_id: TypeId,
+        entity: Entity,
+        location: EntityLocation,
+    ) -> Option<&UnsafeCell<ComponentTicks>> {
+        let component_id = components.get_id(type_id)?;
+        self.get_ticks(archetypes, components, component_id, entity, location)
+    }
+
+    /// Get a raw pointer to the [`ComponentTicks`] on a particular [`Entity`]
+    ///
+    /// # Safety
+    /// - `entity_location` must be within bounds of the given archetype and `entity` must exist inside
+    /// the archetype
+    /// - `component_id` must be valid
+    /// - `Archetypes` and `Components` must come from the world this of this `Storages`
+    /// - the caller must ensure that no aliasing rules are violated
+    #[inline]
+    pub unsafe fn get_ticks(
+        &self,
+        archetypes: &Archetypes,
+        components: &Components,
+        component_id: ComponentId,
+        entity: Entity,
+        location: EntityLocation,
+    ) -> Option<&UnsafeCell<ComponentTicks>> {
+        let archetype = &archetypes[location.archetype_id];
+        let component_info = unsafe { components.get_info_unchecked(component_id) };
+        match component_info.storage_type() {
+            StorageType::Table => {
+                let table = &self.tables[archetype.table_id()];
+                let components = table.get_column(component_id)?;
+                let table_row = archetype.entity_table_row(location.index);
+                // SAFETY: archetypes only store valid table_rows and the stored component type is T
+                Some(unsafe { components.get_ticks_unchecked(table_row) })
+            }
+            StorageType::SparseSet => self
+                .sparse_sets
+                .get(component_id)
+                .and_then(|sparse_set| sparse_set.get_ticks(entity)),
+        }
+    }
+}