# [−][src]Struct ggez::graphics::Rect

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

A simple 2D rectangle.

The origin of the rectangle is at the top-left, with x increasing to the right and y increasing down.

## Fields

`x: f32`

X coordinate of the left edge of the rect.

`y: f32`

Y coordinate of the top edge of the rect.

`w: f32`

Total width of the rect

`h: f32`

Total height of the rect.

## Methods

### `impl Rect`[src]

#### `pub const fn new(x: f32, y: f32, w: f32, h: f32) -> Self`[src]

Create a new `Rect`.

#### `pub fn fraction(x: f32, y: f32, w: f32, h: f32, reference: &Rect) -> Rect`[src]

Creates a new `Rect` a la Love2D's `love.graphics.newQuad`, as a fraction of the reference rect's size.

#### `pub const fn new_i32(x: i32, y: i32, w: i32, h: i32) -> Self`[src]

Create a new rect from `i32` coordinates.

#### `pub const fn zero() -> Self`[src]

Create a new `Rect` with all values zero.

#### `pub const fn one() -> Self`[src]

Creates a new `Rect` at `0,0` with width and height 1.

#### `pub const fn point(&self) -> Point2<f32>`[src]

Gets the `Rect`'s x and y coordinates as a `Point2`.

#### `pub const fn left(&self) -> f32`[src]

Returns the left edge of the `Rect`

#### `pub fn right(&self) -> f32`[src]

Returns the right edge of the `Rect`

#### `pub const fn top(&self) -> f32`[src]

Returns the top edge of the `Rect`

#### `pub fn bottom(&self) -> f32`[src]

Returns the bottom edge of the `Rect`

#### `pub fn contains<P>(&self, point: P) -> bool where    P: Into<Point2<f32>>, `[src]

Checks whether the `Rect` contains a `Point`

#### `pub fn overlaps(&self, other: &Rect) -> bool`[src]

Checks whether the `Rect` overlaps another `Rect`

#### `pub fn translate<V>(&mut self, offset: V) where    V: Into<Vector2<f32>>, `[src]

Translates the `Rect` by an offset of (x, y)

#### `pub fn move_to<P>(&mut self, destination: P) where    P: Into<Point2<f32>>, `[src]

Moves the `Rect`'s origin to (x, y)

#### `pub fn scale(&mut self, sx: f32, sy: f32)`[src]

Scales the `Rect` by a factor of (sx, sy), growing towards the bottom-left

#### `pub fn rotate(&mut self, rotation: f32)`[src]

Calculated the new Rect around the rotated one.

#### `pub fn combine_with(self, other: Rect) -> Rect`[src]

Returns a new `Rect` that includes all points of these two `Rect`s.

## Trait Implementations

### `impl Clone for Rect`[src]

#### `fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from `source`. Read more

### `impl AbsDiffEq<Rect> for Rect`[src]

#### `type Epsilon = f32`

Used for specifying relative comparisons.

#### `fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool`[src]

The inverse of `ApproxEq::abs_diff_eq`.

### `impl RelativeEq<Rect> for Rect`[src]

#### `fn relative_ne(    &self,     other: &Rhs,     epsilon: Self::Epsilon,     max_relative: Self::Epsilon) -> bool`[src]

The inverse of `ApproxEq::relative_eq`.

## Blanket Implementations

### `impl<T> ToOwned for T where    T: Clone, `[src]

#### `type Owned = T`

The resulting type after obtaining ownership.

### `impl<T, U> TryFrom<U> for T where    U: Into<T>, `[src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

### `impl<T, U> TryInto<U> for T where    U: TryFrom<T>, `[src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

### `impl<T> Scalar for T where    T: Copy + PartialEq<T> + Any + Debug, `[src]

#### `fn is<T>() -> bool where    T: Scalar, `[src]

Tests if `Self` the same as the type `T` Read more

### `impl<T> Same<T> for T`

#### `type Output = T`

Should always be `Self`

### `impl<T> SetParameter for T`

#### `fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where    T: Parameter<Self>, `

Sets `value` as a parameter of `self`.