Struct broccoli::query::QueryBuilder

pub struct QueryBuilder<'a, 'node: 'a, T: Aabb> { /* fields omitted */ }

Builder for a query on a DinoTree.

Implementations

impl<'a, 'node: 'a, T: Aabb> QueryBuilder<'a, 'node, T>

pub fn new(vistr: VistrMut<'a, Node<'node, T>>) -> QueryBuilder<'a, 'node, T>

Create the builder.

pub fn with_switch_height(self, height: usize) -> Self

Choose a custom height at which to switch from parallel to sequential. If you end up building sequentially, this option is ignored.

pub fn query_seq(self, func: impl FnMut(PMut<'_, T>, PMut<'_, T>))

Perform the query sequentially.

pub fn query_with_splitter_seq<S: Splitter>(
    self,
    func: impl FnMut(PMut<'_, T>, PMut<'_, T>),
    splitter: S
) -> S

Perform the query sequentially with splitter functions getting called at every level of recursion.

pub fn query_par_ext<S: Splitter + Send + Sync, C: CollisionHandler<T = T> + Splitter + Send + Sync>(
    self,
    joiner: impl Joinable,
    sweeper: C,
    splitter: S
) -> (C, S) where
    T: Send + Sync,
    T::Num: Send + Sync, 

An extended version of find_colliding_pairs. where the user can supply callbacks to when new worker tasks are spawned and joined by rayon. Allows the user to potentially collect some aspect of every aabb collision in parallel.

sweeper : The splitter div/add functions will be called every time a new parallel recurse is started. splitter: The splitter div/add will be called at every level of recursion.

Examples

 use broccoli::{par::RayonJoin,rect,bbox};
 let mut bots = [bbox(rect(0,10,0,10),0u8),bbox(rect(5,15,5,15),1u8)];
 let mut tree = broccoli::new(&mut bots);

 let mut handler=broccoli::helper::QueryParClosure::new(
     &tree,
     Vec::new(),
     |_|(Vec::new(),Vec::new()),        //Start a new thread
     |a,mut b,mut c|{a.append(&mut b);a.append(&mut c)}, //Combine two threads
     |v,a,b|v.push((*a.unpack_inner(),*b.unpack_inner())), //Handle a collision
 );

 let (handler,_)=tree.new_colfind_builder().query_par_ext(
     RayonJoin,
     handler,
     broccoli::build::SplitterEmpty
 );

 let intersections=handler.acc;

 assert_eq!(intersections.len(),1);

pub fn query_par(
    self,
    joiner: impl Joinable,
    func: impl Fn(PMut<'_, T>, PMut<'_, T>) + Clone + Send + Sync
) where
    T: Send + Sync,
    T::Num: Send + Sync, 

Perform the query in parallel, switching to sequential as specified by the QueryBuilder::with_switch_height()