molgfx-math 0.3.5

glam-based math foundation: cameras, projections, bounds, splines, transport frames.
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
109
110
111
112
113
114
115
116
117
118
119
120

//! Allocation-reusing spatial queries over a finished hierarchy.

use super::Bvh;
use crate::{Aabb, Vec3};

impl Bvh {
    /// Root bounds, or the empty bound for an empty hierarchy.
    #[must_use]
    #[inline]
    pub fn bounds(&self) -> Aabb {
        self.nodes.first().map_or(Aabb::EMPTY, |node| node.bounds())
    }

    /// Appends source indices whose bounds overlap a ray. Both vectors are
    /// cleared and reused; results follow deterministic hierarchy order.
    pub fn ray_candidates(
        &self,
        origin: Vec3,
        direction: Vec3,
        traversal: &mut Vec<u32>,
        output: &mut Vec<u32>,
    ) {
        traversal.clear();
        output.clear();
        if self.nodes.is_empty() || !origin.is_finite() || !direction.is_finite() {
            return;
        }
        traversal.push(0);
        let inverse_direction = direction.recip();
        while let Some(index) = traversal.pop() {
            let Some(node) = self.nodes.get(index as usize).copied() else {
                continue;
            };
            if node
                .bounds()
                .ray_intersect(origin, inverse_direction)
                .is_none()
            {
                continue;
            }
            self.append_node_candidates(node, traversal, output);
        }
    }

    /// Appends source indices whose primitive bounds overlap a query sphere.
    /// Both caller vectors retain their allocations for reuse.
    pub fn sphere_candidates(
        &self,
        center: Vec3,
        radius: f32,
        traversal: &mut Vec<u32>,
        output: &mut Vec<u32>,
    ) {
        traversal.clear();
        output.clear();
        if self.nodes.is_empty() || !center.is_finite() || !radius.is_finite() || radius < 0.0 {
            return;
        }
        traversal.push(0);
        let radius_sq = radius * radius;
        while let Some(index) = traversal.pop() {
            let Some(node) = self.nodes.get(index as usize).copied() else {
                continue;
            };
            if point_box_distance_squared(center, node.bounds()) > radius_sq {
                continue;
            }
            self.append_node_candidates(node, traversal, output);
        }
    }

    /// Appends source indices whose primitive bounds overlap an axis-aligned
    /// query box. Both caller vectors retain their storage.
    pub fn aabb_candidates(&self, query: Aabb, traversal: &mut Vec<u32>, output: &mut Vec<u32>) {
        traversal.clear();
        output.clear();
        if self.nodes.is_empty()
            || query.is_empty()
            || !query.min.is_finite()
            || !query.max.is_finite()
        {
            return;
        }
        traversal.push(0);
        while let Some(index) = traversal.pop() {
            let Some(node) = self.nodes.get(index as usize).copied() else {
                continue;
            };
            if !node.bounds().overlaps(&query) {
                continue;
            }
            self.append_node_candidates(node, traversal, output);
        }
    }

    #[inline]
    fn append_node_candidates(
        &self,
        node: super::BvhNode,
        traversal: &mut Vec<u32>,
        output: &mut Vec<u32>,
    ) {
        if let Some(range) = node.primitive_range() {
            let start = range.start as usize;
            let end = range.end as usize;
            if let Some(indices) = self.primitive_indices.get(start..end) {
                output.extend_from_slice(indices);
            }
        } else if let Some((left, right)) = node.children() {
            traversal.push(right);
            traversal.push(left);
        }
    }
}

#[inline]
pub(super) fn point_box_distance_squared(point: Vec3, bound: Aabb) -> f32 {
    let outside = (bound.min - point).max(Vec3::ZERO) + (point - bound.max).max(Vec3::ZERO);
    outside.length_squared()
}