Struct graphene::Rect

#[repr(transparent)]
pub struct Rect { /* private fields */ }

The location and size of a rectangle region.

The width and height of a Rect can be negative; for instance, a Rect with an origin of [ 0, 0 ] and a size of [ 10, 10 ] is equivalent to a Rect with an origin of [ 10, 10 ] and a size of [ -10, -10 ].

Application code can normalize rectangles using normalize(); this function will ensure that the width and height of a rectangle are positive values. All functions taking a Rect as an argument will internally operate on a normalized copy; all functions returning a Rect will always return a normalized rectangle.

Implementations

impl Rect

pub fn contains_point(&self, p: &Point) -> bool

Checks whether a Rect contains the given coordinates.

p

a Point

Returns

true if the rectangle contains the point

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

Checks whether a Rect fully contains the given rectangle.

b

a Rect

Returns

true if the rectangle self fully contains b

pub fn expand(&self, p: &Point) -> Rect

Expands a Rect to contain the given Point.

p

a Point

Returns

res

return location for the expanded rectangle

pub fn area(&self) -> f32

Compute the area of given normalized rectangle.

Returns

the area of the normalized rectangle

pub fn bottom_left(&self) -> Point

Retrieves the coordinates of the bottom-left corner of the given rectangle.

Returns

p

return location for a Point

pub fn bottom_right(&self) -> Point

Retrieves the coordinates of the bottom-right corner of the given rectangle.

Returns

p

return location for a Point

pub fn center(&self) -> Point

Retrieves the coordinates of the center of the given rectangle.

Returns

p

return location for a Point

pub fn height(&self) -> f32

Retrieves the normalized height of the given rectangle.

Returns

the normalized height of the rectangle

pub fn top_left(&self) -> Point

Retrieves the coordinates of the top-left corner of the given rectangle.

Returns

p

return location for a Point

pub fn top_right(&self) -> Point

Retrieves the coordinates of the top-right corner of the given rectangle.

Returns

p

return location for a Point

pub fn width(&self) -> f32

Retrieves the normalized width of the given rectangle.

Returns

the normalized width of the rectangle

pub fn x(&self) -> f32

Retrieves the normalized X coordinate of the origin of the given rectangle.

Returns

the normalized X coordinate of the rectangle

pub fn y(&self) -> f32

Retrieves the normalized Y coordinate of the origin of the given rectangle.

Returns

the normalized Y coordinate of the rectangle

pub fn inset(&mut self, d_x: f32, d_y: f32)

Changes the given rectangle to be smaller, or larger depending on the given inset parameters.

To create an inset rectangle, use positive d_x or d_y values; to create a larger, encompassing rectangle, use negative d_x or d_y values.

The origin of the rectangle is offset by d_x and d_y, while the size is adjusted by (2 * d_x, 2 * d_y). If d_x and d_y are positive values, the size of the rectangle is decreased; if d_x and d_y are negative values, the size of the rectangle is increased.

If the size of the resulting inset rectangle has a negative width or height then the size will be set to zero.

d_x

the horizontal inset

d_y

the vertical inset

Returns

the inset rectangle

pub fn inset_r(&self, d_x: f32, d_y: f32) -> Rect

Changes the given rectangle to be smaller, or larger depending on the given inset parameters.

To create an inset rectangle, use positive d_x or d_y values; to create a larger, encompassing rectangle, use negative d_x or d_y values.

The origin of the rectangle is offset by d_x and d_y, while the size is adjusted by (2 * d_x, 2 * d_y). If d_x and d_y are positive values, the size of the rectangle is decreased; if d_x and d_y are negative values, the size of the rectangle is increased.

If the size of the resulting inset rectangle has a negative width or height then the size will be set to zero.

d_x

the horizontal inset

d_y

the vertical inset

Returns

res

return location for the inset rectangle

pub fn interpolate(&self, b: &Rect, factor: f64) -> Rect

Linearly interpolates the origin and size of the two given rectangles.

b

a Rect

factor

the linear interpolation factor

Returns

res

return location for the interpolated rectangle

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

Computes the intersection of the two given rectangles.

The intersection in the image above is the blue outline.

If the two rectangles do not intersect, res will contain a degenerate rectangle with origin in (0, 0) and a size of 0.

b

a Rect

Returns

true if the two rectangles intersect

res

return location for a Rect

pub fn normalize(&mut self)

Normalizes the passed rectangle.

This function ensures that the size of the rectangle is made of positive values, and that the origin is the top-left corner of the rectangle.

Returns

the normalized rectangle

pub fn normalize_r(&self) -> Rect

Normalizes the passed rectangle.

This function ensures that the size of the rectangle is made of positive values, and that the origin is in the top-left corner of the rectangle.

Returns

res

the return location for the normalized rectangle

pub fn offset(&mut self, d_x: f32, d_y: f32)

Offsets the origin by d_x and d_y.

The size of the rectangle is unchanged.

d_x

the horizontal offset

d_y

the vertical offset

Returns

the offset rectangle

pub fn offset_r(&self, d_x: f32, d_y: f32) -> Rect

Offsets the origin of the given rectangle by d_x and d_y.

The size of the rectangle is left unchanged.

d_x

the horizontal offset

d_y

the vertical offset

Returns

res

return location for the offset rectangle

pub fn round_extents(&self) -> Rect

Rounds the origin of the given rectangle to its nearest integer value and and recompute the size so that the rectangle is large enough to contain all the conrners of the original rectangle.

This function is the equivalent of calling floor on the coordinates of the origin, and recomputing the size calling ceil on the bottom-right coordinates.

If you want to be sure that the rounded rectangle completely covers the area that was covered by the original rectangle — i.e. you want to cover the area including all its corners — this function will make sure that the size is recomputed taking into account the ceiling of the coordinates of the bottom-right corner. If the difference between the original coordinates and the coordinates of the rounded rectangle is greater than the difference between the original size and and the rounded size, then the move of the origin would not be compensated by a move in the anti-origin, leaving the corners of the original rectangle outside the rounded one.

Returns

res

return location for the rectangle with rounded extents

pub fn scale(&self, s_h: f32, s_v: f32) -> Rect

Scales the size and origin of a rectangle horizontaly by s_h, and vertically by s_v. The result res is normalized.

s_h

horizontal scale factor

s_v

vertical scale factor

Returns

res

return location for the scaled rectangle

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

Computes the union of the two given rectangles.

The union in the image above is the blue outline.

b

a Rect

Returns

res

return location for a Rect

pub fn zero() -> Rect

Returns a degenerate rectangle with origin fixed at (0, 0) and a size of 0, 0.

Returns

a fixed rectangle

impl Rect

pub fn vertices(&self) -> &[Vec2; 4]

Computes the four vertices of a Rect.

Returns

vertices

return location for an array of 4 Vec2

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

Initializes the given Rect with the given values.

This function will implicitly normalize the Rect before returning.

x

the X coordinate of the Rect

y

the Y coordinate of the Rect

width

the width of the Rect

height

the height of the Rect

Returns

the initialized rectangle

Trait Implementations

impl Clone for Rect

fn clone(&self) -> Self

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

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

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

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

fn static_type() -> Type

Returns the type identifier of Self.

impl Copy for Rect

impl Eq for Rect