Expand description
AABB struct.
Fields
min: Point3<f32>
Minimum coordinates
max: Point3<f32>
Maximum coordinates
Implementations
sourceimpl AABB
impl AABB
sourcepub fn empty() -> AABB
pub fn empty() -> AABB
Creates a new empty AABB
.
Examples
use bvh::aabb::AABB;
let aabb = AABB::empty();
let min = &aabb.min;
let max = &aabb.max;
// For any point
let x = rand::random();
let y = rand::random();
let z = rand::random();
// An empty AABB should not contain it
assert!(x < min.x && y < min.y && z < min.z);
assert!(max.x < x && max.y < y && max.z < z);
sourcepub fn contains(&self, p: &Point3<f32>) -> bool
pub fn contains(&self, p: &Point3<f32>) -> bool
Returns true if the Point3
is inside the AABB
.
Examples
use bvh::aabb::AABB;
use bvh::nalgebra::Point3;
let aabb = AABB::with_bounds(Point3::new(-1.0, -1.0, -1.0), Point3::new(1.0, 1.0, 1.0));
let point_inside = Point3::new(0.125, -0.25, 0.5);
let point_outside = Point3::new(1.0, -2.0, 4.0);
assert!(aabb.contains(&point_inside));
assert!(!aabb.contains(&point_outside));
sourcepub fn approx_contains_eps(&self, p: &Point3<f32>, epsilon: f32) -> bool
pub fn approx_contains_eps(&self, p: &Point3<f32>, epsilon: f32) -> bool
Returns true if the Point3
is approximately inside the AABB
with respect to some epsilon
.
Examples
use bvh::EPSILON;
use bvh::aabb::AABB;
use bvh::nalgebra::Point3;
let aabb = AABB::with_bounds(Point3::new(-1.0, -1.0, -1.0), Point3::new(1.0, 1.0, 1.0));
let point_barely_outside = Point3::new(1.000_000_1, -1.000_000_1, 1.000_000_001);
let point_outside = Point3::new(1.0, -2.0, 4.0);
assert!(aabb.approx_contains_eps(&point_barely_outside, EPSILON));
assert!(!aabb.approx_contains_eps(&point_outside, EPSILON));
sourcepub fn approx_contains_aabb_eps(&self, other: &AABB, epsilon: f32) -> bool
pub fn approx_contains_aabb_eps(&self, other: &AABB, epsilon: f32) -> bool
Returns true if the other
AABB
is approximately inside this AABB
with respect to some epsilon
.
Examples
use bvh::EPSILON;
use bvh::aabb::AABB;
use bvh::nalgebra::Point3;
let aabb = AABB::with_bounds(Point3::new(-1.0, -1.0, -1.0), Point3::new(1.0, 1.0, 1.0));
let point_barely_outside = Point3::new(1.000_000_1, 1.000_000_1, 1.000_000_1);
let center = aabb.center();
let inner_aabb = AABB::with_bounds(center, point_barely_outside);
assert!(aabb.approx_contains_aabb_eps(&inner_aabb, EPSILON));
sourcepub fn relative_eq(&self, other: &AABB, epsilon: f32) -> bool
pub fn relative_eq(&self, other: &AABB, epsilon: f32) -> bool
Returns true if the other
AABB
is approximately equal to this AABB
with respect to some epsilon
.
Examples
use bvh::EPSILON;
use bvh::aabb::AABB;
use bvh::nalgebra::Point3;
let aabb = AABB::with_bounds(Point3::new(-1.0, -1.0, -1.0), Point3::new(1.0, 1.0, 1.0));
let point_barely_outside_min = Point3::new(-1.000_000_1, -1.000_000_1, -1.000_000_1);
let point_barely_outside_max = Point3::new(1.000_000_1, 1.000_000_1, 1.000_000_1);
let other = AABB::with_bounds(point_barely_outside_min, point_barely_outside_max);
assert!(aabb.relative_eq(&other, EPSILON));
sourcepub fn join(&self, other: &AABB) -> AABB
pub fn join(&self, other: &AABB) -> AABB
Returns a new minimal AABB
which contains both this AABB
and other
.
The result is the convex hull of the both AABB
s.
Examples
use bvh::aabb::AABB;
use bvh::nalgebra::Point3;
let aabb1 = AABB::with_bounds(Point3::new(-101.0, 0.0, 0.0), Point3::new(-100.0, 1.0, 1.0));
let aabb2 = AABB::with_bounds(Point3::new(100.0, 0.0, 0.0), Point3::new(101.0, 1.0, 1.0));
let joint = aabb1.join(&aabb2);
let point_inside_aabb1 = Point3::new(-100.5, 0.5, 0.5);
let point_inside_aabb2 = Point3::new(100.5, 0.5, 0.5);
let point_inside_joint = Point3::new(0.0, 0.5, 0.5);
assert!(joint.contains(&point_inside_aabb1));
assert!(joint.contains(&point_inside_aabb2));
assert!(joint.contains(&point_inside_joint));
sourcepub fn join_mut(&mut self, other: &AABB)
pub fn join_mut(&mut self, other: &AABB)
Mutable version of AABB::join
.
Examples
use bvh::aabb::AABB;
use bvh::nalgebra::{Point3, Vector3};
let size = Vector3::new(1.0, 1.0, 1.0);
let aabb_pos = Point3::new(-101.0, 0.0, 0.0);
let mut aabb = AABB::with_bounds(aabb_pos, aabb_pos + size);
let other_pos = Point3::new(100.0, 0.0, 0.0);
let other = AABB::with_bounds(other_pos, other_pos + size);
let point_inside_aabb = aabb_pos + size / 2.0;
let point_inside_other = other_pos + size / 2.0;
let point_inside_joint = Point3::new(0.0, 0.0, 0.0) + size / 2.0;
aabb.join_mut(&other);
assert!(aabb.contains(&point_inside_aabb));
assert!(aabb.contains(&point_inside_other));
assert!(aabb.contains(&point_inside_joint));
sourcepub fn grow(&self, other: &Point3<f32>) -> AABB
pub fn grow(&self, other: &Point3<f32>) -> AABB
Returns a new minimal AABB
which contains both
this AABB
and the Point3
other
.
Examples
use bvh::aabb::AABB;
use bvh::nalgebra::Point3;
let point1 = Point3::new(0.0, 0.0, 0.0);
let point2 = Point3::new(1.0, 1.0, 1.0);
let point3 = Point3::new(2.0, 2.0, 2.0);
let aabb = AABB::empty();
assert!(!aabb.contains(&point1));
let aabb1 = aabb.grow(&point1);
assert!(aabb1.contains(&point1));
let aabb2 = aabb.grow(&point2);
assert!(aabb2.contains(&point2));
assert!(!aabb2.contains(&point3));
sourcepub fn grow_mut(&mut self, other: &Point3<f32>)
pub fn grow_mut(&mut self, other: &Point3<f32>)
Mutable version of AABB::grow
.
Examples
use bvh::aabb::AABB;
use bvh::nalgebra::Point3;
let point1 = Point3::new(0.0, 0.0, 0.0);
let point2 = Point3::new(1.0, 1.0, 1.0);
let point3 = Point3::new(2.0, 2.0, 2.0);
let mut aabb = AABB::empty();
assert!(!aabb.contains(&point1));
aabb.grow_mut(&point1);
assert!(aabb.contains(&point1));
assert!(!aabb.contains(&point2));
aabb.grow_mut(&point2);
assert!(aabb.contains(&point2));
assert!(!aabb.contains(&point3));
sourcepub fn join_bounded<T: Bounded>(&self, other: &T) -> AABB
pub fn join_bounded<T: Bounded>(&self, other: &T) -> AABB
Returns a new minimal AABB
which contains both this AABB
and the Bounded
other
.
Examples
use bvh::aabb::{AABB, Bounded};
use bvh::nalgebra::Point3;
struct Something;
impl Bounded for Something {
fn aabb(&self) -> AABB {
let point1 = Point3::new(0.0,0.0,0.0);
let point2 = Point3::new(1.0,1.0,1.0);
AABB::with_bounds(point1, point2)
}
}
let aabb = AABB::empty();
let something = Something;
let aabb1 = aabb.join_bounded(&something);
let center = something.aabb().center();
assert!(aabb1.contains(¢er));
sourcepub fn center(&self) -> Point3<f32>
pub fn center(&self) -> Point3<f32>
Returns the center Point3
of the AABB
.
Examples
use bvh::aabb::AABB;
use bvh::nalgebra::Point3;
let min = Point3::new(41.0,41.0,41.0);
let max = Point3::new(43.0,43.0,43.0);
let aabb = AABB::with_bounds(min, max);
let center = aabb.center();
assert!(center.x == 42.0 && center.y == 42.0 && center.z == 42.0);
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
An empty AABB
is an AABB
where the lower bound is greater than
the upper bound in at least one component
Examples
use bvh::aabb::AABB;
use bvh::nalgebra::Point3;
let empty_aabb = AABB::empty();
assert!(empty_aabb.is_empty());
let min = Point3::new(41.0,41.0,41.0);
let max = Point3::new(43.0,43.0,43.0);
let aabb = AABB::with_bounds(min, max);
assert!(!aabb.is_empty());
sourcepub fn surface_area(&self) -> f32
pub fn surface_area(&self) -> f32
sourcepub fn largest_axis(&self) -> Axis
pub fn largest_axis(&self) -> Axis
Returns the axis along which the AABB
is stretched the most.
Examples
use bvh::aabb::AABB;
use bvh::axis::Axis;
use bvh::nalgebra::Point3;
let min = Point3::new(-100.0,0.0,0.0);
let max = Point3::new(100.0,0.0,0.0);
let aabb = AABB::with_bounds(min, max);
let axis = aabb.largest_axis();
assert!(axis == Axis::X);
Trait Implementations
sourceimpl Bounded for AABB
impl Bounded for AABB
Implementation of Bounded
for AABB
.
Examples
use bvh::aabb::{AABB, Bounded};
use bvh::nalgebra::Point3;
let point_a = Point3::new(3.0,4.0,5.0);
let point_b = Point3::new(17.0,18.0,19.0);
let aabb = AABB::empty().grow(&point_a).grow(&point_b);
let aabb_aabb = aabb.aabb();
assert_eq!(aabb_aabb.min, aabb.min);
assert_eq!(aabb_aabb.max, aabb.max);
sourceimpl Index<usize> for AABB
impl Index<usize> for AABB
Make AABB
s indexable. aabb[0]
gives a reference to the minimum bound.
All other indices return a reference to the maximum bound.
Examples
use bvh::aabb::AABB;
use bvh::nalgebra::Point3;
let min = Point3::new(3.0,4.0,5.0);
let max = Point3::new(123.0,123.0,123.0);
let aabb = AABB::with_bounds(min, max);
assert_eq!(aabb[0], min);
assert_eq!(aabb[1], max);
impl Copy for AABB
Auto Trait Implementations
impl RefUnwindSafe for AABB
impl Send for AABB
impl Sync for AABB
impl Unpin for AABB
impl UnwindSafe for AABB
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
self
from the equivalent element of its
superset. Read morefn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
self
is actually part of its subset T
(and can be converted to it).unsafe fn to_subset_unchecked(&self) -> SS
unsafe fn to_subset_unchecked(&self) -> SS
self.to_subset
but without any property checks. Always succeeds.fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
self
to the equivalent element of its superset.