Struct Obb3

pub struct Obb3<S> { /* private fields */ }

3D oriented bounding box

Implementations

impl<S> Obb3<S>

pub fn numcast<T>(self) -> Option<Obb3<T>>

where S: NumCast, T: NumCast,

impl<S> Obb3<S>

where S: Ring,

pub fn new( center: Point3<S>, half_extent_x: Positive<S>, half_extent_y: Positive<S>, half_extent_z: Positive<S>, orientation: Angles3<S>, ) -> Obb3<S>

Construct a new OBB

pub fn containing_points(_points: &[Point3<S>]) -> Option<Obb3<S>>

where S: Real,

Construct the minimum OBB containing the convex hull of a given set of points

pub fn containing(_hull: &Hull3<S>) -> Option<Obb3<S>>

where S: Real,

Construct the minimum OBB containing the given convex hull of points

pub fn center(&self) -> Point3<S>

pub fn half_extent_x(&self) -> Positive<S>

pub fn half_extent_y(&self) -> Positive<S>

pub fn half_extent_z(&self) -> Positive<S>

pub fn orientation(&self) -> Angles3<S>

pub fn dimensions(&self) -> Vec3<S>

where S: Field,

pub fn extents(&self) -> Vec3<S>

where S: Field,

pub fn width(&self) -> Positive<S>

where S: Field,

X dimension

pub fn depth(&self) -> Positive<S>

where S: Field,

Y dimension

pub fn height(&self) -> Positive<S>

where S: Field,

Z dimension

pub fn volume(&self) -> Positive<S>

where S: Field,

pub fn corners(&self) -> [Point3<S>; 8]

where S: Real + Real + MaybeSerDes,

pub fn contains(&self, _point: &Point2<S>) -> bool

where S: Real + Real + MaybeSerDes,

Check if point is contained by the bounding box

pub fn dilate(self, amount: S) -> Obb3<S>

where S: Field,

Increase or decrease each dimension by the given amount.

Panics if any dimension would become zero or negative:

let x = Obb3::new (
  Point3::origin(),
  Positive::unchecked (0.5),
  Positive::unchecked (0.5),
  Positive::unchecked (0.5),
  Angles3::zero()
);
let y = x.dilate (-1.0); // panic!

Trait Implementations

impl<S> Clone for Obb3<S>

where S: Clone,

fn clone(&self) -> Obb3<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Obb3<S>

where S: Debug,

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

Formats the value using the given formatter.

impl<'de, S> Deserialize<'de> for Obb3<S>

where S: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Obb3<S>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S> From<Aabb3<S>> for Obb3<S>

where S: Real,

fn from(aabb: Aabb3<S>) -> Obb3<S>

Panics if AABB has a zero dimension:

let x = Aabb3::with_minmax (
  [0.0, 0.0, 0.0].into(),
  [0.0, 1.0, 1.0].into()
);
let y = Obb3::from (x); // panic!

impl<S> PartialEq for Obb3<S>

where S: PartialEq,

fn eq(&self, other: &Obb3<S>) -> 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<S> Serialize for Obb3<S>

where S: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S> Copy for Obb3<S>

where S: Copy,

impl<S> StructuralPartialEq for Obb3<S>