Struct Rect

pub struct Rect {
    pub pos: Vector,
    pub size: Vector,
}

Represents a rectangle in a 2D space.

The Rect struct is defined by its position (pos) and size (size), both of which are represented as Vector instances. The position indicates the coordinates of the rectangle’s bottom-left corner, and the size indicates the width and height of the rectangle.

Examples

Creating a new rectangle:

use fixed32::Fp;
use fixed32_math::{Vector, Rect};

let pos = Vector::new(Fp::from(1), Fp::from(2));
let size = Vector::new(Fp::from(3), Fp::from(4));
let rect = Rect::new(pos, size);

Accessing the position and size:

use fixed32::Fp;
use fixed32_math::{Vector, Rect};

let pos = Vector::new(Fp::from(1), Fp::from(2));
let size = Vector::new(Fp::from(3), Fp::from(4));
let rect = Rect::new(pos, size);
assert_eq!(rect.pos.x, Fp::from(1));
assert_eq!(rect.size.y, Fp::from(4));

Fields

pos: Vector

size: Vector

Implementations

impl Rect

pub const fn new(pos: Vector, size: Vector) -> Self

Creates a new Rect with the specified position and size.

Parameters

• pos: The position of the rectangle’s top-left corner as a Vector.
• size: The size of the rectangle, including its width and height, as a Vector.

Returns

A Rect instance with the given position and size.

Examples

use fixed32::Fp;
use fixed32_math::{Vector, Rect};

let pos = Vector::new(Fp::from(1), Fp::from(2));
let size = Vector::new(Fp::from(3), Fp::from(4));
let rect = Rect::new(pos, size);
assert_eq!(rect.pos, pos);
assert_eq!(rect.size, size);

pub fn top(self) -> Fp

pub const fn bottom(self) -> Fp

pub const fn left(self) -> Fp

pub fn right(self) -> Fp

pub fn move_by(self, offset: Vector) -> Self

Returns a new Rect with its position translated by the given vector.

This method is useful for moving the rectangle while keeping its size unchanged.

Parameters

• offset: A vector indicating how much to translate the rectangle’s position.

Returns

A new Rect with the position translated by the given vector. The size remains unchanged.

Examples

use fixed32::Fp;
use fixed32_math::{Rect, Vector};

let pos = Vector::new(Fp::from(1), Fp::from(2));
let size = Vector::new(Fp::from(3), Fp::from(4));
let rect = Rect::new(pos, size);
let offset = Vector::new(Fp::from(1), Fp::from(-1));
let translated_rect = rect.move_by(offset);
assert_eq!(translated_rect.pos.x, Fp::from(2));
assert_eq!(translated_rect.pos.y, Fp::from(1));
assert_eq!(translated_rect.size, size);

pub fn area(&self) -> Fp

Calculates the area of the rectangle.

pub fn perimeter(&self) -> Fp

Calculates the perimeter of the rectangle.

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

Calculates the intersection of two rectangles.

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

Calculates the union of two rectangles.

pub fn contains_point(&self, point: &Vector) -> bool

Checks if a point is inside the rectangle.

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

Checks if another rectangle is completely inside this rectangle.

pub fn is_overlapping(self, other: Self) -> bool

pub fn expanded(&self, offset: Vector) -> Self

Expands the rectangle by a given offset.

pub fn contracted(&self, offset: Vector) -> Self

Contracts the rectangle by a given offset.

pub fn aspect_ratio(&self) -> Fp

Calculates the aspect ratio of the rectangle.

Trait Implementations

impl Clone for Rect

fn clone(&self) -> Rect

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Rect

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

Formats the value using the given formatter.

impl Default for Rect

fn default() -> Rect

Returns the “default value” for a type.

impl Display for Rect

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

Formats the value using the given formatter.

impl From<(f32, f32, f32, f32)> for Rect

fn from(values: (f32, f32, f32, f32)) -> Self

Converts to this type from the input type.

impl From<(i16, i16, i16, i16)> for Rect

fn from(values: (i16, i16, i16, i16)) -> Self

Converts to this type from the input type.

impl PartialEq for Rect

fn eq(&self, other: &Rect) -> 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 Copy for Rect

impl Eq for Rect

impl StructuralPartialEq for Rect