Struct Rect 

pub struct Rect {
    pub x: i32,
    pub y: i32,
    pub width: u32,
    pub height: u32,
}

A rectangle for dirty rect tracking.

Example

use martensite_devtools::hud::Rect;

let r = Rect::new(10, 20, 100, 200);
assert_eq!(r.area(), 20_000);

Fields

x: i32

X coordinate (pixels from left).

y: i32

Y coordinate (pixels from top).

width: u32

Width in pixels.

height: u32

Height in pixels.

Implementations

impl Rect

pub fn new(x: i32, y: i32, width: u32, height: u32) -> Self

Creates a new rectangle.

Example

use martensite_devtools::hud::Rect;

let r = Rect::new(0, 0, 100, 100);
assert_eq!(r.area(), 10_000);

pub fn area(&self) -> u64

Returns the area of the rectangle in pixels.

Example

use martensite_devtools::hud::Rect;

assert_eq!(Rect::new(0, 0, 100, 50).area(), 5_000);

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

Returns true if this rectangle intersects another.

Example

use martensite_devtools::hud::Rect;

let a = Rect::new(0, 0, 100, 100);
let b = Rect::new(50, 50, 100, 100);
let c = Rect::new(200, 200, 50, 50);
assert!(a.intersects(&b));
assert!(!a.intersects(&c));

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

Returns the bounding union of two rectangles.

Example

use martensite_devtools::hud::Rect;

let a = Rect::new(0, 0, 100, 100);
let b = Rect::new(50, 50, 100, 100);
let u = a.union(&b);
assert_eq!(u.x, 0);
assert_eq!(u.y, 0);
assert_eq!(u.width, 150);
assert_eq!(u.height, 150);

Trait Implementations

impl Clone for Rect

fn clone(&self) -> Rect

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 Eq for Rect

impl Hash for Rect

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Rect

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Rect