algebrix 0.1.0

Vectors, matrices, quaternions, and geometry for game engines; column vectors, optional SIMD.
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
121
122
123
124
125
126

//! View frustum: 6 planes from a projection matrix. Use [`from_projection`](Frustum::from_projection);
//! then [`contains_point`](Frustum::contains_point), [`contains_sphere`](Frustum::contains_sphere), [`contains_aabb`](Frustum::contains_aabb) for culling.
//!
//! # Example
//!
//! ```rust
//! use algebrix::{Frustum, Mat4, Vec3};
//!
//! let proj = Mat4::perspective_lh(
//!     std::f32::consts::FRAC_PI_4,
//!     16.0 / 9.0,
//!     0.1,
//!     100.0,
//! );
//! let frustum = Frustum::from_projection(proj);
//! let origin = Vec3::ZERO;
//! let inside = frustum.contains_point(origin);
//! let sphere_inside = frustum.contains_sphere(Vec3::new(0.0, 0.0, -1.0), 0.5);
//! ```

use crate::{Mat4, Vec3};
use super::Plane;

/// View frustum: six planes (left, right, bottom, top, near, far) from a projection matrix.
///
/// Use [`from_projection`](Frustum::from_projection) with a view-projection matrix; then
/// [`contains_point`](Frustum::contains_point), [`contains_sphere`](Frustum::contains_sphere), or [`contains_aabb`](Frustum::contains_aabb) for culling.
#[derive(Debug, Clone, Copy)]
pub struct Frustum {
    pub planes: [Plane; 6],
}

impl Frustum {
    /// Build the six frustum planes from a projection matrix (perspective or orthographic). Plane order: left, right, bottom, top, near, far.
    #[inline]
    pub fn from_projection(projection: Mat4) -> Self {
        let m = projection.as_ref();
        
        let left = Plane::from_normal_d(
            Vec3::new(m[3] + m[0], m[7] + m[4], m[11] + m[8]).normalize(),
            m[15] + m[12],
        ).normalize();

        let right = Plane::from_normal_d(
            Vec3::new(m[3] - m[0], m[7] - m[4], m[11] - m[8]).normalize(),
            m[15] - m[12],
        ).normalize();

        let bottom = Plane::from_normal_d(
            Vec3::new(m[3] + m[1], m[7] + m[5], m[11] + m[9]).normalize(),
            m[15] + m[13],
        ).normalize();

        let top = Plane::from_normal_d(
            Vec3::new(m[3] - m[1], m[7] - m[5], m[11] - m[9]).normalize(),
            m[15] - m[13],
        ).normalize();

        let near = Plane::from_normal_d(
            Vec3::new(m[3] + m[2], m[7] + m[6], m[11] + m[10]).normalize(),
            m[15] + m[14],
        ).normalize();

        let far = Plane::from_normal_d(
            Vec3::new(m[3] - m[2], m[7] - m[6], m[11] - m[10]).normalize(),
            m[15] - m[14],
        ).normalize();

        Self {
            planes: [left, right, bottom, top, near, far],
        }
    }

    /// True if the point is inside all six frustum planes.
    #[inline]
    pub fn contains_point(&self, point: Vec3) -> bool {
        self.planes.iter().all(|plane| plane.distance_to_point(point) >= 0.0)
    }

    /// True if the sphere (center, radius) is inside or intersects all six planes.
    #[inline]
    pub fn contains_sphere(&self, center: Vec3, radius: f32) -> bool {
        self.planes.iter().all(|plane| plane.distance_to_point(center) >= -radius)
    }

    /// True if the AABB intersects the frustum (at least one corner in front of each plane).
    #[inline]
    pub fn contains_aabb(&self, aabb: &super::Aabb3) -> bool {
        for plane in &self.planes {
            let corners = aabb.corners();
            let mut all_behind = true;
            for corner in &corners {
                if plane.distance_to_point(*corner) >= 0.0 {
                    all_behind = false;
                    break;
                }
            }
            if all_behind {
                return false;
            }
        }
        true
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use super::super::aabb::Aabb3;

    #[test]
    fn test_frustum_creation() {
        let proj = Mat4::perspective_rh(std::f32::consts::FRAC_PI_4, 1.0, 0.1, 100.0);
        let frustum = Frustum::from_projection(proj);
        assert_eq!(frustum.planes.len(), 6);
    }

    #[test]
    fn test_frustum_contains_aabb() {
        let proj = Mat4::orthographic_rh(-1.0, 1.0, -1.0, 1.0, 0.1, 100.0);
        let frustum = Frustum::from_projection(proj);
        let aabb = Aabb3::new(Vec3::new(-0.5, -0.5, -1.0), Vec3::new(0.5, 0.5, -0.5));
        let result = frustum.contains_aabb(&aabb);
        assert!(result);
    }
}