[Merged by Bors] - untyped APIs for components and resources

crates/bevy_ecs/src/change_detection.rs

@@ -199,3 +199,43 @@ pub struct ReflectMut<'a> {
 change_detection_impl!(ReflectMut<'a>, dyn Reflect,);
 #[cfg(feature = "bevy_reflect")]
 impl_into_inner!(ReflectMut<'a>, dyn Reflect,);
+
+pub struct MutUntyped<'a> {
+    pub(crate) value: *mut (),
+    pub(crate) ticks: Ticks<'a>,
+}
+
+impl<'a> MutUntyped<'a> {
+    /// Returns the pointer to the value, without marking it as changed.
+    /// The value is only valid for the lifetime `'a`, after which it must not be used anymore.
+    /// In order to mark the value as change, you need to call [`set_changed`] manually
+    pub fn ptr(&self) -> *mut () {
+        self.value
+    }
+}
+
+impl DetectChanges for MutUntyped<'_> {
+    fn is_added(&self) -> bool {
+        self.ticks
+            .component_ticks
+            .is_added(self.ticks.last_change_tick, self.ticks.change_tick)
+    }
+
+    fn is_changed(&self) -> bool {
+        self.ticks
+            .component_ticks
+            .is_changed(self.ticks.last_change_tick, self.ticks.change_tick)
+    }
+
+    fn set_changed(&mut self) {
+        self.ticks
+            .component_ticks
+            .set_changed(self.ticks.change_tick);
+    }
+}
+
+impl std::fmt::Debug for MutUntyped<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("MutDynamic").field(&self.value).finish()
+    }
+}

crates/bevy_ecs/src/component.rs

@@ -193,6 +193,24 @@ impl ComponentDescriptor {
         }
     }
 
+    pub unsafe fn new_with_layout(
+        name: String,
+        storage_type: StorageType,
+        is_send_and_sync: bool,
+        type_id: Option<TypeId>,
+        layout: Layout,
+        drop: unsafe fn(*mut u8),
+    ) -> Self {
+        Self {
+            name,
+            storage_type,
+            is_send_and_sync,
+            type_id,
+            layout,
+            drop,
+        }
+    }
+
     /// Create a new `ComponentDescriptor` for a resource.
     ///
     /// The [`StorageType`] for resources is always [`TableStorage`].
@@ -247,20 +265,41 @@ impl Components {
     #[inline]
     pub fn init_component<T: Component>(&mut self, storages: &mut Storages) -> ComponentId {
         let type_id = TypeId::of::<T>();
-        let components = &mut self.components;
-        let index = self.indices.entry(type_id).or_insert_with(|| {
-            let index = components.len();
-            let descriptor = ComponentDescriptor::new::<T>();
-            let info = ComponentInfo::new(ComponentId(index), descriptor);
-            if T::Storage::STORAGE_TYPE == StorageType::SparseSet {
-                storages.sparse_sets.get_or_insert(&info);
-            }
-            components.push(info);
-            index
+
+        let Components {
+            indices,
+            components,
+            ..
+        } = self;
+        let index = indices.entry(type_id).or_insert_with(|| {
+            Components::init_component_inner(components, storages, ComponentDescriptor::new::<T>())
         });
         ComponentId(*index)
     }
 
+    pub fn init_component_with_descriptor(
+        &mut self,
+        storages: &mut Storages,
+        descriptor: ComponentDescriptor,
+    ) -> ComponentId {
+        let index = Components::init_component_inner(&mut self.components, storages, descriptor);
+        ComponentId(index)
+    }
+
+    fn init_component_inner(
+        components: &mut Vec<ComponentInfo>,
+        storages: &mut Storages,
+        descriptor: ComponentDescriptor,
+    ) -> usize {
+        let index = components.len();
+        let info = ComponentInfo::new(ComponentId(index), descriptor);
+        if info.descriptor.storage_type == StorageType::SparseSet {
+            storages.sparse_sets.get_or_insert(&info);
+        }
+        components.push(info);
+        index
+    }
+
     #[inline]
     pub fn len(&self) -> usize {
         self.components.len()
@@ -336,6 +375,10 @@ impl Components {
 
         ComponentId(*index)
     }
+
+    pub fn iter(&self) -> impl Iterator<Item = &ComponentInfo> + '_ {
+        self.components.iter()
+    }
 }
 
 #[derive(Clone, Debug)]

crates/bevy_ecs/src/storage/blob_vec.rs

@@ -58,6 +58,10 @@ impl BlobVec {
         self.capacity
     }
 
+    pub fn layout(&self) -> Layout {
+        self.item_layout
+    }
+
     pub fn reserve_exact(&mut self, additional: usize) {
         let available_space = self.capacity - self.len;
         if available_space < additional {

crates/bevy_ecs/src/world/entity_ref.rs

@@ -1,7 +1,7 @@
 use crate::{
     archetype::{Archetype, ArchetypeId, Archetypes},
     bundle::{Bundle, BundleInfo},
-    change_detection::Ticks,
+    change_detection::{MutUntyped, Ticks},
     component::{Component, ComponentId, ComponentTicks, Components, StorageType},
     entity::{Entities, Entity, EntityLocation},
     storage::{SparseSet, Storages},
@@ -70,6 +70,13 @@ impl<'w> EntityRef<'w> {
         }
     }
 
+    pub fn get_by_id(&self, component_id: ComponentId) -> Option<*const ()> {
+        unsafe {
+            get_component(self.world, component_id, self.entity, self.location)
+                .map(|ptr| ptr as *const ())
+        }
+    }
+
     /// Gets a mutable reference to the component of type `T` associated with
     /// this entity without ensuring there are no other borrows active and without
     /// ensuring that the returned reference will stay valid.
@@ -157,12 +164,35 @@ impl<'w> EntityMut<'w> {
         unsafe { self.get_unchecked::<T>() }
     }
 
+    pub fn get_by_id(&self, component_id: ComponentId) -> Option<*const ()> {
+        unsafe {
+            get_component(self.world, component_id, self.entity, self.location)
+                .map(|ptr| ptr as *const ())
+        }
+    }
+
     #[inline]
     pub fn get_mut<T: Component>(&mut self) -> Option<Mut<'_, T>> {
         // SAFE: world access is unique, and lifetimes enforce correct usage of returned borrow
         unsafe { self.get_unchecked_mut::<T>() }
     }
 
+    pub fn get_mut_by_id(&mut self, component_id: ComponentId) -> Option<MutUntyped> {
+        // SAFE: world access is unique and entity location is valid
+        unsafe {
+            get_component_and_ticks(self.world, component_id, self.entity, self.location).map(
+                |(value, ticks)| MutUntyped {
+                    value: value.cast(),
+                    ticks: Ticks {
+                        component_ticks: &mut *ticks,
+                        last_change_tick: self.world.last_change_tick(),
+                        change_tick: self.world.read_change_tick(),
+                    },
+                },
+            )
+        }
+    }
+
     /// Gets an immutable reference to the component of type `T` associated with
     /// this entity without ensuring there are no unique borrows active and without
     /// ensuring that the returned reference will stay valid.

crates/bevy_ecs/src/world/mod.rs

@@ -10,8 +10,10 @@ pub use world_cell::*;
 use crate::{
     archetype::{ArchetypeComponentId, ArchetypeComponentInfo, ArchetypeId, Archetypes},
     bundle::{Bundle, BundleInserter, BundleSpawner, Bundles},
-    change_detection::Ticks,
-    component::{Component, ComponentId, ComponentTicks, Components, StorageType},
+    change_detection::{MutUntyped, Ticks},
+    component::{
+        Component, ComponentDescriptor, ComponentId, ComponentTicks, Components, StorageType,
+    },
     entity::{AllocAtWithoutReplacement, Entities, Entity},
     query::{FilterFetch, QueryState, WorldQuery},
     storage::{Column, SparseSet, Storages},
@@ -179,6 +181,14 @@ impl World {
         self.components.init_component::<T>(&mut self.storages)
     }
 
+    pub fn init_component_with_descriptor(
+        &mut self,
+        descriptor: ComponentDescriptor,
+    ) -> ComponentId {
+        self.components
+            .init_component_with_descriptor(&mut self.storages, descriptor)
+    }
+
     /// Retrieves an [`EntityRef`] that exposes read-only operations for the given `entity`.
     /// This will panic if the `entity` does not exist. Use [`World::get_entity`] if you want
     /// to check for entity existence instead of implicitly panic-ing.
@@ -1095,6 +1105,33 @@ impl World {
         Some(&*column.get_data_ptr().as_ptr().cast::<R>())
     }
 
+    pub fn get_resource_by_id(&self, component_id: ComponentId) -> Option<*const ()> {
+        let info = self.components.get_info(component_id)?;
+        if !info.is_send_and_sync() {
+            self.validate_non_send_access_untyped(info.name());
+        }
+
+        let column = self.get_populated_resource_column(component_id)?;
+        Some(unsafe { column.get_data_ptr().as_ptr().cast() })
+    }
+
+    pub fn get_resource_mut_by_id(&mut self, component_id: ComponentId) -> Option<MutUntyped> {
+        let info = self.components.get_info(component_id)?;
+        if !info.is_send_and_sync() {
+            self.validate_non_send_access_untyped(info.name());
+        }
+
+        let column = self.get_populated_resource_column(component_id)?;
+        let value = unsafe { column.get_data_ptr().as_ptr().cast() };
+        let ticks = Ticks {
+            component_ticks: unsafe { &mut *column.get_ticks_mut_ptr_unchecked(0) },
+            last_change_tick: self.last_change_tick(),
+            change_tick: self.read_change_tick(),
+        };
+
+        Some(MutUntyped { value, ticks })
+    }
+
     /// # Safety
     /// `component_id` must be assigned to a component of type `R`
     /// Caller must ensure this doesn't violate Rust mutability rules for the given resource.
@@ -1155,6 +1192,27 @@ impl World {
         }
     }
 
+    /// # Safety
+    /// The value referenced by `value` must be valid for the given ComponentId
+    pub unsafe fn insert_resource_by_id(&mut self, component_id: ComponentId, value: *const ()) {
+        let change_tick = self.change_tick();
+        let column = self.initialize_resource_internal(component_id);
+        if column.is_empty() {
+            let value = ManuallyDrop::new(value);
+            // SAFE: column has been allocated above and `value` is valid as per the function's safety requirements
+            column.push(
+                value.cast::<u8>() as *mut _,
+                ComponentTicks::new(change_tick),
+            );
+        } else {
+            // SAFE: column has been allocated above and `value` is valid as per the function's safety requirements
+            let ptr = column.get_data_unchecked(0).cast::<u8>();
+            std::ptr::copy_nonoverlapping(value.cast::<u8>(), ptr, column.data.layout().size());
+
+            column.get_ticks_unchecked_mut(0).set_changed(change_tick);
+        }
+    }
+
     /// # Safety
     /// `component_id` must be valid and correspond to a resource component of type `R`
     #[inline]
@@ -1223,6 +1281,14 @@ impl World {
         );
     }
 
+    pub(crate) fn validate_non_send_access_untyped(&self, name: &str) {
+        assert!(
+            self.main_thread_validator.is_main_thread(),
+            "attempted to access NonSend resource {} off of the main thread",
+            name
+        );
+    }
+
     /// Empties queued entities and adds them to the empty [Archetype](crate::archetype::Archetype).
     /// This should be called before doing operations that might operate on queued entities,
     /// such as inserting a [Component].