1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use crate::inner_prelude::*;


/*
///Equivalent to: `&mut (Rect<N>,T)`
#[repr(transparent)]
#[derive(Debug)]
pub struct BBoxIndirect<'a, T> {
    pub inner: &'a mut T,
}
impl<'a, T> BBoxIndirect<'a, T> {
    pub fn new(inner: &'a mut T) -> Self {
        BBoxIndirect { inner }
    }
}

unsafe impl<'a, T: Aabb> Aabb for BBoxIndirect<'a, T> {
    type Num = T::Num;
    #[inline(always)]
    fn get(&self) -> &Rect<Self::Num> {
        self.inner.get()
    }
}
impl<'a, T: HasInner> HasInner for BBoxIndirect<'a, T> {
    type Inner = T::Inner;

    #[inline(always)]
    fn get_inner(&self) -> (&Rect<T::Num>, &Self::Inner) {
        self.inner.get_inner()
    }

    #[inline(always)]
    fn get_inner_mut(&mut self) -> (&Rect<T::Num>, &mut Self::Inner) {
        self.inner.get_inner_mut()
    }
}
*/



///Shorthand constructor of `BBox`
pub fn bbox<N, T>(rect: axgeom::Rect<N>, inner: T) -> BBox<N, T> {
    BBox::new(rect, inner)
}


///A bounding box container object that implements Aabb and HasInner.
///Note that `&mut BBox<N,T>` also implements Aabb and HasInner.
///
///Using this one struct the user can construct the following types for bboxes to be inserted into the dinotree:
///
///* `BBox<N,T>`  (direct)
///* `&mut BBox<N,T>` (indirect)
///* `BBox<N,&mut T>` (rect direct, T indirect) (best performnace)
///* `BBox<N,*mut T>` (used internally by `DinoTreeOwned`)
///
///
///
///
#[derive(Debug, Copy, Clone)]
#[repr(C)]
pub struct BBox<N, T> {
    pub rect: axgeom::Rect<N>,
    pub inner: T,
}

impl<N, T> BBox<N, T> {
    #[inline(always)]
    pub fn new(rect: axgeom::Rect<N>, inner: T) -> BBox<N, T> {
        BBox { rect, inner }
    }
}

unsafe impl<N: Num, T> Aabb for &mut BBox<N, T> {
    type Num = N;
    #[inline(always)]
    fn get(&self) -> &Rect<Self::Num> {
        &self.rect
    }
}
impl<N: Num, T> HasInner for &mut BBox<N, T> {
    type Inner = T;

    #[inline(always)]
    fn get_inner(&self) -> (&Rect<N>, &Self::Inner) {
        (&self.rect, &self.inner)
    }

    #[inline(always)]
    fn get_inner_mut(&mut self) -> (&Rect<N>, &mut Self::Inner) {
        (&self.rect, &mut self.inner)
    }
}

unsafe impl<N: Num, T> Aabb for BBox<N, T> {
    type Num = N;
    #[inline(always)]
    fn get(&self) -> &Rect<Self::Num> {
        &self.rect
    }
}
impl<N: Num, T> HasInner for BBox<N, T> {
    type Inner = T;

    #[inline(always)]
    fn get_inner(&self) -> (&Rect<N>, &Self::Inner) {
        (&self.rect, &self.inner)
    }

    #[inline(always)]
    fn get_inner_mut(&mut self) -> (&Rect<N>, &mut Self::Inner) {
        (&self.rect, &mut self.inner)
    }
}