reimplement dynamic archetype queries

Author: Plecra

feather/ecs/src/lib.rs

@@ -16,8 +16,8 @@ use hecs::{Component, DynamicBundle, Fetch, Query, World};
 
 #[doc(inline)]
 pub use hecs::{
-    BuiltEntity, ComponentError, Entity, EntityBuilder,
-    MissingComponent, NoSuchEntity, QueryBorrow, Ref, RefMut,
+    Archetype, BuiltEntity, ComponentError, Entity, EntityBuilder, MissingComponent, NoSuchEntity,
+    QueryBorrow, Ref, RefMut,
 };
 
 mod system;
@@ -151,6 +151,19 @@ impl Ecs {
         self.world.query()
     }
 
+    pub fn archetypes(&self) -> impl Iterator<Item = &Archetype> {
+        self.world.archetypes()
+    }
+
+    ///
+    /// # Safety
+    ///
+    /// `id` must correspond to a currently live [`Entity`].
+    /// A despawned or never-allocated `id` will produce undefined behavior.
+    pub unsafe fn find_entity_from_id(&self, id: u32) -> Entity {
+        self.world.find_entity_from_id(id)
+    }
+
     /// Sets the index of the currently executing system,
     /// used for event tracking.
     pub fn set_current_system_index(&mut self, index: usize) {

feather/plugin-host/src/host_calls/query.rs

@@ -3,7 +3,7 @@
 use std::{alloc::Layout, any::TypeId, mem::size_of, ptr};
 
 use anyhow::Context;
-use feather_ecs::{Ecs};
+use feather_ecs::{Archetype, Ecs};
 use feather_plugin_host_macros::host_function;
 use quill_common::{
     component::{ComponentVisitor, SerializationMethod},
@@ -44,13 +44,16 @@ struct WrittenComponentData {
 /// `ComponentVisitor` implementation used to write
 /// component data to plugin memory.
 struct WriteComponentsVisitor<'a> {
+    ecs: &'a Ecs,
+    types: &'a [HostComponent],
     cx: &'a PluginContext,
     num_entities: usize,
 }
 
 impl<'a> ComponentVisitor<anyhow::Result<WrittenComponentData>> for WriteComponentsVisitor<'a> {
     fn visit<T: Component>(self) -> anyhow::Result<WrittenComponentData> {
-        let components = todo!();
+        let components = matching_archetypes(self.ecs, self.types)
+            .map(|archetype| archetype.get::<T>().unwrap());
 
         // Write each component.
         // We use a different strategy depending
@@ -65,7 +68,7 @@ impl<'a> ComponentVisitor<anyhow::Result<WrittenComponentData>> for WriteCompone
                     // Copy the components into the buffer.
                     let mut byte_index = 0;
                     for component_slice in components {
-                        for component in component_slice.as_slice::<T>() {
+                        for component in component_slice.iter() {
                             let bytes = component.as_bytes();
 
                             unsafe {
@@ -86,7 +89,7 @@ impl<'a> ComponentVisitor<anyhow::Result<WrittenComponentData>> for WriteCompone
 
                 // Write components into the buffer.
                 for component_slice in components {
-                    for component in component_slice.as_slice::<T>() {
+                    for component in component_slice.iter() {
                         component.to_bytes(&mut bytes);
                     }
                 }
@@ -103,12 +106,28 @@ impl<'a> ComponentVisitor<anyhow::Result<WrittenComponentData>> for WriteCompone
     }
 }
 
+fn matching_archetypes<'a>(
+    ecs: &'a Ecs,
+    types: &'a [HostComponent],
+) -> impl Iterator<Item = &'a Archetype> + 'a {
+    struct Has<'a>(&'a Archetype);
+    impl ComponentVisitor<bool> for Has<'_> {
+        fn visit<T: Component>(self) -> bool {
+            self.0.has::<T>()
+        }
+    }
+    ecs.archetypes()
+        .filter(move |archetype| types.iter().all(|t| t.visit(Has(archetype))))
+}
+
 fn create_query_data(
     cx: &PluginContext,
     ecs: &Ecs,
     types: &[HostComponent],
 ) -> anyhow::Result<QueryData> {
-    let num_entities = todo!();
+    let num_entities = matching_archetypes(ecs, types)
+        .map(|archetype| archetype.ids().len())
+        .sum();
     if num_entities == 0 {
         return Ok(QueryData {
             num_entities: 0,
@@ -122,6 +141,8 @@ fn create_query_data(
     let component_lens = cx.bump_allocate(Layout::array::<u32>(types.len())?)?;
     for (i, &typ) in types.iter().enumerate() {
         let data = typ.visit(WriteComponentsVisitor {
+            ecs,
+            types,
             cx,
             num_entities,
         })?;
@@ -133,7 +154,15 @@ fn create_query_data(
     }
 
     let entities_ptr = cx.bump_allocate(Layout::array::<EntityId>(num_entities)?)?;
-    for (i, entity) in todo!().enumerate() {
+    for (i, entity) in matching_archetypes(ecs, types)
+        .flat_map(|archetype| {
+            archetype
+                .ids()
+                .iter()
+                .map(|id| unsafe { ecs.find_entity_from_id(*id) })
+        })
+        .enumerate()
+    {
         let bits = entity.to_bits().get();
         unsafe {
             cx.write_pod(entities_ptr.cast().add(i), bits)?;