Struct vek::geom::repr_c::Rect

pub struct Rect<P, E> {
    pub x: P,
    pub y: P,
    pub w: E,
    pub h: E,
}

2D rectangle, represented by a bottom-left position, and 2D extents.

Most operations on a Rect are better done by converting it to Aabr form. In fact, most existing code in the wild implicitly does this and so does this crate.

Aabr structs are often more convenient, faster and probably less confusing. The Rect type is provided because it exists for a lot of APIs (including some system APIs, OpenGL, and others).

Please note that in most APIs in the wild (but NOT in vek), the Y axis is treated as pointing downwards because it’s the one of window space.

Keeping the Y axis upwards is a lot more convenient implementation-wise, and still matches the convention used in 3D spaces.

Fields

x: P

X position of the bottom-left corner.

y: P

Y position of the bottom-left corner.

w: E

Width.

h: E

Height, with Y axis going upwards.

Implementations

impl<P, E> Rect<P, E>

pub fn new(x: P, y: P, w: E, h: E) -> Self

Creates a new rectangle from position elements and extent elements.

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

Gets this rectangle’s position.

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

Gets this rectangle’s extent (size).

pub fn position_extent(self) -> (Vec2<P>, Extent2<E>)

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

pub fn map<DP, DE, PF, EF>(self, pf: PF, ef: EF) -> Rect<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) -> Rect<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> Rect<T, T> where
    T: Copy + Add<T, Output = T>, 

pub fn into_aabr(self) -> Aabr<T>

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

pub fn contains_point(self, p: Vec2<T>) -> bool where
    T: PartialOrd, 

Does this rectangle contain the given point ?

pub fn contains_rect(self, other: Self) -> bool where
    T: PartialOrd, 

Does this rectangle fully contain the given one ?

pub fn collides_with_rect(self, other: Self) -> bool where
    T: PartialOrd, 

Does this rectangle collide with another ?

pub fn center(self) -> Vec2<T> where
    T: One + Div<T, Output = T>, 

Gets this rectangle’s center.

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

pub fn expanded_to_contain_point(self, p: Vec2<T>) -> Self where
    T: PartialOrd, 

Returns this shape so that it contains the given point.

pub fn expand_to_contain_point(&mut self, p: Vec2<T>) where
    T: PartialOrd, 

Expands this shape so that it contains the given point.

pub fn union(self, other: Self) -> Self

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

pub fn intersection(self, other: Self) -> Self

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

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

Sets this rectangle to the union of itself with another.

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

Sets this rectangle to the intersection of itself with another.

pub fn collision_vector_with_rect(self, other: Self) -> Vec2<T> where
    T: One + Div<T, Output = T>, 

Gets a vector that tells how much self penetrates other.

pub fn split_at_x(self, sp: T) -> [Self; 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) -> [Self; 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.

Trait Implementations

impl<P: Clone, E: Clone> Clone for Rect<P, E>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug, E: Debug> Debug for Rect<P, E>

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

Formats the value using the given formatter.

impl<P: Default, E: Default> Default for Rect<P, E>

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

Returns the “default value” for a type.

impl<'de, P, E> Deserialize<'de> for Rect<P, E> where
    P: Deserialize<'de>,
    E: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<P, E> From<(Vec2<P>, Extent2<E>)> for Rect<P, E>

fn from(t: (Vec2<P>, Extent2<E>)) -> Self

Performs the conversion.

impl<T> From<Aabr<T>> for Rect<T, T> where
    T: Copy + Sub<T, Output = T>, 

fn from(aab: Aabr<T>) -> Self

Performs the conversion.

impl<T> From<Rect<T, T>> for Aabr<T> where
    T: Copy + Add<T, Output = T>, 

fn from(rect: Rect<T, T>) -> Self

Performs the conversion.

impl<P: Hash, E: Hash> Hash for Rect<P, E>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<P: PartialEq, E: PartialEq> PartialEq<Rect<P, E>> for Rect<P, E>

fn eq(&self, other: &Rect<P, E>) -> bool

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

fn ne(&self, other: &Rect<P, E>) -> bool

This method tests for !=.

impl<P, E> Serialize for Rect<P, E> where
    P: Serialize,
    E: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<P: Copy, E: Copy> Copy for Rect<P, E>

impl<P: Eq, E: Eq> Eq for Rect<P, E>

impl<P, E> StructuralEq for Rect<P, E>

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