Struct sdl2::rect::Rect [−][src]
pub struct Rect { /* fields omitted */ }
A (non-empty) rectangle.
The width and height of a Rect
must always be strictly positive (never
zero). In cases where empty rects may need to represented, it is
recommended to use Option<Rect>
, with None
representing an empty
rectangle (see, for example, the output of the
intersection
method).
Methods
impl Rect
[src]
impl Rect
pub fn new(x: i32, y: i32, width: u32, height: u32) -> Rect
[src]
pub fn new(x: i32, y: i32, width: u32, height: u32) -> Rect
Creates a new rectangle from the given values.
The width and height are clamped to ensure that the right and bottom sides of the rectangle does not exceed i32::max_value() (the value 2147483647, the maximal positive size of an i32). This means that the rect size will behave oddly if you move it very far to the right or downwards on the screen.
Rect
s must always be non-empty, so a width
and/or height
argument
of 0 will be replaced with 1.
pub fn from_center<P>(center: P, width: u32, height: u32) -> Rect where
P: Into<Point>,
[src]
pub fn from_center<P>(center: P, width: u32, height: u32) -> Rect where
P: Into<Point>,
Creates a new rectangle centered on the given position.
The width and height are clamped to ensure that the right and bottom sides of the rectangle does not exceed i32::max_value() (the value 2147483647, the maximal positive size of an i32). This means that the rect size will behave oddly if you move it very far to the right or downwards on the screen.
Rect
s must always be non-empty, so a width
and/or height
argument
of 0 will be replaced with 1.
pub fn x(&self) -> i32
[src]
pub fn x(&self) -> i32
The horizontal position of this rectangle.
pub fn y(&self) -> i32
[src]
pub fn y(&self) -> i32
The vertical position of this rectangle.
pub fn width(&self) -> u32
[src]
pub fn width(&self) -> u32
The width of this rectangle.
pub fn height(&self) -> u32
[src]
pub fn height(&self) -> u32
The height of this rectangle.
pub fn size(&self) -> (u32, u32)
[src]
pub fn size(&self) -> (u32, u32)
Returns the width and height of this rectangle.
pub fn set_x(&mut self, x: i32)
[src]
pub fn set_x(&mut self, x: i32)
Sets the horizontal position of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.
pub fn set_y(&mut self, y: i32)
[src]
pub fn set_y(&mut self, y: i32)
Sets the vertical position of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.
pub fn set_width(&mut self, width: u32)
[src]
pub fn set_width(&mut self, width: u32)
Sets the width of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.
Rect
s must always be non-empty, so a width
argument of 0 will be
replaced with 1.
pub fn set_height(&mut self, height: u32)
[src]
pub fn set_height(&mut self, height: u32)
Sets the height of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.
Rect
s must always be non-empty, so a height
argument of 0 will be
replaced with 1.
pub fn left(&self) -> i32
[src]
pub fn left(&self) -> i32
Returns the x-position of the left side of this rectangle.
pub fn right(&self) -> i32
[src]
pub fn right(&self) -> i32
Returns the x-position of the right side of this rectangle.
pub fn top(&self) -> i32
[src]
pub fn top(&self) -> i32
Returns the y-position of the top side of this rectangle.
pub fn bottom(&self) -> i32
[src]
pub fn bottom(&self) -> i32
Returns the y-position of the bottom side of this rectangle.
pub fn center(&self) -> Point
[src]
pub fn center(&self) -> Point
Returns the center position of this rectangle.
Note that if the width or height is not a multiple of two, the center will be rounded down.
Example
use sdl2::rect::{Rect,Point}; let rect = Rect::new(1,0,2,3); assert_eq!(Point::new(2,1),rect.center());
pub fn top_left(&self) -> Point
[src]
pub fn top_left(&self) -> Point
Returns the top-left corner of this rectangle.
Example
use sdl2::rect::{Rect, Point}; let rect = Rect::new(1, 0, 2, 3); assert_eq!(Point::new(1, 0), rect.top_left());
pub fn top_right(&self) -> Point
[src]
pub fn top_right(&self) -> Point
Returns the top-right corner of this rectangle.
Example
use sdl2::rect::{Rect, Point}; let rect = Rect::new(1, 0, 2, 3); assert_eq!(Point::new(3, 0), rect.top_right());
pub fn bottom_left(&self) -> Point
[src]
pub fn bottom_left(&self) -> Point
Returns the bottom-left corner of this rectangle.
Example
use sdl2::rect::{Rect, Point}; let rect = Rect::new(1, 0, 2, 3); assert_eq!(Point::new(1, 3), rect.bottom_left());
pub fn bottom_right(&self) -> Point
[src]
pub fn bottom_right(&self) -> Point
Returns the bottom-right corner of this rectangle.
Example
use sdl2::rect::{Rect, Point}; let rect = Rect::new(1, 0, 2, 3); assert_eq!(Point::new(3, 3), rect.bottom_right());
pub fn set_right(&mut self, right: i32)
[src]
pub fn set_right(&mut self, right: i32)
Sets the position of the right side of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.
pub fn set_bottom(&mut self, bottom: i32)
[src]
pub fn set_bottom(&mut self, bottom: i32)
Sets the position of the bottom side of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.
pub fn center_on<P>(&mut self, point: P) where
P: Into<(i32, i32)>,
[src]
pub fn center_on<P>(&mut self, point: P) where
P: Into<(i32, i32)>,
Centers the rectangle on the given point.
pub fn offset(&mut self, x: i32, y: i32)
[src]
pub fn offset(&mut self, x: i32, y: i32)
Move this rect and clamp the positions to prevent over/underflow. This also clamps the size to prevent overflow.
pub fn reposition<P>(&mut self, point: P) where
P: Into<(i32, i32)>,
[src]
pub fn reposition<P>(&mut self, point: P) where
P: Into<(i32, i32)>,
Moves this rect to the given position after clamping the values.
pub fn resize(&mut self, width: u32, height: u32)
[src]
pub fn resize(&mut self, width: u32, height: u32)
Resizes this rect to the given size after clamping the values.
pub fn contains<P>(&self, point: P) -> bool where
P: Into<(i32, i32)>,
[src]
pub fn contains<P>(&self, point: P) -> bool where
P: Into<(i32, i32)>,
: use contains_point
instead
Checks whether this rect contains a given point, or touches it on the
right and/or bottom edges. This method is deprecated in favor of
Rect::contains_point
.
For historical
reasons, this
method differs in behavior from
SDL_PointInRect
by
including points along the bottom and right edges of the rectangle, so
that a 1-by-1 rectangle actually covers an area of four points, not
one.
Examples
use sdl2::rect::{Rect, Point}; let rect = Rect::new(1, 2, 3, 4); assert!(rect.contains(Point::new(1, 2))); assert!(!rect.contains(Point::new(0, 1))); assert!(rect.contains(Point::new(3, 5))); assert!(rect.contains(Point::new(4, 6))); // N.B. assert!(!rect.contains(Point::new(5, 7)));
pub fn contains_point<P>(&self, point: P) -> bool where
P: Into<(i32, i32)>,
[src]
pub fn contains_point<P>(&self, point: P) -> bool where
P: Into<(i32, i32)>,
Checks whether this rectangle contains a given point.
Points along the right and bottom edges are not considered to be inside
the rectangle; this way, a 1-by-1 rectangle contains only a single
point. Another way to look at it is that this method returns true if
and only if the given point would be painted by a call to
Renderer::fill_rect
.
Examples
use sdl2::rect::{Rect, Point}; let rect = Rect::new(1, 2, 3, 4); assert!(rect.contains_point(Point::new(1, 2))); assert!(!rect.contains_point(Point::new(0, 1))); assert!(rect.contains_point(Point::new(3, 5))); assert!(!rect.contains_point(Point::new(4, 6)));
pub fn contains_rect(&self, other: Rect) -> bool
[src]
pub fn contains_rect(&self, other: Rect) -> bool
Checks whether this rectangle completely contains another rectangle.
This method returns true if and only if every point contained by
other
is also contained by self
; in other words, if the
intersection of self
and other
is equal to other
.
Examples
use sdl2::rect::Rect; let rect = Rect::new(1, 2, 3, 4); assert!(rect.contains_rect(rect)); assert!(rect.contains_rect(Rect::new(3, 3, 1, 1))); assert!(!rect.contains_rect(Rect::new(2, 1, 1, 1))); assert!(!rect.contains_rect(Rect::new(3, 3, 2, 1)));
pub fn raw(&self) -> *const SDL_Rect
[src]
pub fn raw(&self) -> *const SDL_Rect
Returns the underlying C Rect.
pub fn raw_mut(&mut self) -> *mut SDL_Rect
[src]
pub fn raw_mut(&mut self) -> *mut SDL_Rect
pub fn raw_slice(slice: &[Rect]) -> *const SDL_Rect
[src]
pub fn raw_slice(slice: &[Rect]) -> *const SDL_Rect
pub fn from_ll(raw: SDL_Rect) -> Rect
[src]
pub fn from_ll(raw: SDL_Rect) -> Rect
pub fn from_enclose_points<R: Into<Option<Rect>>>(
points: &[Point],
clipping_rect: R
) -> Option<Rect> where
R: Into<Option<Rect>>,
[src]
pub fn from_enclose_points<R: Into<Option<Rect>>>(
points: &[Point],
clipping_rect: R
) -> Option<Rect> where
R: Into<Option<Rect>>,
Calculate a minimal rectangle enclosing a set of points. If a clipping rectangle is given, only points that are within it will be considered.
pub fn has_intersection(&self, other: Rect) -> bool
[src]
pub fn has_intersection(&self, other: Rect) -> bool
Determines whether two rectangles intersect.
Rectangles that share an edge but don't actually overlap are not considered to intersect.
Examples
use sdl2::rect::Rect; let rect = Rect::new(0, 0, 5, 5); assert!(rect.has_intersection(rect)); assert!(rect.has_intersection(Rect::new(2, 2, 5, 5))); assert!(!rect.has_intersection(Rect::new(5, 0, 5, 5)));
pub fn intersection(&self, other: Rect) -> Option<Rect>
[src]
pub fn intersection(&self, other: Rect) -> Option<Rect>
Calculates the intersection of two rectangles.
Returns None
if the two rectangles don't intersect. Rectangles that
share an edge but don't actually overlap are not considered to
intersect.
The bitwise AND operator &
can also be used.
Examples
use sdl2::rect::Rect; let rect = Rect::new(0, 0, 5, 5); assert_eq!(rect.intersection(rect), Some(rect)); assert_eq!(rect.intersection(Rect::new(2, 2, 5, 5)), Some(Rect::new(2, 2, 3, 3))); assert_eq!(rect.intersection(Rect::new(5, 0, 5, 5)), None);
pub fn union(&self, other: Rect) -> Rect
[src]
pub fn union(&self, other: Rect) -> Rect
Calculates the union of two rectangles (i.e. the smallest rectangle that contains both).
The bitwise OR operator |
can also be used.
Examples
use sdl2::rect::Rect; let rect = Rect::new(0, 0, 5, 5); assert_eq!(rect.union(rect), rect); assert_eq!(rect.union(Rect::new(2, 2, 5, 5)), Rect::new(0, 0, 7, 7)); assert_eq!(rect.union(Rect::new(5, 0, 5, 5)), Rect::new(0, 0, 10, 5));
pub fn intersect_line(&self, start: Point, end: Point) -> Option<(Point, Point)>
[src]
pub fn intersect_line(&self, start: Point, end: Point) -> Option<(Point, Point)>
Calculates the intersection of a rectangle and a line segment and returns the points of their intersection.
Trait Implementations
impl Debug for Rect
[src]
impl Debug for Rect
fn fmt(&self, f: &mut Formatter) -> Result
[src]
fn fmt(&self, f: &mut Formatter) -> Result
Formats the value using the given formatter. Read more
impl Clone for Rect
[src]
impl Clone for Rect
fn clone(&self) -> Rect
[src]
fn clone(&self) -> Rect
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl Copy for Rect
[src]
impl Copy for Rect
impl PartialEq for Rect
[src]
impl PartialEq for Rect
fn eq(&self, other: &Rect) -> bool
[src]
fn eq(&self, other: &Rect) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
fn ne(&self, other: &Rhs) -> bool
This method tests for !=
.
impl Eq for Rect
[src]
impl Eq for Rect
impl Hash for Rect
[src]
impl Hash for Rect
fn hash<H: Hasher>(&self, state: &mut H)
[src]
fn hash<H: Hasher>(&self, state: &mut H)
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl Deref for Rect
[src]
impl Deref for Rect
type Target = SDL_Rect
The resulting type after dereferencing.
fn deref(&self) -> &SDL_Rect
[src]
fn deref(&self) -> &SDL_Rect
Example
use sdl2::rect::Rect; let rect = Rect::new(2, 3, 4, 5); assert_eq!(2, rect.x);
impl DerefMut for Rect
[src]
impl DerefMut for Rect
fn deref_mut(&mut self) -> &mut SDL_Rect
[src]
fn deref_mut(&mut self) -> &mut SDL_Rect
Example
use sdl2::rect::Rect; let mut rect = Rect::new(2, 3, 4, 5); rect.x = 60; assert_eq!(60, rect.x);
impl Into<SDL_Rect> for Rect
[src]
impl Into<SDL_Rect> for Rect
impl Into<(i32, i32, u32, u32)> for Rect
[src]
impl Into<(i32, i32, u32, u32)> for Rect
impl From<SDL_Rect> for Rect
[src]
impl From<SDL_Rect> for Rect
impl From<(i32, i32, u32, u32)> for Rect
[src]
impl From<(i32, i32, u32, u32)> for Rect
impl AsRef<SDL_Rect> for Rect
[src]
impl AsRef<SDL_Rect> for Rect
impl AsMut<SDL_Rect> for Rect
[src]
impl AsMut<SDL_Rect> for Rect
impl BitAnd<Rect> for Rect
[src]
impl BitAnd<Rect> for Rect
type Output = Option<Rect>
The resulting type after applying the &
operator.
fn bitand(self, rhs: Rect) -> Option<Rect>
[src]
fn bitand(self, rhs: Rect) -> Option<Rect>
Performs the &
operation.
impl BitOr<Rect> for Rect
[src]
impl BitOr<Rect> for Rect