Struct Rect3 

pub struct Rect3<P, E> {
    pub x: P,
    pub y: P,
    pub z: P,
    pub w: E,
    pub h: E,
    pub d: E,
}

A Rect extended to 3D.

This would have been named Box, but it was “taken” by the standard library already.

You should probably use Aabb because it is less confusing. See also Rect for a short discussion on the topic.

Fields

x: P

X position of the bottom-left-near corner.

y: P

Y position of the bottom-left-near corner.

z: P

Z position of the bottom-left-near corner.

w: E

Width.

h: E

Height, with Y axis going upwards.

d: E

Depth, with Z axis going forwards.

Implementations

impl<P, E> Rect3<P, E>

pub fn new(x: P, y: P, z: P, w: E, h: E, d: E) -> Rect3<P, E>

Creates a new rectangle from position elements and extent elements.

pub fn position(self) -> Vec3<P>

Gets this rectangle’s position.

pub fn set_position(&mut self, p: Vec3<P>)

Sets this rectangle’s position.

pub fn extent(self) -> Extent3<E>

Gets this rectangle’s extent (size).

pub fn set_extent(&mut self, e: Extent3<E>)

Sets this rectangle’s extent (size).

pub fn position_extent(self) -> (Vec3<P>, Extent3<E>)

Gets this rectangle’s position and extent (size).

pub fn map<DP, DE, PF, EF>(self, pf: PF, ef: EF) -> Rect3<DP, DE>

where PF: FnMut(P) -> DP, EF: FnMut(E) -> DE,

Returns this rectangle, converted with the given closures (one for position elements, the other for extent elements).

pub fn as_<DP, DE>(self) -> Rect3<DP, DE>

where P: AsPrimitive<DP>, DP: 'static + Copy, E: AsPrimitive<DE>, DE: 'static + Copy,

Converts this rectangle to a rectangle of another type, using the as conversion.

impl<T> Rect3<T, T>

where T: Copy + Add<Output = T>,

pub fn into_aabb(self) -> Aabb<T>

Converts this into the matching axis-aligned bounding shape representation.

pub fn contains_point(self, p: Vec3<T>) -> bool

where T: PartialOrd,

Does this rectangle contain the given point ?

pub fn contains_rect3(self, other: Rect3<T, T>) -> bool

where T: PartialOrd,

Does this rectangle fully contain the given one ?

pub fn collides_with_rect3(self, other: Rect3<T, T>) -> bool

where T: PartialOrd,

Does this rectangle collide with another ?

pub fn center(self) -> Vec3<T>

where T: One + Div<Output = T>,

Gets this rectangle’s center.

impl<T> Rect3<T, T>

where T: PartialOrd + Sub<Output = T> + Add<Output = T> + Copy,

pub fn expanded_to_contain_point(self, p: Vec3<T>) -> Rect3<T, T>

where T: PartialOrd,

Returns this shape so that it contains the given point.

pub fn expand_to_contain_point(&mut self, p: Vec3<T>)

where T: PartialOrd,

Expands this shape so that it contains the given point.

pub fn union(self, other: Rect3<T, T>) -> Rect3<T, T>

Gets the smallest rectangle that contains both this one and another.

pub fn intersection(self, other: Rect3<T, T>) -> Rect3<T, T>

Gets the largest rectangle contained by both this one and another.

pub fn expand_to_contain(&mut self, other: Rect3<T, T>)

Sets this rectangle to the union of itself with another.

pub fn intersect(&mut self, other: Rect3<T, T>)

Sets this rectangle to the intersection of itself with another.

pub fn collision_vector_with_rect3(self, other: Rect3<T, T>) -> Vec3<T>

where T: One + Div<Output = T>,

Gets a vector that tells how much self penetrates other.

pub fn split_at_x(self, sp: T) -> [Rect3<T, T>; 2]

Splits this shape in two, by a straight plane along the x axis. The returned tuple is (low, high).

Panics

sp is assumed to be a position along the x axis that is within this shape’s bounds.

pub fn split_at_y(self, sp: T) -> [Rect3<T, T>; 2]

Splits this shape in two, by a straight plane along the y axis. The returned tuple is (low, high).

Panics

sp is assumed to be a position along the y axis that is within this shape’s bounds.

pub fn split_at_z(self, sp: T) -> [Rect3<T, T>; 2]

Splits this shape in two, by a straight plane along the z axis. The returned tuple is (low, high).

Panics

sp is assumed to be a position along the z axis that is within this shape’s bounds.

Trait Implementations

impl<P, E> Clone for Rect3<P, E>

where P: Clone, E: Clone,

fn clone(&self) -> Rect3<P, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P, E> Debug for Rect3<P, E>

where P: Debug, E: Debug,

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

Formats the value using the given formatter.

impl<P, E> Default for Rect3<P, E>

where P: Default, E: Default,

fn default() -> Rect3<P, E>

Returns the “default value” for a type.

impl<'de, P, E> Deserialize<'de> for Rect3<P, E>

where P: Deserialize<'de>, E: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Rect3<P, E>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P, E> From<(Vec3<P>, Extent3<E>)> for Rect3<P, E>

fn from(t: (Vec3<P>, Extent3<E>)) -> Rect3<P, E>

Converts to this type from the input type.

impl<T> From<Aabb<T>> for Rect3<T, T>

where T: Copy + Sub<Output = T>,

fn from(aab: Aabb<T>) -> Rect3<T, T>

Converts to this type from the input type.

impl<T> From<Rect3<T, T>> for Aabb<T>

where T: Copy + Add<Output = T>,

fn from(rect: Rect3<T, T>) -> Aabb<T>

Converts to this type from the input type.

impl<P, E> Hash for Rect3<P, E>

where P: Hash, E: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<P, E> PartialEq for Rect3<P, E>

where P: PartialEq, E: PartialEq,

fn eq(&self, other: &Rect3<P, E>) -> 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<P, E> Serialize for Rect3<P, E>

where P: Serialize, E: 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<P, E> Copy for Rect3<P, E>

where P: Copy, E: Copy,

impl<P, E> Eq for Rect3<P, E>

where P: Eq, E: Eq,

impl<P, E> StructuralPartialEq for Rect3<P, E>