Planes and Culling Frustums

[ggadwa]

Any thoughts about adding in planes and culling frustums (or just frustums with the right functions.) I'm using nalgebra for a game I'm working on and planes + frustums are nice for optimizations, so others might desire them.

I basically made my own and if you think this is something useful, feel free to use my code if it's up to your standards, at least as a start. Otherwise, it's not hard to create, just something that could get wrapped into your lib and be one less piece of code I'm maintaining.

If you already have this and I somehow missed it, I apologize for the issue!

Plane:

`
use num_traits::real::Real;
use nalgebra::*;

pub struct Plane<T: Real> {
pub a: T,
pub b: T,
pub c: T,
pub d: T
}

impl<T: Real + std::fmt::Debug + 'static> Plane {
pub fn new(
a: T,
b: T,
c: T,
d: T
) -> Self {
Self {
a,
b,
c,
d
}
}

pub fn normalize(
    &mut self
) {
    let f = ((self.a * self.a) + (self.b * self.b) + (self.c * self.c)).sqrt();
    if f != num_traits::zero() {
        self.a = self.a / f;
        self.b = self.b / f;
        self.c = self.c / f;
        self.d = self.d / f;
    }
}

pub fn bound_box_outside_plane(
    &mut self,
    min: &Point3<T>,
    max: &Point3<T>
) -> bool {
    if (self.a * min.x) + (self.b * min.y) + (self.c * min.z) + self.d > num_traits::zero() {
        return true;
    }
	if (self.a * max.x) + (self.b * min.y) + (self.c * min.z) + self.d > num_traits::zero() {
        return true;
    }
	if (self.a * min.x) + (self.b * max.y) + (self.c * min.z) + self.d > num_traits::zero() {
        return true;
    }
	if (self.a * max.x) + (self.b * max.y) + (self.c * min.z) + self.d > num_traits::zero() {
        return true;
    }
	if (self.a * min.x) + (self.b * min.y) + (self.c * max.z) + self.d > num_traits::zero() {
        return true;
    }
	if (self.a * max.x) + (self.b * min.y) + (self.c * max.z) + self.d > num_traits::zero() {
        return true;
    }
	if (self.a * min.x) + (self.b * max.y) + (self.c * max.z) + self.d > num_traits::zero() {
        return true;
    }
	(self.a * max.x) + (self.b * max.y) + (self.c * max.z) + self.d > num_traits::zero()
}

}

impl<T: Real + std::fmt::Debug + 'static> Default for Plane {
fn default() -> Self {
Self {
a: num_traits::zero(),
b: num_traits::zero(),
c: num_traits::zero(),
d: num_traits::zero()
}
}
}
`

Culling Frustum:

`
use num_traits::real::Real;
use nalgebra::*;

use crate::game::view_plane::Plane;
pub struct CullingFrustum<T: Real> {
pub left: Plane,
pub right: Plane,
pub top: Plane,
pub bottom: Plane,
pub near: Plane,
pub far: Plane,
}

impl<T: Real + std::fmt::Debug + 'static> CullingFrustum {
pub fn new(
perspective_matrix: &Matrix4,
view_matrix: &Matrix4
) -> Self {
let mut clip_plane: [T; 16] = [num_traits::zero(); 16];

    clip_plane[0]=(view_matrix[(0,0)]*perspective_matrix[(0,0)])+(view_matrix[(1,0)]*perspective_matrix[(0,1)])+(view_matrix[(2,0)]*perspective_matrix[(0,2)])+(view_matrix[(3,0)]*perspective_matrix[(0,3)]);
    clip_plane[1]=(view_matrix[(0,0)]*perspective_matrix[(1,0)])+(view_matrix[(1,0)]*perspective_matrix[(1,1)])+(view_matrix[(2,0)]*perspective_matrix[(1,2)])+(view_matrix[(3,0)]*perspective_matrix[(1,3)]);
    clip_plane[2]=(view_matrix[(0,0)]*perspective_matrix[(2,0)])+(view_matrix[(1,0)]*perspective_matrix[(2,1)])+(view_matrix[(2,0)]*perspective_matrix[(2,2)])+(view_matrix[(3,0)]*perspective_matrix[(2,3)]);
    clip_plane[3]=(view_matrix[(0,0)]*perspective_matrix[(3,0)])+(view_matrix[(1,0)]*perspective_matrix[(3,1)])+(view_matrix[(2,0)]*perspective_matrix[(3,2)])+(view_matrix[(3,0)]*perspective_matrix[(3,3)]);

    clip_plane[4]=(view_matrix[(0,1)]*perspective_matrix[(0,0)])+(view_matrix[(1,1)]*perspective_matrix[(0,1)])+(view_matrix[(2,1)]*perspective_matrix[(0,2)])+(view_matrix[(3,1)]*perspective_matrix[(0,3)]);
    clip_plane[5]=(view_matrix[(0,1)]*perspective_matrix[(1,0)])+(view_matrix[(1,1)]*perspective_matrix[(1,1)])+(view_matrix[(2,1)]*perspective_matrix[(1,2)])+(view_matrix[(3,1)]*perspective_matrix[(1,3)]);
    clip_plane[6]=(view_matrix[(0,1)]*perspective_matrix[(2,0)])+(view_matrix[(1,1)]*perspective_matrix[(2,1)])+(view_matrix[(2,1)]*perspective_matrix[(2,2)])+(view_matrix[(3,1)]*perspective_matrix[(2,3)]);
    clip_plane[7]=(view_matrix[(0,1)]*perspective_matrix[(3,0)])+(view_matrix[(1,1)]*perspective_matrix[(3,1)])+(view_matrix[(2,1)]*perspective_matrix[(3,2)])+(view_matrix[(3,1)]*perspective_matrix[(3,3)]);

    clip_plane[8]=(view_matrix[(0,2)]*perspective_matrix[(0,0)])+(view_matrix[(1,2)]*perspective_matrix[(0,1)])+(view_matrix[(2,2)]*perspective_matrix[(0,2)])+(view_matrix[(3,2)]*perspective_matrix[(0,3)]);
    clip_plane[9]=(view_matrix[(0,2)]*perspective_matrix[(1,0)])+(view_matrix[(1,2)]*perspective_matrix[(1,1)])+(view_matrix[(2,2)]*perspective_matrix[(1,2)])+(view_matrix[(3,2)]*perspective_matrix[(1,3)]);
    clip_plane[10]=(view_matrix[(0,2)]*perspective_matrix[(2,0)])+(view_matrix[(1,2)]*perspective_matrix[(2,1)])+(view_matrix[(2,2)]*perspective_matrix[(2,2)])+(view_matrix[(3,2)]*perspective_matrix[(2,3)]);
    clip_plane[11]=(view_matrix[(0,2)]*perspective_matrix[(3,0)])+(view_matrix[(1,2)]*perspective_matrix[(3,1)])+(view_matrix[(2,2)]*perspective_matrix[(3,2)])+(view_matrix[(3,2)]*perspective_matrix[(3,3)]);

    clip_plane[12]=(view_matrix[(0,3)]*perspective_matrix[(0,0)])+(view_matrix[(1,3)]*perspective_matrix[(0,1)])+(view_matrix[(2,3)]*perspective_matrix[(0,2)])+(view_matrix[(3,3)]*perspective_matrix[(0,3)]);
    clip_plane[13]=(view_matrix[(0,3)]*perspective_matrix[(1,0)])+(view_matrix[(1,3)]*perspective_matrix[(1,1)])+(view_matrix[(2,3)]*perspective_matrix[(1,2)])+(view_matrix[(3,3)]*perspective_matrix[(1,3)]);
    clip_plane[14]=(view_matrix[(0,3)]*perspective_matrix[(2,0)])+(view_matrix[(1,3)]*perspective_matrix[(2,1)])+(view_matrix[(2,3)]*perspective_matrix[(2,2)])+(view_matrix[(3,3)]*perspective_matrix[(2,3)]);
    clip_plane[15]=(view_matrix[(0,3)]*perspective_matrix[(3,0)])+(view_matrix[(1,3)]*perspective_matrix[(3,1)])+(view_matrix[(2,3)]*perspective_matrix[(3,2)])+(view_matrix[(3,3)]*perspective_matrix[(3,3)]);

    // left plane
    let mut left: Plane<T> = Plane::new(
        clip_plane[3]+clip_plane[0],
        clip_plane[7]+clip_plane[4],
        clip_plane[11]+clip_plane[8],
        clip_plane[15]+clip_plane[12]
    );
    left.normalize();
    
    // right plane
    let mut right: Plane<T> = Plane::new(
        clip_plane[3]-clip_plane[0],
        clip_plane[7]-clip_plane[4],
        clip_plane[11]-clip_plane[8],
        clip_plane[15]-clip_plane[12]
    );
    right.normalize();
    
    // top plane
    let mut top: Plane<T> = Plane::new(
        clip_plane[3]-clip_plane[1],
        clip_plane[7]-clip_plane[5],
        clip_plane[11]-clip_plane[9],
        clip_plane[15]-clip_plane[13]
    );
    top.normalize();
    
    // bottom plane
    let mut bottom: Plane<T> = Plane::new(
        clip_plane[3]+clip_plane[1],
        clip_plane[7]+clip_plane[5],
        clip_plane[11]+clip_plane[9],
        clip_plane[15]+clip_plane[13]
    );
    bottom.normalize();
    
    // near plane
    let mut near: Plane<T> = Plane::new(
        clip_plane[3]+clip_plane[2],
        clip_plane[7]+clip_plane[6],
        clip_plane[11]+clip_plane[10],
        clip_plane[15]+clip_plane[14]
    );
    near.normalize();
    
    // far plane
    let mut far: Plane<T> = Plane::new(
        clip_plane[3]-clip_plane[2],
        clip_plane[7]-clip_plane[6],
        clip_plane[11]-clip_plane[10],
        clip_plane[15]-clip_plane[14]
    );
    far.normalize();

    Self {
        left,
        right,
        top,
        bottom,
        near,
        far
    }
}

pub fn bound_box_in_frustum(
    &mut self,
    min: &Point3<T>,
    max: &Point3<T>
) -> bool {
    // check if outside the plane, if it is,
    // then it's considered outside the bounds
    if !self.left.bound_box_outside_plane(min, max) {
        return false;
    }
    if !self.right.bound_box_outside_plane(min, max) {
        return false;
    }
    if !self.top.bound_box_outside_plane(min, max) {
        return false;
    }
    if !self.bottom.bound_box_outside_plane(min, max) {
        return false;
    }
    if !self.near.bound_box_outside_plane(min, max) {
        return false;
    }
    self.far.bound_box_outside_plane(min, max)
}

}

impl<T: Real + std::fmt::Debug + 'static> Default for CullingFrustum {
fn default() -> Self {
Self {
left: Plane::default(),
right: Plane::default(),
top: Plane::default(),
bottom: Plane::default(),
near: Plane::default(),
far: Plane::default(),
}
}
}
`

[tpdickso]

I think nalgebra's built-in geometric types tend to be constrained to more algebraic types that are related to vectors/matrices -- however, I think the HalfSpace structure from nalgebra's sister library parry could be what you're looking for! It has a focus specifically on collision detection and so could be useful for your use-case. I don't think parry currently has a structure for a 6-plane frustum, though.