Struct splashsurf_lib::AxisAlignedBoundingBox

pub struct AxisAlignedBoundingBox<R: Real, const D: usize> { /* fields omitted */ }

Type representing an axis aligned bounding box in arbitrary dimensions

Implementations

impl<R, const D: usize> AxisAlignedBoundingBox<R, D> where
    R: Real,
    SVector<R, D>: ThreadSafe, 

pub fn par_from_points(points: &[SVector<R, D>]) -> Self

Constructs the smallest AABB fitting around all the given points, parallel version

impl<R, const D: usize> AxisAlignedBoundingBox<R, D> where
    R: Real, 

pub fn zeros() -> Self

Constructs a degenerate AABB with min and max set to zero

pub fn new(min: SVector<R, D>, max: SVector<R, D>) -> Self

Constructs an AABB with the given min and max bounding points

pub fn from_point(point: SVector<R, D>) -> Self

Constructs a degenerate AABB with zero extents centered at the given point

pub fn from_points(points: &[SVector<R, D>]) -> Self

Constructs the smallest AABB fitting around all the given points

pub fn try_convert<T>(&self) -> Option<AxisAlignedBoundingBox<T, D>> where
    T: Real, 

Tries to convert the AABB from one real type to another real type, returns None if conversion fails

pub fn min(&self) -> &SVector<R, D>

Returns the min coordinate of the bounding box

pub fn max(&self) -> &SVector<R, D>

Returns the max coordinate of the bounding box

pub fn is_consistent(&self) -> bool

Returns whether the AABB is consistent, i.e. aabb.min()[i] <= aabb.max()[i] for all i

pub fn is_degenerate(&self) -> bool

Returns whether the AABB is degenerate in any dimension, i.e. aabb.min()[i] == aabb.max()[i] for any i

pub fn extents(&self) -> SVector<R, D>

Returns the extents of the bounding box (vector connecting min and max point of the box)

pub fn min_extent(&self) -> R

Returns the smallest scalar extent of the AABB over all of its dimensions

pub fn max_extent(&self) -> R

Returns the largest scalar extent of the AABB over all of its dimensions

pub fn centroid(&self) -> SVector<R, D>

Returns the geometric centroid of the AABB (mean of the corner points)

pub fn contains_point(&self, point: &SVector<R, D>) -> bool

Checks if the given point is inside of the AABB, the AABB is considered to be half-open to its max coordinate

pub fn translate(&mut self, vector: &SVector<R, D>)

Translates the AABB by the given vector

pub fn center_at_origin(&mut self)

Translates the AABB to center it at the coordinate origin (moves the centroid to the coordinate origin)

pub fn scale_uniformly(&mut self, scaling: R)

Multiplies a uniform, local scaling to the AABB (i.e. multiplying its extents as if it was centered at the origin)

pub fn join(&mut self, other: &Self)

Enlarges this AABB to the smallest AABB enclosing both itself and another AABB

pub fn join_with_point(&mut self, point: &SVector<R, D>)

Enlarges this AABB to the smallest AABB enclosing both itself and another point

pub fn grow_uniformly(&mut self, margin: R)

Grows this AABB uniformly in all directions by the given scalar margin (i.e. adding the margin to min/max extents)

pub fn enclosing_cube(&self) -> Self

Returns the smallest cubical AABB with the same center that encloses this AABB

Trait Implementations

impl<R: Clone + Real, const D: usize> Clone for AxisAlignedBoundingBox<R, D>

fn clone(&self) -> AxisAlignedBoundingBox<R, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R, const D: usize> Debug for AxisAlignedBoundingBox<R, D> where
    R: Real, 

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

Formats the value using the given formatter.

impl<R: PartialEq + Real, const D: usize> PartialEq<AxisAlignedBoundingBox<R, D>> for AxisAlignedBoundingBox<R, D>

fn eq(&self, other: &AxisAlignedBoundingBox<R, D>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &AxisAlignedBoundingBox<R, D>) -> bool

This method tests for !=.

impl<R: Eq + Real, const D: usize> Eq for AxisAlignedBoundingBox<R, D>

impl<R: Real, const D: usize> StructuralEq for AxisAlignedBoundingBox<R, D>

impl<R: Real, const D: usize> StructuralPartialEq for AxisAlignedBoundingBox<R, D>