Struct Bounds3

pub struct Bounds3<T> {
    pub p_min: Point3<T>,
    pub p_max: Point3<T>,
}

Generic type for 3D bounding boxes.

Fields

p_min: Point3<T>

point representing the minimum x,y,z value of the bounds.

p_max: Point3<T>

point representing the maximum x,y,z value of the bounds.

Implementations

impl<T> Bounds3<T>

where T: Number,

pub fn inside_exclusive(&self, p: Point3<T>) -> bool

Determine if p inside self excluding upper-bounds.

Examples

use pbrt::core::geometry::Bounds3i;
use pbrt::core::geometry::Point3i;

let b = Bounds3i::from([[2, 2, 2], [4, 4, 4]]);
assert!(b.inside_exclusive(Point3i::from([2, 2, 2])));
assert!(!b.inside_exclusive(Point3i::from([4, 4, 4])));

Trait Implementations

impl<T: Clone> Clone for Bounds3<T>

fn clone(&self) -> Bounds3<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Bounds3<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for Bounds3<T>

fn default() -> Bounds3<T>

Returns the “default value” for a type.

impl<T> From<[[T; 3]; 2]> for Bounds3<T>

where T: Number,

fn from(ps: [[T; 3]; 2]) -> Self

Create Bounds3<T> from tuple of slices. It also ensures min/max are correct, regardless of how they’re arranged in the incoming slices.

Examples

use pbrt::core::geometry::Bounds3f;
use pbrt::core::geometry::Point3f;

let b = Bounds3f::from([[2., 3., 4.], [4., 5.,6.]]);
assert_eq!(
    b,
    Bounds3f {
        p_min: Point3f { x: 2., y: 3.,z:4. },
        p_max: Point3f { x: 4., y: 5.,z:6. }
    }
);

let b = Bounds3f::from([[5., 4., 1.], [3., 2.,3.]]);
assert_eq!(b, Bounds3f::from([[3., 2.,1.], [5., 4.,3.]]));

impl<T> From<[Point3<T>; 2]> for Bounds3<T>

where T: Number,

fn from(ps: [Point3<T>; 2]) -> Self

Create Bounds3<T> from slice of Point3<t>. It also ensures min/max are correct, regardless of how they’re arranged in the incoming Point3<t>.

Examples

use pbrt::core::geometry::Bounds3f;
use pbrt::core::geometry::Point3f;

let b = Bounds3f::from([Point3f::from([2., 3.,4.]), Point3f::from([4., 5.,6.])]);
assert_eq!(
    b,
    Bounds3f {
        p_min: Point3f { x: 2., y: 3. ,z:4.},
        p_max: Point3f { x: 4., y: 5.,z:6. }
    }
);

let b = Bounds3f::from([Point3f::from([5., 4.,1.]), Point3f::from([3., 2.,3.])]);
assert_eq!(b, Bounds3f::from([[3., 2.,1.], [5., 4.,3.]]));

impl<T: PartialEq> PartialEq for Bounds3<T>

fn eq(&self, other: &Bounds3<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Copy> Copy for Bounds3<T>

impl<T> StructuralPartialEq for Bounds3<T>