Struct broccoli::Tree

#[repr(transparent)]pub struct Tree<'a, A: Axis, T: Aabb> { /* fields omitted */ }

The data structure this crate revoles around.

Implementations

impl<'a, A: Axis, T: Aabb> Tree<'a, A, T>

pub fn with_axis(axis: A, bots: &'a mut [T]) -> Tree<'a, A, T>

Create a Tree using a specified axis.

Examples

 let mut bots = [axgeom::rect(0,10,0,10)];
 let tree = broccoli::Tree::with_axis(axgeom::XAXIS,&mut bots);

pub fn with_axis_par(axis: A, bots: &'a mut [T]) -> Tree<'a, A, T> where
    T: Send + Sync,
    T::Num: Send + Sync, 

Create a Tree using a specified axis in parallel.

Examples

 let mut bots = [axgeom::rect(0,10,0,10)];
 let tree = broccoli::Tree::with_axis_par(axgeom::XAXIS,&mut bots);

#[must_use]pub fn get_height(&self) -> usize

Examples

 use broccoli::analyze;
 const NUM_ELEMENT:usize=400;
 let mut bots = [axgeom::rect(0,10,0,10);NUM_ELEMENT];
 let mut tree = broccoli::new(&mut bots);

 assert_eq!(tree.get_height(),analyze::TreePreBuilder::new(NUM_ELEMENT).get_height());

#[must_use]pub fn num_nodes(&self) -> usize

Examples

 use broccoli::analyze;
 let mut bots = [axgeom::rect(0,10,0,10)];
 let mut tree = broccoli::new(&mut bots);

 assert_eq!(tree.num_nodes(),analyze::TreePreBuilder::new(1).num_nodes());

#[must_use]pub fn get_nodes(&self) -> &[Node<'a, T>]

Examples

 use broccoli::analyze;
 let mut bots = [axgeom::rect(0,10,0,10)];
 let mut tree = broccoli::new(&mut bots);

 assert_eq!(tree.get_nodes()[0].range[0], axgeom::rect(0,10,0,10));

#[must_use]pub fn get_nodes_mut(&mut self) -> PMut<'_, [Node<'a, T>]>

Examples

 use broccoli::analyze;
 let mut bots = [axgeom::rect(0,10,0,10)];
 let mut tree = broccoli::new(&mut bots);

 assert_eq!(tree.get_nodes_mut().get_index_mut(0).range[0], axgeom::rect(0,10,0,10));

Trait Implementations

impl<'a, A: Axis, T: Aabb> NaiveCheck<'a, Tree<'a, A, T>> for TreeRef<'a, A, T>

type A = A

type T = T

type Num = T::Num

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

pub fn assert_for_all_not_in_rect_mut(&mut self, rect: &Rect<Self::Num>)

pub fn assert_for_all_intersect_rect_mut(&mut self, rect: &Rect<Self::Num>)

pub fn assert_for_all_in_rect_mut(&mut self, rect: &Rect<Self::Num>)

pub fn assert_colliding_pairs_mut(&mut self)

pub fn assert_raycast_mut<'b, Acc>(
    &'b mut self,
    ray: Ray<Self::Num>,
    acc: &mut Acc,
    broad: impl FnMut(&mut Acc, &Ray<Self::Num>, &Rect<Self::Num>) -> CastResult<Self::Num>,
    fine: impl FnMut(&mut Acc, &Ray<Self::Num>, &Self::T) -> CastResult<Self::Num>,
    border: Rect<Self::Num>
) where
    'a: 'b,
    Self::Num: Debug, 

pub fn assert_k_nearest_mut<Acc>(
    &mut self,
    point: Vec2<Self::Num>,
    num: usize,
    acc: &mut Acc,
    broad: impl FnMut(&mut Acc, Vec2<Self::Num>, &Rect<Self::Num>) -> Self::Num,
    fine: impl FnMut(&mut Acc, Vec2<Self::Num>, &Self::T) -> Self::Num,
    border: Rect<Self::Num>
)

#[must_use]pub fn assert_tree_invariants(&self) -> bool

impl<'a, A: Axis, T: Aabb> Queries<'a> for Tree<'a, A, T>

type A = A

type T = T

type Num = T::Num

pub fn axis(&self) -> Self::A

Examples

pub fn vistr_mut(&mut self) -> VistrMut<'_, Node<'a, T>>

Examples

pub fn vistr(&self) -> Vistr<'_, Node<'a, T>>

Examples

pub fn find_colliding_pairs_mut(
    &mut self,
    func: impl FnMut(PMut<'_, Self::T>, PMut<'_, Self::T>)
)

Find all aabb intersections and return a PMut of it. Unlike the regular find_colliding_pairs_mut, this allows the user to access a read only reference of the AABB.

pub fn find_colliding_pairs_mut_par(
    &mut self,
    func: impl Fn(PMut<'_, Self::T>, PMut<'_, Self::T>) + Send + Sync + Clone
) where
    Self::T: Send + Sync,
    Self::Num: Send + Sync, 

The parallel version of Queries::find_colliding_pairs_mut.

pub fn new_colfind_builder<'c>(
    &'c mut self
) -> QueryBuilder<'c, 'a, Self::A, Self::T>

For analysis, allows the user to query with custom settings

pub fn for_all_intersect_rect<'b>(
    &'b self,
    rect: &Rect<Self::Num>,
    func: impl FnMut(&'b Self::T)
) where
    'a: 'b, 

Examples

pub fn for_all_intersect_rect_mut<'b>(
    &'b mut self,
    rect: &Rect<Self::Num>,
    func: impl FnMut(PMut<'b, Self::T>)
) where
    'a: 'b, 

Examples

pub fn for_all_in_rect<'b>(
    &'b self,
    rect: &Rect<Self::Num>,
    func: impl FnMut(&'b Self::T)
) where
    'a: 'b, 

Examples

pub fn for_all_in_rect_mut<'b>(
    &'b mut self,
    rect: &Rect<Self::Num>,
    func: impl FnMut(PMut<'b, Self::T>)
) where
    'a: 'b, 

Examples

pub fn for_all_not_in_rect_mut<'b>(
    &'b mut self,
    rect: &Rect<Self::Num>,
    func: impl FnMut(PMut<'b, Self::T>)
) where
    'a: 'b, 

Examples

#[must_use]pub fn multi_rect<'c>(&'c mut self) -> MultiRectMut<'c, 'a, Self::A, Self::T>

If we have two non intersecting rectangles, it is safe to return to the user two sets of mutable references of the bots strictly inside each rectangle since it is impossible for a bot to belong to both sets.

#[must_use]pub fn raycast_mut<'b, Acc>(
    &'b mut self,
    ray: Ray<Self::Num>,
    acc: &mut Acc,
    broad: impl FnMut(&mut Acc, &Ray<Self::Num>, &Rect<Self::Num>) -> CastResult<Self::Num>,
    fine: impl FnMut(&mut Acc, &Ray<Self::Num>, &Self::T) -> CastResult<Self::Num>,
    border: Rect<Self::Num>
) -> CastResult<(Vec<PMut<'b, Self::T>>, Self::Num)> where
    'a: 'b, 

Find the elements that are hit by a ray.

pub fn raycast_trait_mut<'b, Acc, R: RayCast<T = Self::T, N = Self::Num>>(
    &'b mut self,
    ray: Ray<Self::Num>,
    rtrait: R,
    border: Rect<Self::Num>
) -> CastResult<(Vec<PMut<'b, Self::T>>, Self::Num)> where
    'a: 'b, 

Companion function to Queries::raycast_mut() for cases where the use wants to use the trait instead of closures.

#[must_use]pub fn k_nearest_mut<'b, Acc>(
    &'b mut self,
    point: Vec2<Self::Num>,
    num: usize,
    acc: &mut Acc,
    broad: impl FnMut(&mut Acc, Vec2<Self::Num>, &Rect<Self::Num>) -> Self::Num,
    fine: impl FnMut(&mut Acc, Vec2<Self::Num>, &Self::T) -> Self::Num,
    border: Rect<Self::Num>
) -> KResult<'_, Self::T> where
    'a: 'b, 

Find the closest num elements to the specified point. The user provides two functions:

#[must_use]pub fn k_nearest_trait_mut<'b, Acc, K: Knearest<T = Self::T, N = Self::Num>>(
    &'b mut self,
    point: Vec2<Self::Num>,
    num: usize,
    ktrait: K,
    border: Rect<Self::Num>
) -> KResult<'_, Self::T> where
    'a: 'b, 

Companion function to Queries::k_nearest_mut() for cases where the use wants to use the trait instead of closures.

pub fn intersect_with_mut<X: Aabb<Num = Self::Num>>(
    &mut self,
    other: &mut [X],
    func: impl Fn(PMut<'_, Self::T>, PMut<'_, X>)
)

Find collisions between elements in this tree, with the specified slice of elements.

pub fn draw_divider(
    &self,
    drawer: &mut impl DividerDrawer<N = Self::Num>,
    rect: &Rect<Self::Num>
)

Examples

pub fn nbody_mut<X: NodeMassTrait<Num = Self::Num, Item = Self::T> + Send + Sync>(
    &mut self,
    ncontext: X,
    rect: Rect<Self::Num>
) where
    X::No: Send,
    Self::T: Send + Sync,
    Self::Num: Send + Sync, 

Experimental. See broccoli demo

pub fn nbody_mut_par<X: NodeMassTrait<Num = Self::Num, Item = Self::T> + Sync + Send>(
    &mut self,
    ncontext: X,
    rect: Rect<Self::Num>
) where
    X::No: Send,
    Self::T: Send + Sync,
    Self::Num: Send + Sync, 

Experimental. See broccoli demo