eightfold 0.1.0

3D space partitioning library
Documentation 
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

//! Additional [Octant] implementation for spatial trees

use parry3d::bounding_volume::AABB;

use crate::Octant;

use super::{error::Error, WorldPoint};

impl Octant {
    /// Find the Octant of a point `p` relative to another point `c`.
    pub fn from_center(c: &WorldPoint, p: &WorldPoint) -> Self {
        Self::new(p.x > c.x, p.y > c.y, p.z > c.z)
    }

    /// Find the Octant of a point `p` within an AABB `bb`.
    pub fn from_aabb<'err>(bb: &AABB, p: &'err WorldPoint) -> Result<Self, Error<'err>> {
        if !bb.contains_local_point(p) {
            return Err(Error::PointOutOfBounds(p));
        }
        Ok(Self::from_center(&bb.center(), p))
    }

    /// Construct an [AABB] such that `bb` is an octant of the result
    pub fn sup_aabb(self, bb: &AABB) -> AABB {
        use parry3d::math::Point as P;
        let n = &bb.mins;
        let x = &bb.maxs;
        let v = x - n;
        match self.0 {
            0 => AABB {
                mins: *n,
                maxs: x + v,
            },
            1 => AABB {
                mins: P::new(n.x, n.y, n.z - v.z),
                maxs: P::new(x.x + v.x, x.y + v.y, x.z),
            },
            2 => AABB {
                mins: P::new(n.x, n.y - v.y, n.z),
                maxs: P::new(x.x + v.x, x.y, x.z + v.z),
            },
            3 => AABB {
                mins: P::new(n.x, n.y - v.y, n.z - v.z),
                maxs: P::new(x.x + v.x, x.y, x.z),
            },
            4 => AABB {
                mins: P::new(n.x - v.x, n.y, n.z),
                maxs: P::new(x.x, x.y + v.y, x.z + v.z),
            },
            5 => AABB {
                mins: P::new(n.x - v.x, n.y, n.z - v.z),
                maxs: P::new(x.x, x.y + v.y, x.z),
            },
            6 => AABB {
                mins: P::new(n.x - v.x, n.y - v.y, n.z),
                maxs: P::new(x.x, x.y, x.z + v.z),
            },
            7 => AABB {
                mins: n - v,
                maxs: *x,
            },
            _ => unreachable!(),
        }
    }

    /// Construct an [AABB] by taking an octant from an existing [AABB].
    pub fn sub_aabb(self, bb: &AABB) -> AABB {
        use parry3d::math::Point as P;
        let c = bb.center();
        let n = &bb.mins;
        let x = &bb.maxs;
        match self.0 {
            0 => AABB {
                mins: *n, // ---
                maxs: c,
            },
            1 => AABB {
                mins: P::new(n.x, n.y, c.z), // --z
                maxs: P::new(c.x, c.y, x.z),
            },
            2 => AABB {
                mins: P::new(n.x, c.y, n.z), // -y-
                maxs: P::new(c.x, x.y, c.z),
            },
            3 => AABB {
                mins: P::new(n.x, c.y, c.z), // -yz
                maxs: P::new(c.x, x.y, x.z),
            },
            4 => AABB {
                mins: P::new(c.x, n.y, n.z), // x--
                maxs: P::new(x.x, c.y, c.z),
            },
            5 => AABB {
                mins: P::new(c.x, n.y, c.z), // x-z
                maxs: P::new(x.x, c.y, x.z),
            },
            6 => AABB {
                mins: P::new(c.x, c.y, n.z), // xy-
                maxs: P::new(x.x, x.y, c.z),
            },
            7 => AABB {
                mins: c, // xyz
                maxs: *x,
            },
            _ => unreachable!(),
        }
    }
}