Struct broccoli::container::TreeRefInd

pub struct TreeRefInd<'a, N: Num, T> { /* fields omitted */ }

A less general tree that providess collect functions and also derefs to a Tree.

TreeRefInd assumes there is a layer of indirection where all the pointers point to the same slice. It uses this assumption to provide collect functions that allow storing query results that can then be iterated through multiple times quickly.

Implementations

impl<'a, N: Num + Send + Sync, T: Send + Sync> TreeRefInd<'a, N, T>

pub fn collect_colliding_pairs_par<D: Send + Sync>(
    &mut self,
    func: impl Fn(&mut T, &mut T) -> Option<D> + Send + Sync + Copy
) -> CollidingPairsPar<T, D>

The parallel version of TreeRefInd::collect_colliding_pairs that instead returns a CollidingPairsPar.

Examples

 let mut aabbs = [
     broccoli::bbox(broccoli::rect(0isize, 10, 0, 10), 0),
     broccoli::bbox(broccoli::rect(15, 20, 15, 20), 1),
     broccoli::bbox(broccoli::rect(5, 15, 5, 15), 2),
 ];

 let mut tree = broccoli::container::TreeRefInd::new_par(&mut aabbs,|a|{
    a.rect
 });

 //Find all colliding aabbs only once.
 let mut pairs=tree.collect_colliding_pairs_par(|a, b| {
    a.inner += 1;
    b.inner += 1;
    Some(())
 });

 //Iterate over the pairs multiple times
 for _ in 0..3{
     //mutate every colliding pair.
     pairs.for_every_pair_mut_par(&mut aabbs,|a,b,()|{
         a.inner+=1;
         b.inner+=1;
     })
 }

impl<'a, N: Num, T> TreeRefInd<'a, N, T>

pub fn collect_all<D: Send + Sync>(
    &mut self,
    func: impl FnMut(&Rect<N>, &mut T) -> Option<D>
) -> FilteredElements<T, D>

Collect all elements based off of a predicate and return a FilteredElements.

Examples

 let mut aabbs = [
    broccoli::bbox(broccoli::rect(0isize, 10, 0, 10), 0),
    broccoli::bbox(broccoli::rect(15, 20, 15, 20), 1),
    broccoli::bbox(broccoli::rect(5, 15, 5, 15), 2),
 ];

 let mut tree = broccoli::container::TreeRefInd::new(&mut aabbs,|a|{
     a.rect
 });

 //Find a group of elements only once.
 let mut pairs=tree.collect_all(|_,b| {
    if b.inner % 2 ==0{
        Some(())
    }else{
        None
    }
 });

 //Iterate over that group multiple times
 for _ in 0..3{
     //mutate every colliding pair.
     for (a,()) in pairs.get_mut(&mut aabbs){
         a.inner+=1;
     }
 }

impl<'a, N: Num, T> TreeRefInd<'a, N, T>

pub fn collect_colliding_pairs<D: Send + Sync>(
    &mut self,
    func: impl FnMut(&mut T, &mut T) -> Option<D> + Send + Sync
) -> CollidingPairs<T, D>

Find all colliding pairs based on a predicate and return a CollidingPairs.

Examples

 let mut aabbs = [
     broccoli::bbox(broccoli::rect(0isize, 10, 0, 10), 0),
     broccoli::bbox(broccoli::rect(15, 20, 15, 20), 1),
     broccoli::bbox(broccoli::rect(5, 15, 5, 15), 2),
 ];

 let mut tree = broccoli::container::TreeRefInd::new(&mut aabbs,|a|{
    a.rect
 });

 //Find all colliding aabbs only once.
 let mut pairs=tree.collect_colliding_pairs(|a, b| {
    a.inner += 1;
    b.inner += 1;
    Some(())
 });

 //Iterate over the pairs multiple times
 for _ in 0..3{
     //mutate every colliding pair.
     pairs.for_every_pair_mut(&mut aabbs,|a,b,()|{
         a.inner+=1;
         b.inner+=1;
     })
 }

impl<'a, N: Num, T> TreeRefInd<'a, N, T>

pub fn new(
    arr: &'a mut [T],
    func: impl FnMut(&mut T) -> Rect<N>
) -> TreeRefInd<'a, N, T>

impl<'a, N: Num + Send + Sync, T: Send + Sync> TreeRefInd<'a, N, T>

pub fn new_par(
    arr: &'a mut [T],
    func: impl FnMut(&mut T) -> Rect<N>
) -> TreeRefInd<'a, N, T>

impl<'a, N: Num, T> TreeRefInd<'a, N, T>

pub fn as_tree_ref_mut(&mut self) -> &mut TreeRef<'a, BBox<N, &'a mut T>>

Explicitly DerefMut.

pub fn get_elements(&self) -> &[T]

use broccoli::{prelude::*,bbox,rect};
let mut k=[4];
let mut b=broccoli::container::TreeRefInd::new(&mut k,|&mut d|rect(d,d,d,d));
b.find_colliding_pairs_mut(|a,b|{});
assert_eq!(b.get_elements()[0],4);
b.find_colliding_pairs_mut(|a,b|{});

pub fn get_elements_mut(&mut self) -> &'a mut [T]

use broccoli::{prelude::*,bbox,rect};
let mut k=[0];
let mut b=broccoli::container::TreeRefInd::new(&mut k,|&mut d|rect(d,d,d,d));
b.find_colliding_pairs_mut(|a,b|{});
b.get_elements_mut()[0]=5;
b.find_colliding_pairs_mut(|a,b|{});

Methods from Deref<Target = TreeRef<'a, BBox<N, &'a mut T>>>

pub fn get_bbox_elements(&self) -> &[T]

use broccoli::{prelude::*,bbox,rect};
let mut k=[bbox(rect(0,10,0,10),8)];
let mut b=broccoli::container::TreeRef::new(&mut k);
b.find_colliding_pairs_mut(|a,b|{});
assert_eq!(b.get_bbox_elements()[0].inner,8);
b.find_colliding_pairs_mut(|a,b|{});

pub fn get_bbox_elements_mut(&mut self) -> PMut<'a, [T]>

use broccoli::{prelude::*,bbox,rect};
let mut k=[bbox(rect(0,10,0,10),8)];
let mut b=broccoli::container::TreeRef::new(&mut k);
b.find_colliding_pairs_mut(|a,b|{});
*b.get_bbox_elements_mut().get_index_mut(0).unpack_inner()=5;
b.find_colliding_pairs_mut(|a,b|{});

Trait Implementations

impl<'a, N: Num + 'a, T> Deref for TreeRefInd<'a, N, T>

type Target = TreeRef<'a, BBox<N, &'a mut T>>

The resulting type after dereferencing.

pub fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, N: Num + 'a, T> DerefMut for TreeRefInd<'a, N, T>

pub fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.