ecs: New model for plugin components, implement test query code

Author: caelunshun

Cargo.lock

@@ -7,4 +7,5 @@ edition = "2018"
 [dependencies]
 ahash = "0.7"
 arrayvec = "0.5"
+itertools = "0.10"
 thiserror = "1"

quill/ecs/Cargo.toml

@@ -1,6 +1,4 @@
-use std::{alloc::Layout, any::TypeId, sync::Arc};
-
-use crate::space::MemorySpace;
+use std::{alloc::Layout, any::TypeId, ptr, sync::Arc};
 
 /// A type that can be used as a component.
 ///
@@ -9,66 +7,24 @@ pub trait Component: Send + 'static {}
 
 impl<T> Component for T where T: Send + 'static {}
 
-/// Type ID of a component.
-///
-/// Supports both Rust types and arbitrary
-/// "opaque" types identified by a `u64`.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct ComponentTypeId(ComponentTypeIdInner);
-
-impl ComponentTypeId {
-    pub fn of<T: 'static>() -> Self {
-        Self(ComponentTypeIdInner::Rust(TypeId::of::<T>()))
-    }
-
-    pub fn opaque(id: u64) -> Self {
-        Self(ComponentTypeIdInner::Opaque(id))
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
-enum ComponentTypeIdInner {
-    Rust(TypeId),
-    Opaque(u64),
-}
-
 /// Metadata for a component type.
 #[derive(Clone)]
 pub struct ComponentMeta {
-    /// Memory space where the component is allocated.
-    pub(crate) space: Arc<MemorySpace>,
     /// Component type ID.
-    pub(crate) type_id: ComponentTypeId,
+    pub(crate) type_id: TypeId,
     /// Component layout.
     pub(crate) layout: Layout,
     /// Function to drop the component.
-    pub(crate) drop_fn: Arc<dyn Fn(*mut u8) + Send + Sync>,
+    pub(crate) drop_fn: unsafe fn(*mut u8),
 }
 
 impl ComponentMeta {
     /// Creates a `ComponentMeta` for a native Rust component.
     pub fn of<T: 'static>() -> Self {
         Self {
-            space: Arc::new(MemorySpace::host()),
-            type_id: ComponentTypeId::of::<T>(),
+            type_id: TypeId::of::<T>(),
             layout: Layout::new::<T>(),
-            drop_fn: Arc::new(|data| unsafe { std::ptr::drop_in_place(data.cast::<T>()) }),
-        }
-    }
-
-    /// Creates a `ComponentMeta` for an arbitrary type, maybe opaque,
-    /// maybe allocated in a non-default memory space.
-    pub fn custom(
-        space: Arc<MemorySpace>,
-        type_id: ComponentTypeId,
-        layout: Layout,
-        drop_fn: Arc<dyn Fn(*mut u8) + Send + Sync>,
-    ) -> Self {
-        Self {
-            space,
-            type_id,
-            layout,
-            drop_fn,
+            drop_fn: |ptr| unsafe { ptr::drop_in_place(ptr.cast::<T>()) },
         }
     }
 }

quill/ecs/src/component.rs

@@ -1,15 +1,21 @@
-use std::any::type_name;
+use std::{any::type_name, iter};
 
 use ahash::AHashMap;
+use itertools::Either;
 
 use crate::{
     bundle::ComponentBundle,
-    component::{Component, ComponentMeta, ComponentTypeId},
+    component::{Component, ComponentMeta},
     entity::{Entities, EntityId},
     entity_builder::EntityBuilder,
     storage::SparseSetStorage,
+    QueryDriver, QueryTuple,
 };
 
+pub use self::components::Components;
+
+mod components;
+
 #[derive(Debug, thiserror::Error)]
 pub enum ComponentError {
     #[error("entity does not have a component of type {0}")]
@@ -32,7 +38,7 @@ pub struct EntityDead;
 /// Feather, the `World` stores blocks, not entities.)
 #[derive(Default)]
 pub struct Ecs {
-    components: AHashMap<ComponentTypeId, SparseSetStorage>,
+    components: Components,
     entities: Entities,
 }
 
@@ -46,11 +52,8 @@ impl Ecs {
     ///
     /// Time complexity: O(1)
     pub fn get<T: Component>(&self, entity: EntityId) -> Result<&T, ComponentError> {
-        let storage = self.storage_for::<T>()?;
         self.check_entity(entity)?;
-        storage
-            .get::<T>(entity.index())
-            .ok_or_else(|| ComponentError::MissingComponent(type_name::<T>()))
+        self.components.get(entity.index())
     }
 
     /// Inserts a component for an entity.
@@ -65,23 +68,19 @@ impl Ecs {
         component: T,
     ) -> Result<(), EntityDead> {
         self.check_entity(entity)?;
-        let storage = self.storage_or_insert_for::<T>();
-        storage.insert(entity.index(), component);
+        self.components.insert(entity.index(), component);
         Ok(())
     }
 
     /// Removes a component from an entity.
     ///
     /// Returns `Err` if the entity does not exist
     /// or if it did not have the component.
+    ///
+    /// Time complexity: O(1)
     pub fn remove<T: Component>(&mut self, entity: EntityId) -> Result<(), ComponentError> {
         self.check_entity(entity)?;
-        let storage = self.storage_mut_for::<T>()?;
-        if storage.remove(entity.index()) {
-            Ok(())
-        } else {
-            Err(ComponentError::MissingComponent(type_name::<T>()))
-        }
+        self.components.remove::<T>(entity.index())
     }
 
     /// Creates a new entity with no components.
@@ -101,9 +100,9 @@ impl Ecs {
         let entity = self.spawn_empty();
 
         for (component_meta, component) in builder.drain() {
-            let storage = self.storage_or_insert_for_untyped(component_meta);
             unsafe {
-                storage.insert_raw(entity.index(), component.as_ptr());
+                self.components
+                    .insert_raw(entity.index(), component_meta, component.as_ptr());
             }
         }
 
@@ -134,43 +133,41 @@ impl Ecs {
 
         // PERF: could we somehow optimize this linear search
         // by only checking storages containing the entity?
-        for storage in self.components.values_mut() {
+        for (_, storage) in self.components.storages_mut() {
             storage.remove(entity.index());
         }
 
         Ok(())
     }
 
+    /// Queries for all entities that have the given set of components.
+    ///
+    /// Returns an iterator over tuples of `(entity, components)`.
+    pub fn query<'a, Q: QueryTuple>(
+        &'a self,
+    ) -> impl Iterator<Item = (EntityId, Q::Output<'a>)> + 'a
+    where
+        Q::Output<'a>: 'a,
+    {
+        let sparse_sets = match Q::sparse_sets(&self.components) {
+            Some(s) => s,
+            None => return Either::Left(iter::empty()),
+        };
+        let sparse_set_refs: Vec<_> = sparse_sets.iter().map(|s| s.to_ref()).collect();
+        let dense_indices = Q::dense_indices();
+
+        let driver = QueryDriver::new(&sparse_set_refs, &dense_indices);
+
+        Either::Right(driver.iter().map(move |item| {
+            let components = unsafe { Q::make_output(&sparse_sets, item.dense_indices) };
+            let entity = self.entities.get(item.sparse_index);
+            (entity, components)
+        }))
+    }
+
     fn check_entity(&self, entity: EntityId) -> Result<(), EntityDead> {
         self.entities
             .check_generation(entity)
             .map_err(|_| EntityDead)
     }
-
-    fn storage_for<T: Component>(&self) -> Result<&SparseSetStorage, ComponentError> {
-        self.components
-            .get(&ComponentTypeId::of::<T>())
-            .ok_or_else(|| ComponentError::MissingComponent(type_name::<T>()))
-    }
-
-    fn storage_mut_for<T: Component>(&mut self) -> Result<&mut SparseSetStorage, ComponentError> {
-        self.components
-            .get_mut(&ComponentTypeId::of::<T>())
-            .ok_or_else(|| ComponentError::MissingComponent(type_name::<T>()))
-    }
-
-    fn storage_or_insert_for<T: Component>(&mut self) -> &mut SparseSetStorage {
-        self.components
-            .entry(ComponentTypeId::of::<T>())
-            .or_insert_with(|| SparseSetStorage::new(ComponentMeta::of::<T>()))
-    }
-
-    fn storage_or_insert_for_untyped(
-        &mut self,
-        component_meta: ComponentMeta,
-    ) -> &mut SparseSetStorage {
-        self.components
-            .entry(component_meta.type_id)
-            .or_insert_with(|| SparseSetStorage::new(component_meta))
-    }
 }

quill/ecs/src/ecs.rs

@@ -0,0 +1,90 @@
+use std::any::{type_name, TypeId};
+
+use ahash::AHashMap;
+
+use crate::{component::ComponentMeta, storage::SparseSetStorage, Component, ComponentError};
+
+/// A raw ECS that stores only components but does not track
+/// entities.
+///
+/// Operates on entity indices but does not account for generations.
+#[derive(Default)]
+pub struct Components {
+    storages: AHashMap<TypeId, SparseSetStorage>,
+}
+
+impl Components {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn insert<T: Component>(&mut self, index: u32, component: T) {
+        self.storage_or_insert_for::<T>().insert(index, component);
+    }
+
+    /// # Safety
+    /// `component` must point to a valid instance of the component.
+    pub unsafe fn insert_raw(
+        &mut self,
+        index: u32,
+        component_meta: ComponentMeta,
+        component: *const u8,
+    ) {
+        self.storage_or_insert_for_untyped(component_meta)
+            .insert_raw(index, component)
+    }
+
+    pub fn remove<T: Component>(&mut self, index: u32) -> Result<(), ComponentError> {
+        let was_removed = self.storage_mut_for::<T>()?.remove(index);
+        if was_removed {
+            Ok(())
+        } else {
+            Err(ComponentError::MissingComponent(type_name::<T>()))
+        }
+    }
+
+    pub fn get<T: Component>(&self, index: u32) -> Result<&T, ComponentError> {
+        self.storage_for::<T>()?
+            .get(index)
+            .ok_or_else(|| ComponentError::MissingComponent(type_name::<T>()))
+    }
+
+    pub fn storages(&self) -> impl Iterator<Item = (TypeId, &SparseSetStorage)> + '_ {
+        self.storages
+            .iter()
+            .map(|(&type_id, storage)| (type_id, storage))
+    }
+
+    pub fn storages_mut(&mut self) -> impl Iterator<Item = (TypeId, &mut SparseSetStorage)> + '_ {
+        self.storages
+            .iter_mut()
+            .map(|(&type_id, storage)| (type_id, storage))
+    }
+
+    pub fn storage_for<T: Component>(&self) -> Result<&SparseSetStorage, ComponentError> {
+        self.storages
+            .get(&TypeId::of::<T>())
+            .ok_or_else(|| ComponentError::MissingComponent(type_name::<T>()))
+    }
+
+    fn storage_mut_for<T: Component>(&mut self) -> Result<&mut SparseSetStorage, ComponentError> {
+        self.storages
+            .get_mut(&TypeId::of::<T>())
+            .ok_or_else(|| ComponentError::MissingComponent(type_name::<T>()))
+    }
+
+    fn storage_or_insert_for<T: Component>(&mut self) -> &mut SparseSetStorage {
+        self.storages
+            .entry(TypeId::of::<T>())
+            .or_insert_with(|| SparseSetStorage::new(ComponentMeta::of::<T>()))
+    }
+
+    fn storage_or_insert_for_untyped(
+        &mut self,
+        component_meta: ComponentMeta,
+    ) -> &mut SparseSetStorage {
+        self.storages
+            .entry(component_meta.type_id)
+            .or_insert_with(|| SparseSetStorage::new(component_meta))
+    }
+}

quill/ecs/src/ecs/components.rs

@@ -80,6 +80,14 @@ impl Entities {
             Ok(())
         }
     }
+
+    /// Gets the entity with generation for the given index.
+    pub fn get(&self, index: u32) -> EntityId {
+        EntityId {
+            index,
+            generation: self.generations[index as usize],
+        }
+    }
 }
 
 #[cfg(test)]

quill/ecs/src/entity.rs

@@ -1,9 +1,10 @@
 use std::{
+    any::TypeId,
     mem::{size_of, MaybeUninit},
     ptr::{self, NonNull},
 };
 
-use crate::{component::ComponentMeta, Component, ComponentTypeId, Ecs, EntityId};
+use crate::{component::ComponentMeta, Component, Ecs, EntityId};
 
 /// A utility to build an entity's components.
 ///
@@ -52,7 +53,7 @@ impl EntityBuilder {
     pub fn has<T: Component>(&self) -> bool {
         self.entries
             .iter()
-            .any(|entry| entry.component_meta.type_id == ComponentTypeId::of::<T>())
+            .any(|entry| entry.component_meta.type_id == TypeId::of::<T>())
     }
 
     /// Spawns the entity builder into an `Ecs`.
@@ -100,18 +101,18 @@ mod tests {
         unsafe {
             let mut iter = builder.drain();
             let (meta, data) = iter.next().unwrap();
-            assert_eq!(meta.type_id, ComponentTypeId::of::<i32>());
+            assert_eq!(meta.type_id, TypeId::of::<i32>());
             assert_eq!(ptr::read_unaligned::<i32>(data.cast().as_ptr()), 10i32);
 
             let (meta, data) = iter.next().unwrap();
-            assert_eq!(meta.type_id, ComponentTypeId::of::<String>());
+            assert_eq!(meta.type_id, TypeId::of::<String>());
             assert_eq!(
                 ptr::read_unaligned::<String>(data.cast().as_ptr()),
                 "a string"
             );
 
             let (meta, data) = iter.next().unwrap();
-            assert_eq!(meta.type_id, ComponentTypeId::of::<usize>());
+            assert_eq!(meta.type_id, TypeId::of::<usize>());
             assert_eq!(ptr::read_unaligned::<usize>(data.cast().as_ptr()), 50usize);
 
             assert!(iter.next().is_none());