Struct broccoli::Tree

pub struct Tree<'a, T: Aabb> { /* private fields */ }

A broccoli Tree.

Implementations

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

pub fn assert_tree_invariants(&self) where
    T::Num: Debug, 

panics if a broken broccoli tree invariant is detected. For debugging purposes only.

impl<T: Aabb> Tree<'_, T>

pub fn find_colliding_pairs_from_args<S: Splitter>(
    &mut self,
    args: QueryArgs<'_, S>,
    func: impl FnMut(AabbPin<&mut T>, AabbPin<&mut T>)
)

pub fn par_find_colliding_pairs_from_args<S: Splitter, F>(
    &mut self,
    args: QueryArgs<'_, S>,
    func: F
) where
    F: FnMut(AabbPin<&mut T>, AabbPin<&mut T>),
    F: Send + Clone,
    S: Send,
    T: Send,
    T::Num: Send, 

pub fn par_find_colliding_pairs_acc<Acc, FS, FA, F>(
    &mut self,
    acc: Acc,
    split_func: FS,
    add_func: FA,
    func: F
) -> Acc where
    FS: FnMut(&mut Acc) -> Acc + Clone + Send,
    FA: FnMut(&mut Acc, Acc) + Clone + Send,
    F: FnMut(&mut Acc, AabbPin<&mut T>, AabbPin<&mut T>) + Clone + Send,
    Acc: Send,
    T: Send,
    T::Num: Send, 

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

pub fn find_colliding_pairs(
    &mut self,
    func: impl FnMut(AabbPin<&mut T>, AabbPin<&mut T>)
)

pub fn par_find_colliding_pairs<F: FnMut(AabbPin<&mut T>, AabbPin<&mut T>)>(
    &mut self,
    func: F
) where
    T: Send,
    T::Num: Send,
    F: Send + Clone, 

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

pub fn draw_divider(
    &self,
    line: impl FnMut(AxisDyn, &Node<'_, T>, &Rect<T::Num>, usize),
    rect: Rect<T::Num>
)

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

pub fn find_knearest(
    &mut self,
    point: Vec2<T::Num>,
    num: usize,
    ktrait: impl Knearest<T>
) -> KResult<'_, T>

pub fn find_knearest_closure(
    &mut self,
    point: Vec2<T::Num>,
    num: usize,
    broad: impl FnMut(Vec2<T::Num>, AabbPin<&mut T>) -> Option<T::Num>,
    fine: impl FnMut(Vec2<T::Num>, AabbPin<&mut T>) -> T::Num,
    xline: impl FnMut(Vec2<T::Num>, T::Num) -> T::Num,
    yline: impl FnMut(Vec2<T::Num>, T::Num) -> T::Num
) -> KResult<'_, T>

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

pub fn cast_ray_closure(
    &mut self,
    ray: Ray<T::Num>,
    broad: impl FnMut(&Ray<T::Num>, AabbPin<&mut T>) -> Option<CastResult<T::Num>>,
    fine: impl FnMut(&Ray<T::Num>, AabbPin<&mut T>) -> CastResult<T::Num>,
    xline: impl FnMut(&Ray<T::Num>, T::Num) -> CastResult<T::Num>,
    yline: impl FnMut(&Ray<T::Num>, T::Num) -> CastResult<T::Num>
) -> CastResult<CastAnswer<'_, T>>

pub fn cast_ray<R: RayCast<T>>(
    &mut self,
    ray: Ray<T::Num>,
    rtrait: R
) -> CastResult<CastAnswer<'_, T>>

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

pub fn find_all_not_in_rect<'b, K: Aabb<Num = T::Num>>(
    &'b mut self,
    rect: AabbPin<&mut K>,
    closure: impl FnMut(AabbPin<&mut K>, AabbPin<&'b mut T>)
)

pub fn find_all_in_rect<'b, K: Aabb<Num = T::Num>>(
    &'b mut self,
    rect: AabbPin<&mut K>,
    closure: impl FnMut(AabbPin<&mut K>, AabbPin<&'b mut T>)
)

pub fn find_all_intersect_rect<'b, K: Aabb<Num = T::Num>>(
    &'b mut self,
    rect: AabbPin<&mut K>,
    closure: impl FnMut(AabbPin<&mut K>, AabbPin<&'b mut T>)
)

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

pub fn find_colliding_pairs_with<X: Aabb<Num = T::Num>>(
    &mut self,
    other: &mut Tree<'_, X>,
    func: impl FnMut(AabbPin<&mut T>, AabbPin<&mut X>)
)

pub fn find_colliding_pairs_with_iter<'x, X: Aabb<Num = T::Num> + 'x>(
    &mut self,
    other: impl Iterator<Item = AabbPin<&'x mut X>>,
    func: impl FnMut(AabbPin<&mut T>, AabbPin<&mut X>)
)

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

pub fn handle_nbody<N: Nbody<T = T>>(&mut self, no: &mut N)

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

pub fn is_degenerate(&self) -> bool

If the top 25% of tree levels has more elements than the bottom 75%, consider the tree not good for querying without a considerable jump in computation cost.

If worst case n*n time is unacceptable for your usecase, consider calling this after tree construction. If the tree is degenerate, consider just handling a subset of all colliding pairs by using the colliding pair building blocks in queries::colfind::build

impl<'a, T: Aabb + 'a> Tree<'a, T>

pub fn from_build_args<'b, P: Splitter>(args: BuildArgs<'a, 'b, T, P>) -> Self

pub fn par_from_build_args<'b, P: Splitter>(
    args: BuildArgs<'a, 'b, T, P>
) -> Self where
    T: Send,
    T::Num: Send,
    P: Send, 

pub fn new(bots: &'a mut [T]) -> Self

pub fn par_new(bots: &'a mut [T]) -> Self where
    T: Send,
    T::Num: Send, 

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

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

pub fn num_levels(&self) -> usize

pub fn num_nodes(&self) -> usize

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

pub fn get_nodes_mut(&mut self) -> AabbPin<&mut [Node<'a, T>]>