From 9226356b7b54c4c5b036b6fee00bba376245c5f3 Mon Sep 17 00:00:00 2001 From: HampusM Date: Fri, 24 Jul 2026 22:32:21 +0200 Subject: feat(engine-ecs): add traversal query term --- engine-ecs/src/query.rs | 334 +++++++++++++++++++++++++++--------------------- 1 file changed, 190 insertions(+), 144 deletions(-) (limited to 'engine-ecs/src/query.rs') diff --git a/engine-ecs/src/query.rs b/engine-ecs/src/query.rs index 8549411..10260f2 100644 --- a/engine-ecs/src/query.rs +++ b/engine-ecs/src/query.rs @@ -1,8 +1,8 @@ use std::any::type_name; use std::marker::PhantomData; -use seq_macro::seq; use paste::paste; +use seq_macro::seq; use util_macros::sub; use crate::component::{ @@ -11,13 +11,27 @@ use crate::component::{ HandleMut as ComponentHandleMut, }; use crate::entity::Handle as EntityHandle; +use crate::pair::Wildcard; use crate::query::flexible::{Iter as FlexibleQueryIter, Query as FlexibleQuery}; use crate::system::{Metadata as SystemMetadata, Param as SystemParam}; -use crate::tuple::Tuple; +use crate::tuple::{Concat, Tuple}; use crate::uid::Uid; use crate::util::array_vec::ArrayVec; use crate::util::Array; -use crate::World; +use crate::{pair, World}; + +mod reexports +{ + pub use crate::component::storage::{ + SearchTerms as Terms, + TermMetadata, + Traversal, + TraversalKind, + TraversalResult, + }; +} + +pub use reexports::*; pub mod flexible; pub mod term; @@ -27,23 +41,20 @@ pub const MAX_TERM_CNT: usize = 17; #[derive(Debug)] pub struct Query<'world, TermsT> -where - TermsT: TermTuple<'world>, { inner: FlexibleQuery<'world, MAX_TERM_CNT>, _pd: PhantomData, } impl<'world, TermsT> Query<'world, TermsT> -where - TermsT: TermTuple<'world>, { /// Iterates over the entities matching this query, the iterator item being the entity /// components. #[must_use] - pub fn iter<'this>( - &'this self, - ) -> Iter<'this, 'world, TermsT, FlexibleQueryIter<'this, 'world>> + pub fn iter<'this>(&'this self) -> Iter<'this, TermsT> + where + TermsT: TermTuple<'this>, + 'world: 'this, { tracing::trace!("Searching for {}", std::any::type_name::()); @@ -57,44 +68,25 @@ where /// Iterates over the entities matching this query, the iterator item being the entity /// [`Uid`] and the matching entity components. #[must_use] - pub fn iter_with_euids<'this>( - &'this self, - ) -> ComponentAndEuidIter<'this, 'world, TermsT, FlexibleQueryIter<'this, 'world>> - { - tracing::trace!("Searching for {}", std::any::type_name::()); - - ComponentAndEuidIter { - world: self.inner.world(), - iter: self.inner.iter(), - comps_pd: PhantomData, - } - } - - /// Iterates over the entities matching this query using the iterator returned by - /// `func`. - /// - /// This function exists so that a custom [`EntityHandle`] iterator can be given to - /// [`Iter`] without giving the user access to a reference to the [`World`]. - #[must_use] - pub fn iter_with<'this, OutIter>( - &'this self, - func: impl FnOnce(FlexibleQueryIter<'this, 'world>) -> OutIter, - ) -> Iter<'this, 'world, TermsT, OutIter> + pub fn iter_with_euids<'this>(&'this self) -> ComponentAndEuidIter<'this, TermsT> where - OutIter: Iterator>, + TermsT: TermTuple<'this>, + 'world: 'this, { tracing::trace!("Searching for {}", std::any::type_name::()); - Iter { + ComponentAndEuidIter { world: self.inner.world(), - inner: func(self.inner.iter()), + inner: self.inner.iter(), comps_pd: PhantomData, } } /// Returns the UID of the entity at the given query iteration index. #[must_use] - pub fn get_entity_uid(&self, entity_index: usize) -> Option + pub fn get_entity_uid<'this>(&'this self, entity_index: usize) -> Option + where + TermsT: TermTuple<'this>, { Some(self.inner.iter().nth(entity_index)?.uid()) } @@ -124,10 +116,12 @@ where } pub(crate) fn new(world: &'world World) -> Self + where + TermsT: TermTuple<'world>, { let mut terms_builder = Terms::builder(); - TermsT::apply_terms_to_builder(&mut terms_builder); + TermsT::apply_terms_to_builder(&mut terms_builder, 0); Self { inner: world.flexible_query(terms_builder.build()), @@ -136,12 +130,12 @@ where } } -impl<'query, 'world, TermsT> IntoIterator - for &'query Query<'world, TermsT> +impl<'query, 'world, TermsT> IntoIterator for &'query Query<'world, TermsT> where - TermsT: TermTuple<'world>, + TermsT: TermTuple<'query>, + 'world: 'query, { - type IntoIter = Iter<'query, 'world, TermsT, FlexibleQueryIter<'query, 'world>>; + type IntoIter = Iter<'query, TermsT>; type Item = TermsT::Fields; fn into_iter(self) -> Self::IntoIter @@ -150,8 +144,7 @@ where } } -impl<'world, TermsT> SystemParam<'world> - for Query<'world, TermsT> +impl<'world, TermsT> SystemParam<'world> for Query<'world, TermsT> where TermsT: TermTuple<'world>, { @@ -163,13 +156,6 @@ where } } -#[derive(Debug)] -pub struct Terms -{ - present: ArrayVec, - absent: ArrayVec, -} - impl Terms { pub fn builder() -> TermsBuilder @@ -180,30 +166,33 @@ impl Terms #[derive(Debug, Default)] #[must_use] -pub struct TermsBuilder +pub struct TermsBuilder { - present: ArrayVec, - absent: ArrayVec, + present: ArrayVec, + absent: ArrayVec, + traverse: ArrayVec, TERM_CAP>, } #[allow(clippy::return_self_not_must_use)] -pub trait TermsBuilderInterface +pub trait TermsBuilderInterface { fn present(self, ids: impl Array) -> Self; fn absent(self, ids: impl Array) -> Self; + + fn traverse(self, traversals: impl Array> + Clone) -> Self; } macro_rules! impl_terms_builder { ($($impl_content: tt)*) => { - impl - TermsBuilderInterface for TermsBuilder + impl + TermsBuilderInterface for TermsBuilder { $($impl_content)* } - impl - TermsBuilderInterface for &mut TermsBuilder + impl + TermsBuilderInterface for &mut TermsBuilder { $($impl_content)* } @@ -274,6 +263,17 @@ impl_terms_builder! { self } + + #[allow(unused_mut)] + fn traverse(mut self, traversals: impl Array> + Clone) -> Self + { + self.traverse.extend(traversals.clone()); + + self.present( + traversals + .map(|traversal| pair!({ traversal.relation }, Wildcard).id()) + ) + } } impl TermsBuilder @@ -287,45 +287,49 @@ impl TermsBuilder Terms { present: self.present, absent: self.absent, + traverse: self.traverse, } } } -pub trait Term<'world> +pub trait Term<'query> { - type AddField; + type Fields: Tuple; fn apply_to_terms_builder( terms_builder: &mut TermsBuilder, + term_metadata: TermMetadata, ); - fn add_field( - entity_handle: &EntityHandle<'world>, - world: &'world World, - fields: Fields, - ) -> Self::AddField; + fn fields( + world: &'query World, + search_result: &SearchResult<'query, '_>, + term_metadata: TermMetadata, + ) -> Self::Fields; } -impl<'world, ComponentT: Component> Term<'world> for &ComponentT +impl<'query, ComponentT: Component> Term<'query> for &ComponentT { - type AddField = Fields::WithElementAtEnd>; + type Fields = (ComponentHandle<'query, ComponentT>,); fn apply_to_terms_builder( terms_builder: &mut TermsBuilder, + _term_metadata: TermMetadata, ) { terms_builder.present([ComponentT::id()]); } - fn add_field( - entity_handle: &EntityHandle<'world>, - _world: &'world World, - fields: Fields, - ) -> Self::AddField + fn fields( + _world: &'query World, + search_result: &SearchResult<'query, '_>, + _term_metadata: TermMetadata, + ) -> Self::Fields { assert!(!ComponentT::id().is_pair()); - let Some(component) = entity_handle + let Some(component) = search_result + .entity_handle .get_matching_components(ComponentT::id()) .next() else { @@ -335,44 +339,47 @@ impl<'world, ComponentT: Component> Term<'world> for &ComponentT "is most likely a bug in the entity querying" ), type_name::(), - entity_handle.uid() + search_result.entity_handle.uid() ); }; - let component = match ComponentHandle::::from_entity_component_ref(&component) { - Ok(component) => component, - Err(err) => { - panic!( - "Creating handle to component {} failed: {err}", - type_name::() - ); - } - }; + let component = + match ComponentHandle::::from_entity_component_ref(&component) { + Ok(component) => component, + Err(err) => { + panic!( + "Creating handle to component {} failed: {err}", + type_name::() + ); + } + }; - fields.with_elem(component) + (component,) } } -impl<'world, ComponentT: Component> Term<'world> for &mut ComponentT +impl<'query, ComponentT: Component> Term<'query> for &mut ComponentT { - type AddField = Fields::WithElementAtEnd>; + type Fields = (ComponentHandleMut<'query, ComponentT>,); fn apply_to_terms_builder( terms_builder: &mut TermsBuilder, + _term_metadata: TermMetadata, ) { terms_builder.present([ComponentT::id()]); } - fn add_field( - entity_handle: &EntityHandle<'world>, - world: &'world World, - fields: Fields, - ) -> Self::AddField + fn fields( + world: &'query World, + search_result: &SearchResult<'query, '_>, + _term_metadata: TermMetadata, + ) -> Self::Fields { assert!(!ComponentT::id().is_pair()); - let Some(component) = entity_handle + let Some(component) = search_result + .entity_handle .get_matching_components(ComponentT::id()) .next() else { @@ -382,11 +389,13 @@ impl<'world, ComponentT: Component> Term<'world> for &mut ComponentT "is most likely a bug in the entity querying" ), type_name::(), - entity_handle.uid() + search_result.entity_handle.uid() ); }; - let component = match ComponentHandleMut::::from_entity_component_ref(&component, world) { + let component = match ComponentHandleMut::::from_entity_component_ref( + &component, world, + ) { Ok(component) => component, Err(err) => { panic!( @@ -396,57 +405,67 @@ impl<'world, ComponentT: Component> Term<'world> for &mut ComponentT } }; - fields.with_elem(component) + (component,) } } -impl<'world, TermT, FieldAcc> TermFieldSource<'world, FieldAcc> for TermT -where - TermT: Term<'world>, - TermT::AddField: Tuple, - FieldAcc: Tuple +impl<'query, TermT, FieldAcc> TermFieldSource<'query, FieldAcc> for TermT +where + TermT: Term<'query, Fields: Concat>, + FieldAcc: Tuple, { - type NewFieldAcc = TermT::AddField; + type NewFieldAcc = >::Output; fn collect_field( - entity_handle: &EntityHandle<'world>, - world: &'world World, + world: &'query World, + search_result: &SearchResult<'query, '_>, + term_metadata: TermMetadata, fields: FieldAcc, ) -> Self::NewFieldAcc { - Self::add_field(entity_handle, world, fields) + >::concat( + Self::fields(world, search_result, term_metadata), + fields, + ) } } -pub trait TermTuple<'world> +pub trait TermTuple<'query> { - type Fields; + type Fields: Tuple; fn apply_terms_to_builder( terms_builder: &mut TermsBuilder, + term_level: u32, ); fn get_fields( - entity_handle: &EntityHandle<'world>, - world: &'world World, + world: &'query World, + search_result: &SearchResult<'query, '_>, + term_level: u32, ) -> Self::Fields; } -pub struct Iter<'query, 'world, TermsT, EntityHandleIter> +#[derive(Debug)] +#[non_exhaustive] +pub struct SearchResult<'query, 'temp> +{ + pub entity_handle: EntityHandle<'query>, + pub traversal_results: &'temp [TraversalResult], +} + +pub struct Iter<'query, TermsT> where - TermsT: TermTuple<'world>, - EntityHandleIter: Iterator>, + TermsT: TermTuple<'query>, { - world: &'world World, - inner: EntityHandleIter, - comps_pd: PhantomData<(TermsT, &'query ())>, + world: &'query World, + inner: FlexibleQueryIter<'query, MAX_TERM_CNT>, + comps_pd: PhantomData, } -impl<'query, 'world, TermsT, EntityHandleIter> Iterator - for Iter<'query, 'world, TermsT, EntityHandleIter> +impl<'query, TermsT> Iterator for Iter<'query, TermsT> where - TermsT: TermTuple<'world>, - EntityHandleIter: Iterator>, + TermsT: TermTuple<'query>, { type Item = TermsT::Fields; @@ -454,46 +473,58 @@ where { let entity_handle = self.inner.next()?; - Some(TermsT::get_fields(&entity_handle, self.world)) + Some(TermsT::get_fields( + self.world, + &SearchResult { + entity_handle, + traversal_results: self.inner.traversal_results().unwrap(), + }, + 0, + )) } } -pub struct ComponentAndEuidIter<'query, 'world, TermsT, EntityHandleIter> +pub struct ComponentAndEuidIter<'query, TermsT> where - TermsT: TermTuple<'world>, - EntityHandleIter: Iterator>, + TermsT: TermTuple<'query>, { - world: &'world World, - iter: EntityHandleIter, - comps_pd: PhantomData<(TermsT, &'query ())>, + world: &'query World, + inner: FlexibleQueryIter<'query, MAX_TERM_CNT>, + comps_pd: PhantomData, } -impl<'query, 'world, TermsT, EntityHandleIter> Iterator - for ComponentAndEuidIter<'query, 'world, TermsT, EntityHandleIter> +impl<'query, TermsT> Iterator for ComponentAndEuidIter<'query, TermsT> where - TermsT: TermTuple<'world>, - EntityHandleIter: Iterator>, + TermsT: TermTuple<'query>, { type Item = (Uid, TermsT::Fields); fn next(&mut self) -> Option { - let entity_handle = self.iter.next()?; + let entity_handle = self.inner.next()?; Some(( entity_handle.uid(), - TermsT::get_fields(&entity_handle, self.world), + TermsT::get_fields( + self.world, + &SearchResult { + entity_handle, + traversal_results: self.inner.traversal_results().unwrap(), + }, + 0, + ), )) } } -pub trait TermFieldSource<'world, FieldAcc> +pub trait TermFieldSource<'query, FieldAcc> { type NewFieldAcc; fn collect_field( - entity_handle: &EntityHandle<'world>, - world: &'world World, + world: &'query World, + search_result: &SearchResult<'query, '_>, + term_metadata: TermMetadata, fields: FieldAcc, ) -> Self::NewFieldAcc; } @@ -513,11 +544,11 @@ macro_rules! term_field_source_new_field_acc { macro_rules! gen_term_tuple_impls { ($c: tt) => { seq!(I in 0..$c { - impl<'world, #(Term~I,)*> TermTuple<'world> for (#(Term~I,)*) + impl<'query, #(Term~I,)*> TermTuple<'query> for (#(Term~I,)*) where #( - Term~I: Term<'world> + TermFieldSource< - 'world, + Term~I: Term<'query> + TermFieldSource< + 'query, sub!(I - 1, term_field_source_new_field_acc), NewFieldAcc: Tuple >, @@ -527,24 +558,40 @@ macro_rules! gen_term_tuple_impls { #[allow(unused)] fn apply_terms_to_builder( - terms_builder: &mut TermsBuilder + terms_builder: &mut TermsBuilder, + term_level: u32, ) { #( - Term~I::apply_to_terms_builder(terms_builder); + Term~I::apply_to_terms_builder( + terms_builder, + TermMetadata { + level: term_level, + index: I + }, + ); )* } #[allow(unused)] fn get_fields( - entity_handle: &EntityHandle<'world>, - world: &'world World, + world: &'query World, + search_result: &SearchResult<'query, '_>, + term_level: u32, ) -> Self::Fields { let fields = (); #( - let fields = Term~I::collect_field(entity_handle, world, fields); + let fields = Term~I::collect_field( + world, + search_result, + TermMetadata { + level: term_level, + index: I + }, + fields + ); )* fields @@ -557,4 +604,3 @@ macro_rules! gen_term_tuple_impls { seq!(C in 0..17 { gen_term_tuple_impls!(C); }); - -- cgit v1.2.3-18-g5258