Struct dinotree_alg::BoundedDinoTree

pub struct BoundedDinoTree<'a, A: Axis, N: Node> { /* fields omitted */ }

Methods

impl<'_, A: Axis, N: Node> BoundedDinoTree<'_, A, N>

Important traits for Vec<u8>

impl Write for Vec<u8>

#[must_use] pub fn k_nearest_mut(
    &mut self,
    point: Vec2<N::Num>,
    num: usize,
    distance: impl Fn(Vec2<N::Num>, &Rect<N::Num>) -> N::Num
) -> Vec<KnearestResult<N::T>>

Examples

use dinotree_alg::prelude::*;
use axgeom::*;
let border = rect(0,100,0,100);
let mut bots = [rect(0,10,0,10),
                rect(2,5,2,5),
                rect(4,10,4,10)];
let mut bots_copy=bots.clone();
let mut tree = DinoTree::new(&mut bots);

let mut bounded_tree=tree.as_bounded(border);
let res = bounded_tree.k_nearest_mut(vec2(0,0),2,|a,b|b.distance_squared_to_point(a).unwrap_or(0));

assert_eq!(res.len(),2);
assert_eq!(res[0].bot.get(),&bots_copy[0]);
assert_eq!(res[1].bot.get(),&bots_copy[1]);

Important traits for Vec<u8>

impl Write for Vec<u8>

#[must_use] pub fn k_nearest_fine_mut(
    &mut self,
    point: Vec2<N::Num>,
    num: usize,
    knear: &mut impl Knearest<N = N::Num, T = N::T>
) -> Vec<KnearestResult<N::T>>

#[must_use] pub fn raycast_fine_mut(
    &mut self,
    ray: Ray<N::Num>,
    rtrait: &mut impl RayCast<N = N::Num, T = N::T>
) -> RayCastResult<N::T>

#[must_use] pub fn raycast_mut(
    &mut self,
    ray: Ray<N::Num>,
    rtrait: impl Fn(&Ray<N::Num>, &Rect<N::Num>) -> RayIntersectResult<N::Num>
) -> RayCastResult<N::T>

Methods from Deref<Target = DinoTree<A, N>>

pub fn find_collisions_mut_par(
    &mut self,
    func: impl Fn(PMut<N::T>, PMut<N::T>) + Send + Sync
)

Examples

use dinotree_alg::prelude::*;
let mut bots = [bbox(axgeom::rect(0,10,0,10),0u8),bbox(axgeom::rect(5,15,5,15),0u8)];
let mut tree = DinoTree::new(&mut bots);
tree.find_collisions_mut_par(|mut a,mut b|{
    *a.inner_mut()+=1;
    *b.inner_mut()+=1;
});

assert_eq!(bots[0].inner,1);
assert_eq!(bots[1].inner,1);

pub fn as_bounded(&mut self, rect: Rect<N::Num>) -> BoundedDinoTree<A, N>

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

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

Examples

use dinotree_alg::prelude::*;
let mut bots1 = [bbox(axgeom::rect(0,10,0,10),0u8)];
let mut bots2 = [bbox(axgeom::rect(5,15,5,15),0u8)];
let mut tree = DinoTree::new(&mut bots1);

tree.intersect_with_mut(&mut bots2,|mut a,mut b|{
    *a.inner_mut()+=1;
    *b.inner_mut()+=2;    
});

assert_eq!(bots1[0].inner,1);
assert_eq!(bots2[0].inner,2);

#[must_use] pub fn multi_rect(&mut self) -> MultiRectMut<A, N>

Examples

use dinotree_alg::prelude::*;
let mut bots1 = [bbox(axgeom::rect(0,10,0,10),0u8)];
let mut tree = DinoTree::new(&mut bots1);
let mut multi = tree.multi_rect();

multi.for_all_in_rect_mut(axgeom::rect(0,10,0,10),|a|{}).unwrap();
let res = multi.for_all_in_rect_mut(axgeom::rect(5,15,5,15),|a|{});
assert_eq!(res,Err(RectIntersectErr));

pub fn for_all_not_in_rect_mut(
    &mut self,
    rect: &Rect<N::Num>,
    func: impl FnMut(PMut<N::T>)
)

pub fn for_all_intersect_rect_mut(
    &mut self,
    rect: &Rect<N::Num>,
    func: impl FnMut(PMut<N::T>)
)

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

pub fn for_all_in_rect_mut(
    &mut self,
    rect: &Rect<N::Num>,
    func: impl FnMut(PMut<N::T>)
)

pub fn for_all_in_rect(&self, rect: &Rect<N::Num>, func: impl FnMut(&N::T))

pub fn find_collisions_mut(&mut self, func: impl FnMut(PMut<N::T>, PMut<N::T>))

Examples

use dinotree_alg::prelude::*;
let mut bots = [bbox(axgeom::rect(0,10,0,10),0u8),bbox(axgeom::rect(5,15,5,15),0u8)];
let mut tree = DinoTree::new(&mut bots);
tree.find_collisions_mut(|mut a,mut b|{
    *a.inner_mut()+=1;
    *b.inner_mut()+=1;
});

assert_eq!(bots[0].inner,1);
assert_eq!(bots[1].inner,1);

#[must_use] pub fn axis(&self) -> A

#[must_use] pub fn vistr_mut(&mut self) -> VistrMut<N>

#[must_use] pub fn vistr(&self) -> Vistr<N>

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

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

Trait Implementations

impl<'_, A: Axis, N: Node> Deref for BoundedDinoTree<'_, A, N>

type Target = DinoTree<A, N>

The resulting type after dereferencing.

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

Dereferences the value.

impl<'_, A: Axis, N: Node> DerefMut for BoundedDinoTree<'_, A, N>

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

Mutably dereferences the value.