Struct me3_framework::overlay::Rect

#[repr(C)]
pub struct Rect {
    pub min: Pos2,
    pub max: Pos2,
}

A rectangular region of space.

Usually a Rect has a positive (or zero) size, and then Self::min <= Self::max. In these cases Self::min is the left-top corner and Self::max is the right-bottom corner.

A rectangle is allowed to have a negative size, which happens when the order of min and max are swapped. These are usually a sign of an error.

Normally the unit is points (logical pixels) in screen space coordinates.

Fields

min: Pos2

One of the corners of the rectangle, usually the left top one.

max: Pos2

The other corner, opposing Self::min. Usually the right bottom one.

Implementations

impl Rect

pub const EVERYTHING: Rect = Self{ min: pos2(-INFINITY, -INFINITY), max: pos2(INFINITY, INFINITY),}

Infinite rectangle that contains every point.

pub const NOTHING: Rect = Self{ min: pos2(INFINITY, INFINITY), max: pos2(-INFINITY, -INFINITY),}

The inverse of Self::EVERYTHING: stretches from positive infinity to negative infinity. Contains no points.

This is useful as the seed for bounding boxes.

Example:

let mut rect = Rect::NOTHING;
assert!(rect.size() == Vec2::splat(-f32::INFINITY));
assert!(rect.contains(pos2(0.0, 0.0)) == false);
rect.extend_with(pos2(2.0, 1.0));
rect.extend_with(pos2(0.0, 3.0));
assert_eq!(rect, Rect::from_min_max(pos2(0.0, 1.0), pos2(2.0, 3.0)))

pub const NAN: Rect = Self{ min: pos2(f32::NAN, f32::NAN), max: pos2(f32::NAN, f32::NAN),}

An invalid Rect filled with f32::NAN;

pub const fn from_min_max(min: Pos2, max: Pos2) -> Rect

pub fn from_min_size(min: Pos2, size: Vec2) -> Rect

left-top corner plus a size (stretching right-down).

pub fn from_center_size(center: Pos2, size: Vec2) -> Rect

pub fn from_x_y_ranges(
    x_range: RangeInclusive<f32>,
    y_range: RangeInclusive<f32>
) -> Rect

pub fn from_two_pos(a: Pos2, b: Pos2) -> Rect

Returns the bounding rectangle of the two points.

pub fn from_points(points: &[Pos2]) -> Rect

Bounding-box around the points.

pub fn everything_right_of(left_x: f32) -> Rect

A Rect that contains every point to the right of the given X coordinate.

pub fn everything_left_of(right_x: f32) -> Rect

A Rect that contains every point to the left of the given X coordinate.

pub fn everything_below(top_y: f32) -> Rect

A Rect that contains every point below a certain y coordinate

pub fn everything_above(bottom_y: f32) -> Rect

A Rect that contains every point above a certain y coordinate

pub fn expand(self, amnt: f32) -> Rect

Expand by this much in each direction, keeping the center

pub fn expand2(self, amnt: Vec2) -> Rect

Expand by this much in each direction, keeping the center

pub fn shrink(self, amnt: f32) -> Rect

Shrink by this much in each direction, keeping the center

pub fn shrink2(self, amnt: Vec2) -> Rect

Shrink by this much in each direction, keeping the center

pub fn translate(self, amnt: Vec2) -> Rect

pub fn rotate_bb(self, rot: Rot2) -> Rect

Rotate the bounds (will expand the Rect)

pub fn intersects(self, other: Rect) -> bool

pub fn set_width(&mut self, w: f32)

keep min

pub fn set_height(&mut self, h: f32)

keep min

pub fn set_center(&mut self, center: Pos2)

Keep size

pub fn contains(&self, p: Pos2) -> bool

pub fn contains_rect(&self, other: Rect) -> bool

pub fn clamp(&self, p: Pos2) -> Pos2

Return the given points clamped to be inside the rectangle Panics if Self::is_negative.

pub fn extend_with(&mut self, p: Pos2)

pub fn extend_with_x(&mut self, x: f32)

Expand to include the given x coordinate

pub fn extend_with_y(&mut self, y: f32)

Expand to include the given y coordinate

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

The union of two bounding rectangle, i.e. the minimum Rect that contains both input rectangles.

pub fn intersect(self, other: Rect) -> Rect

The intersection of two Rect, i.e. the area covered by both.

pub fn center(&self) -> Pos2

pub fn size(&self) -> Vec2

pub fn width(&self) -> f32

pub fn height(&self) -> f32

pub fn aspect_ratio(&self) -> f32

Width / height

• aspect_ratio < 1: portrait / high
• aspect_ratio = 1: square
• aspect_ratio > 1: landscape / wide

pub fn square_proportions(&self) -> Vec2

[2, 1] for wide screen, and [1, 2] for portrait, etc. At least one dimension = 1, the other >= 1 Returns the proportions required to letter-box a square view area.

pub fn area(&self) -> f32

pub fn distance_to_pos(&self, pos: Pos2) -> f32

The distance from the rect to the position.

The distance is zero when the position is in the interior of the rectangle.

pub fn distance_sq_to_pos(&self, pos: Pos2) -> f32

The distance from the rect to the position, squared.

The distance is zero when the position is in the interior of the rectangle.

pub fn signed_distance_to_pos(&self, pos: Pos2) -> f32

Signed distance to the edge of the box.

Negative inside the box.

pub fn lerp(&self, t: Vec2) -> Pos2

Linearly interpolate so that [0, 0] is Self::min and [1, 1] is Self::max.

pub fn x_range(&self) -> RangeInclusive<f32>

pub fn y_range(&self) -> RangeInclusive<f32>

pub fn bottom_up_range(&self) -> RangeInclusive<f32>

pub fn is_negative(&self) -> bool

width < 0 || height < 0

pub fn is_positive(&self) -> bool

width > 0 && height > 0

pub fn is_finite(&self) -> bool

True if all members are also finite.

pub fn any_nan(self) -> bool

True if any member is NaN.

impl Rect

Convenience functions (assumes origin is towards left top):

pub fn left(&self) -> f32

min.x

pub fn left_mut(&mut self) -> &mut f32

min.x

pub fn set_left(&mut self, x: f32)

min.x

pub fn right(&self) -> f32

max.x

pub fn right_mut(&mut self) -> &mut f32

max.x

pub fn set_right(&mut self, x: f32)

max.x

pub fn top(&self) -> f32

min.y

pub fn top_mut(&mut self) -> &mut f32

min.y

pub fn set_top(&mut self, y: f32)

min.y

pub fn bottom(&self) -> f32

max.y

pub fn bottom_mut(&mut self) -> &mut f32

max.y

pub fn set_bottom(&mut self, y: f32)

max.y

pub fn left_top(&self) -> Pos2

pub fn center_top(&self) -> Pos2

pub fn right_top(&self) -> Pos2

pub fn left_center(&self) -> Pos2

pub fn right_center(&self) -> Pos2

pub fn left_bottom(&self) -> Pos2

pub fn center_bottom(&self) -> Pos2

pub fn right_bottom(&self) -> Pos2

Trait Implementations

impl Clone for Rect

fn clone(&self) -> Rect

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Rect

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

Formats the value using the given formatter.

impl From<[Pos2; 2]> for Rect

from (min, max) or (left top, right bottom)

fn from([Pos2; 2]) -> Rect

Converts to this type from the input type.

impl PartialEq<Rect> for Rect

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

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

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

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

impl Copy for Rect

impl Eq for Rect

impl StructuralEq for Rect

impl StructuralPartialEq for Rect