Struct Rect 

pub struct Rect {
    pub x: f32,
    pub y: f32,
    pub w: f32,
    pub h: f32,
}

Rect

Contains the position (x, y) and size (width, height) of a rectangle. Can be used for detecting AABB collisions or drawing rectangles.

Examples

let my_rect = Rect::new(0.0, 0.0, 50.0, 50.0);

Drawing a Rect to the screen:

my_rect.draw(RED);
// or
draw_rectangle_from_rect(my_rect, RED);

Check collisions:

if my_rect.contains_point(mouse_position_vec2()) {
    println!("Mouse is inside the rect")
}

let aabb_intersection: Option<Rect> = my_rect.intersection(other_rect);

Fields

x: f32

y: f32

w: f32

h: f32

Implementations

impl Rect

pub const fn new(x: f32, y: f32, w: f32, h: f32) -> Self

Makes a new Rect object with the x, y position and Width x Height

pub fn from_corners(a: Vector2, b: Vector2) -> Self

Build a Rect from two corner points (handles any order)

pub fn from_center(center: Vector2, w: f32, h: f32) -> Self

Build a Rect centered on center with the given size

pub const fn left(&self) -> f32

pub const fn right(&self) -> f32

pub const fn top(&self) -> f32

pub const fn bottom(&self) -> f32

pub const fn top_left(&self) -> Vector2

pub const fn top_right(&self) -> Vector2

pub const fn bottom_left(&self) -> Vector2

pub const fn bottom_right(&self) -> Vector2

pub const fn xy(&self) -> Vector2

pub const fn wh(&self) -> Vector2

pub const fn xw(&self) -> Vector2

pub const fn xh(&self) -> Vector2

pub const fn yw(&self) -> Vector2

pub const fn yh(&self) -> Vector2

pub fn corners(&self) -> [Vector2; 4]

pub fn center(&self) -> Vector2

pub const fn area(&self) -> f32

pub const fn perimeter(&self) -> f32

pub const fn size(&self) -> Vector2

pub const fn position(&self) -> Vector2

pub const fn with_x(&self, x: f32) -> Self

Get a new Rect with the specified x

pub const fn with_y(&self, y: f32) -> Self

Get a new Rect with the specified y

pub const fn with_w(&self, w: f32) -> Self

Get a new Rect with the specified w

pub const fn with_h(&self, h: f32) -> Self

Get a new Rect with the specified h

pub fn with_position(&self, pos: Vector2) -> Self

Get a new Rect with the specified position

pub fn with_position_xy(&self, x: f32, y: f32) -> Self

Get a new Rect with the specified position

pub fn change_position_by(&mut self, offset: Vector2)

Changes the position relatively by an offset Vector2.

pub fn change_size_by(&mut self, offset: Vector2)

Changes the size relatively by an offset Vector2.

pub fn with_size(&self, size: Vector2) -> Self

Get a new Rect with the specified size

pub fn translated(&self, offset: Vector2) -> Self

Get a moved Rect by an offset

pub fn centered_at(&self, center: Vector2) -> Self

Move the rect so its center is at center

pub fn inflated(&self, amount: f32) -> Self

Grow/shrink the rect on all sides by amount (negative shrinks), keeping center fixed

pub const fn scaled(&self, factor: f32) -> Self

Scale width/height around the top-left corner (position unchanged)

pub fn scaled_from_center(&self, factor: f32) -> Self

Scale width/height around the rect’s center

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

Smallest rect that fully contains both self and other

pub fn clamp_point(&self, point: Vector2) -> Vector2

Clamp a point to lie within this rect

pub fn normalized(&self) -> Self

Fix a rect with negative width/height into one with positive dimensions

pub fn to_array(&self) -> [f32; 4]

pub fn lerp(self, other: Rect, t: f32) -> Self

Linearly interpolate between two rects

pub const fn contains_point(&self, x: f32, y: f32) -> bool

Test if point (x, y) lies inside/on the Rect

pub const fn contains_point_fully(&self, x: f32, y: f32) -> bool

Test if point (x, y) lies inside/on the Rect

pub const fn contains_point_vec2(&self, point: Vector2) -> bool

Test if point (Vector2) lies inside/on the Rect

pub const fn contains_point_fully_vec2(&self, point: Vector2) -> bool

Test if point (Vector2) lies inside/on the Rect

pub fn contains_mouse(&self) -> bool

Test if mouse lies inside/on the Rect

pub fn contains_mouse_fully(&self) -> bool

Test if mouse lies inside/on the Rect

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

AABB overlap test

pub const fn intersection(&self, other: Rect) -> Option<Rect>

Returns the overlapping region, or None if they don’t intersect

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

True if self fully contains other

pub fn update(&mut self, new_rect: Rect) -> Rect

Updates the original rect with a new one and returns it as well

pub fn draw(&self, color: Color)

Draw the Rect to the screen using a color

pub fn draw_rounded(&self, radius: f32, color: Color)

pub fn draw_rounded_ex( &self, top_left: f32, top_right: f32, bottom_left: f32, bottom_right: f32, color: Color, )

pub fn draw_lines(&self, thickness: f32, color: Color)

Draw the Rect’s outline to the screen using a color and thickness

pub fn draw_lines_rounded(&self, radius: f32, thickness: f32, color: Color)

pub fn draw_lines_rounded_ex( &self, top_left: f32, top_right: f32, bottom_left: f32, bottom_right: f32, thickness: f32, color: Color, )

impl Rect

pub fn resolve_collision(&mut self, other: Rect) -> Option<Vector2>

Pushes self out of an axis-aligned other. Returns the collision normal (direction self was pushed), or None.

pub fn resolve_collision_obb( &mut self, angle: f32, other: &Rect, other_angle: f32, ) -> Option<Vector2>

Pushes self out of a rotated other (SAT). Returns the collision normal (direction self was pushed), or None.

pub fn intersection_obb( &self, angle: f32, other: &Rect, other_angle: f32, ) -> Option<Vector2>

OBB vs OBB collision (SAT). Angles are in radians, each rect rotates around its own center. Returns the minimum translation vector that pushes self out of other, or None if not colliding.

pub fn intersects_obb(&self, angle: f32, other: &Rect, other_angle: f32) -> bool

Bool-only OBB overlap test

pub fn corners_by_angle(&self, angle: f32) -> [Vector2; 4]

Corners of the rect rotated by angle (radians) around its center

pub fn draw_rotated(&self, angle: f32, color: Color)

Draw the Rect rotated by angle (radians) around its center

pub fn draw_lines_rotated(&self, angle: f32, thickness: f32, color: Color)

Draw the rotated Rect’s outline

Trait Implementations

impl Clone for Rect

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Rect

impl Debug for Rect

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

Formats the value using the given formatter.

impl Default for Rect

fn default() -> Self

Returns the “default value” for a type.

impl Into<[f32; 4]> for Rect

fn into(self) -> [f32; 4]

Converts this type into the (usually inferred) input type.

impl PartialEq for Rect

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Rect

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Rect