Adding helper methods

Author: aevyrie

crates/bevy_geometry/src/lib.rs

@@ -1,18 +1,12 @@
 use bevy_math::*;
 use bevy_reflect::Reflect;
-//use bevy_transform::components::GlobalTransform;
 use std::error::Error;
 use std::fmt;
 
 pub trait Primitive3d {
-    /*
-    /// Returns true if this primitive is on the outside (normal direction) of the supplied
-    fn outside_plane(
-        &self,
-        primitive_transform: GlobalTransform,
-        plane: Plane,
-        plane_transform: GlobalTransform,
-    ) -> bool;*/
+    /// Returns true if this primitive is entirely on the outside (in the normal direction) of the
+    /// supplied plane.
+    fn outside_plane(&self, plane: Plane) -> bool;
 }
 
 #[derive(Debug, Clone)]
@@ -25,7 +19,10 @@ impl fmt::Display for PrimitiveError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             PrimitiveError::MinGreaterThanMax => {
-                write!(f, "AxisAlignedBox minimums must be smaller than maximums")
+                write!(
+                    f,
+                    "AxisAlignedBox minimums must be smaller or equal to the maximums"
+                )
             }
             PrimitiveError::NonPositiveExtents => {
                 write!(f, "AxisAlignedBox extents must be greater than zero")
@@ -36,76 +33,214 @@ impl fmt::Display for PrimitiveError {
 
 #[derive(Copy, Clone, PartialEq, Debug, Reflect)]
 pub struct Sphere {
-    pub origin: Vec3,
-    pub radius: f32,
+    origin: Vec3,
+    radius: f32,
+}
+
+impl Sphere {
+    /// Get a reference to the sphere's origin.
+    pub fn origin(&self) -> &Vec3 {
+        &self.origin
+    }
+
+    /// Get a reference to the sphere's radius.
+    pub fn radius(&self) -> &f32 {
+        &self.radius
+    }
+
+    /// Set the sphere's origin.
+    pub fn set_origin(&mut self, origin: Vec3) {
+        self.origin = origin;
+    }
+
+    /// Set the sphere's radius.
+    pub fn set_radius(&mut self, radius: f32) {
+        self.radius = radius;
+    }
+}
+impl Primitive3d for Sphere {
+    /// Use the sphere's position and radius to determin eif it is entirely on the outside of the
+    /// the supplied plane.
+    fn outside_plane(&self, plane: Plane) -> bool {
+        plane.distance_to_point(&self.origin) > self.radius
+    }
 }
-impl Primitive3d for Sphere {}
 
 /// An oriented box, unlike an axis aligned box, can be rotated and is not constrained to match the
 /// orientation of the coordinate system it is defined in. Internally, this is represented as an
 /// axis aligned box with some rotation ([Quat]) applied.
 #[derive(Copy, Clone, PartialEq, Debug, Reflect)]
 pub struct OrientedBox {
-    pub aab: AxisAlignedBox,
-    pub orientation: Quat,
+    aab: AxisAlignedBox,
+    transform: Mat4,
+}
+impl Primitive3d for OrientedBox {
+    fn outside_plane(&self, plane: Plane) -> bool {
+        for vertex in self.vertices().iter() {
+            if plane.distance_to_point(vertex) <= 0.0 {
+                return false;
+            }
+        }
+        true
+    }
+}
+impl OrientedBox {
+    /// An ordered list of the vertices that form the 8 corners of the [AxisAlignedBox].
+    /// ```none
+    ///     (5)------(1)
+    ///      | \      | \
+    ///      |  (4)------(0)
+    ///      |   |    |   |
+    ///     (7)--|---(3)  |
+    ///        \ |      \ |
+    ///         (6)------(2)
+    /// ```
+    pub fn vertices(&self) -> [Vec3; 8] {
+        let mut vertices = [Vec3::ZERO; 8];
+        let aab_vertices = self.aab.vertices();
+        for i in 0..vertices.len() {
+            vertices[i] = self.transform.project_point3(aab_vertices[i])
+        }
+        vertices
+    }
+
+    /// Set the oriented box's aab.
+    pub fn set_aab(&mut self, aab: AxisAlignedBox) {
+        self.aab = aab;
+    }
+
+    /// Set the oriented box's transform.
+    pub fn set_transform(&mut self, transform: Mat4) {
+        self.transform = transform;
+    }
+    pub fn fast_aabb(&self) -> AxisAlignedBox {
+        let vertices = self.vertices();
+        let mut max = Vec3::splat(f32::MIN);
+        let mut min = Vec3::splat(f32::MAX);
+        for vertex in vertices.iter() {
+            max = vertex.max(max);
+            min = vertex.min(min);
+        }
+        // Unwrap is okay here because min < max
+        AxisAlignedBox::from_min_max(min, max).unwrap()
+    }
 }
-impl Primitive3d for OrientedBox {}
 
 /// An axis aligned box is a box whose axes lie in the x/y/z directions of the coordinate system
 /// the box is defined in.
 #[derive(Copy, Clone, PartialEq, Debug, Reflect)]
 pub struct AxisAlignedBox {
-    minimums: Vec3,
-    maximums: Vec3,
+    min: Vec3,
+    max: Vec3,
+}
+impl Primitive3d for AxisAlignedBox {
+    fn outside_plane(&self, plane: Plane) -> bool {
+        for vertex in self.vertices().iter() {
+            if plane.distance_to_point(vertex) <= 0.0 {
+                return false;
+            }
+        }
+        true
+    }
 }
-impl Primitive3d for AxisAlignedBox {}
 impl AxisAlignedBox {
-    pub fn from_min_max(minimums: Vec3, maximums: Vec3) -> Result<AxisAlignedBox, PrimitiveError> {
-        if (maximums - minimums).min_element() > 0.0 {
-            Ok(AxisAlignedBox { minimums, maximums })
+    /// An ordered list of the vertices that form the 8 corners of the [AxisAlignedBox].
+    /// ```none
+    ///          (5)------(1)               Y
+    ///           | \      | \              |
+    ///           |  (4)------(0) MAX       o---X
+    ///           |   |    |   |             \
+    ///      MIN (7)--|---(3)  |              Z
+    ///             \ |      \ |
+    ///              (6)------(2)
+    /// ```
+    pub fn vertices(&self) -> [Vec3; 8] {
+        let min = self.min;
+        let max = self.max;
+        [
+            Vec3::new(max.x, max.y, max.z),
+            Vec3::new(max.x, max.y, min.z),
+            Vec3::new(max.x, min.y, max.z),
+            Vec3::new(max.x, min.y, min.z),
+            Vec3::new(min.x, max.y, max.z),
+            Vec3::new(min.x, max.y, min.z),
+            Vec3::new(min.x, min.y, max.z),
+            Vec3::new(min.x, min.y, min.z),
+        ]
+    }
+    /// Construct an [AxisAlignedBox] given the coordinates of the minimum and maximum corners.
+    pub fn from_min_max(min: Vec3, max: Vec3) -> Result<AxisAlignedBox, PrimitiveError> {
+        if (max - min).min_element() >= 0.0 {
+            Ok(AxisAlignedBox { min, max })
         } else {
             Err(PrimitiveError::MinGreaterThanMax)
         }
     }
+    /// Construct an [AxisALignedBox] from the origin at the minimum corner, and the extents - the
+    /// dimensions of the box in each axis.
     pub fn from_extents_origin(
         extents: Vec3,
         origin: Vec3,
     ) -> Result<AxisAlignedBox, PrimitiveError> {
         if extents.min_element() > 0.0 {
             Ok(AxisAlignedBox {
-                minimums: origin,
-                maximums: extents + origin,
+                min: origin,
+                max: extents + origin,
             })
         } else {
             Err(PrimitiveError::NonPositiveExtents)
         }
     }
+    /// Computes the AAB that
+    pub fn from_points(points: Vec<Vec3>) -> AxisAlignedBox {
+        let mut max = Vec3::splat(f32::MIN);
+        let mut min = Vec3::splat(f32::MAX);
+        for &point in points.iter() {
+            max = point.max(max);
+            min = point.min(min);
+        }
+        // Unwrap is okay here because min < max
+        AxisAlignedBox::from_min_max(min, max).unwrap()
+    }
 }
 
-/// A frustum is a truncated pyramid that is used to represent the "volume" of world space that is
+/// A frustum is a truncated pyramid that is used to represent the volume of world space that is
 /// visible to the camera.
 #[derive(Copy, Clone, PartialEq, Debug, Reflect)]
 #[reflect_value(PartialEq)]
 pub struct Frustum {
     planes: [Plane; 6],
+    vertices: [Vec3; 8],
+}
+impl Primitive3d for Frustum {
+    fn outside_plane(&self, plane: Plane) -> bool {
+        for vertex in self.vertices().iter() {
+            if plane.distance_to_point(vertex) <= 0.0 {
+                return false;
+            }
+        }
+        true
+    }
 }
-impl Primitive3d for Frustum {}
 impl Frustum {
-    pub fn from_camera_properties(
-        &self,
-        camera_position: Mat4,
-        projection_matrix: Mat4,
-    ) -> Frustum {
+    fn compute_vertices(camera_position: Mat4, projection_matrix: Mat4) -> [Vec3; 8] {
         let ndc_to_world: Mat4 = camera_position * projection_matrix.inverse();
-        // Near/Far, Top/Bottom, Left/Right
-        let nbl_world = ndc_to_world.project_point3(Vec3::new(-1.0, -1.0, -1.0));
-        let nbr_world = ndc_to_world.project_point3(Vec3::new(1.0, -1.0, -1.0));
-        let ntl_world = ndc_to_world.project_point3(Vec3::new(-1.0, 1.0, -1.0));
-        let fbl_world = ndc_to_world.project_point3(Vec3::new(-1.0, -1.0, 1.0));
-        let ftr_world = ndc_to_world.project_point3(Vec3::new(1.0, 1.0, 1.0));
-        let ftl_world = ndc_to_world.project_point3(Vec3::new(-1.0, 1.0, 1.0));
-        let fbr_world = ndc_to_world.project_point3(Vec3::new(1.0, -1.0, 1.0));
-        let ntr_world = ndc_to_world.project_point3(Vec3::new(1.0, 1.0, -1.0));
+        [
+            ndc_to_world.project_point3(Vec3::new(-1.0, -1.0, -1.0)),
+            ndc_to_world.project_point3(Vec3::new(1.0, -1.0, -1.0)),
+            ndc_to_world.project_point3(Vec3::new(-1.0, 1.0, -1.0)),
+            ndc_to_world.project_point3(Vec3::new(1.0, 1.0, -1.0)),
+            ndc_to_world.project_point3(Vec3::new(-1.0, -1.0, 1.0)),
+            ndc_to_world.project_point3(Vec3::new(1.0, -1.0, 1.0)),
+            ndc_to_world.project_point3(Vec3::new(-1.0, 1.0, 1.0)),
+            ndc_to_world.project_point3(Vec3::new(1.0, 1.0, 1.0)),
+        ]
+    }
+
+    pub fn from_camera_properties(camera_position: Mat4, projection_matrix: Mat4) -> Frustum {
+        let vertices = Frustum::compute_vertices(camera_position, projection_matrix);
+        let [nbl_world, nbr_world, ntl_world, ntr_world, fbl_world, fbr_world, ftl_world, ftr_world] =
+            vertices;
 
         let near_normal = (nbr_world - nbl_world)
             .cross(ntl_world - nbl_world)
@@ -150,9 +285,30 @@ impl Frustum {
             point: ftr_world,
             normal: far_normal,
         };
-        Frustum {
-            planes: [left, right, top, bottom, near, far],
-        }
+
+        let planes = [left, right, top, bottom, near, far];
+
+        Frustum { planes, vertices }
+    }
+
+    /// Get a reference to the frustum's vertices. These are given as an ordered list of vertices
+    /// that form the 8 corners of a [Frustum].
+    /// ```none
+    ///     (6)--------------(7)        
+    ///      | \    TOP     / |    
+    ///      |  (2)------(3)  |
+    ///      | L |        | R |  
+    ///     (4)  |  NEAR  |  (5)
+    ///        \ |        | /
+    ///         (0)------(1)
+    /// ```
+    pub fn vertices(&self) -> &[Vec3; 8] {
+        &self.vertices
+    }
+
+    /// Get a reference to the frustum's planes.
+    pub fn planes(&self) -> &[Plane; 6] {
+        &self.planes
     }
 }
 
@@ -162,7 +318,11 @@ pub struct Plane {
     point: Vec3,
     normal: Vec3,
 }
-impl Primitive3d for Plane {}
+impl Primitive3d for Plane {
+    fn outside_plane(&self, plane: Plane) -> bool {
+        self.normal == plane.normal && self.distance_to_point(plane.point()) > 0.0
+    }
+}
 impl Plane {
     /// Generate a plane from three points that lie on the plane.
     pub fn from_points(points: [Vec3; 3]) -> Plane {
@@ -180,4 +340,20 @@ impl Plane {
             normal: normal.normalize(),
         }
     }
+    /// Returns the nearest distance from the supplied point to this plane. Positive values are in
+    /// the direction of the plane's normal (outside), negative values are opposite the direction
+    /// of the planes normal (inside).
+    pub fn distance_to_point(&self, point: &Vec3) -> f32 {
+        self.normal.dot(*point) + -self.normal.dot(self.point)
+    }
+
+    /// Get a reference to the plane's point.
+    pub fn point(&self) -> &Vec3 {
+        &self.point
+    }
+
+    /// Get a reference to the plane's normal.
+    pub fn normal(&self) -> &Vec3 {
+        &self.normal
+    }
 }

tools/publish.sh

@@ -3,6 +3,7 @@ crates=(
     bevy_utils
     bevy_derive
     bevy_math
+    bevy_geometry
     bevy_tasks
     bevy_ecs/macros
     bevy_ecs
@@ -16,7 +17,6 @@ crates=(
     bevy_core
     bevy_diagnostic
     bevy_transform
-    bevy_geometry
     bevy_window
     bevy_render
     bevy_input