Struct FRect

pub struct FRect { /* private fields */ }

Available on crate feature dep_sdl2 only.

A (non-empty) rectangle with float precision.

The width and height of a FRect must always be strictly positive (never zero). In cases where empty rects may need to be represented, it is recommended to use Option<FRect>, with None representing an empty rectangle (see, for example, the output of the intersection method).

Implementations

impl FRect

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

Creates a new rectangle with float precision from the given values.

FRects must always be non-empty, so a width and/or height argument of 0 or less will be replaced with 1.

pub fn from_center<P>(center: P, width: f32, height: f32) -> FRect

where P: Into<FPoint>,

Creates a new rectangle with float precision centered on the given position.

FRects must always be non-empty, so a width and/or height argument of 0 or less will be replaced with 1.

pub fn x(&self) -> f32

The horizontal position of this rectangle.

pub fn y(&self) -> f32

The vertical position of this rectangle.

pub fn width(&self) -> f32

The width of this rectangle.

pub fn height(&self) -> f32

The height of this rectangle.

pub fn size(&self) -> (f32, f32)

Returns the width and height of this rectangle.

pub fn set_x(&mut self, x: f32)

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: f32)

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: f32)

Sets the width of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.

FRects must always be non-empty, so a width argument of 0 will be replaced with 1.

pub fn set_height(&mut self, height: f32)

Sets the height of this rectangle to the given value, clamped to be less than or equal to i32::max_value() / 2.

FRects must always be non-empty, so a height argument of 0 will be replaced with 1.

pub fn left(&self) -> f32

Returns the x-position of the left side of this rectangle.

pub fn right(&self) -> f32

Returns the x-position of the right side of this rectangle.

pub fn top(&self) -> f32

Returns the y-position of the top side of this rectangle.

pub fn bottom(&self) -> f32

Returns the y-position of the bottom side of this rectangle.

pub fn left_shifted(self, offset: f32) -> FRect

Shifts this rectangle to the left by offset.

Example

use sdl2::rect::FRect;
assert_eq!(FRect::new(0.0, 0.0, 10.0, 10.0).left_shifted(5.0), FRect::new(-5.0, 0.0, 10.0, 10.0));

pub fn right_shifted(self, offset: f32) -> FRect

Shifts this rectangle to the right by offset.

Example

use sdl2::rect::FRect;
assert_eq!(FRect::new(0.0, 0.0, 10.0, 10.0).right_shifted(5.0), FRect::new(5.0, 0.0, 10.0, 10.0));

pub fn top_shifted(self, offset: f32) -> FRect

Shifts this rectangle to the top by offset.

Example

use sdl2::rect::FRect;
assert_eq!(FRect::new(0.0, 0.0, 10.0, 10.0).top_shifted(5.00), FRect::new(0.0, -5.0, 10.0, 10.0));

pub fn bottom_shifted(self, offset: f32) -> FRect

Shifts this rectangle to the bottom by offset.

Example

use sdl2::rect::FRect;
assert_eq!(FRect::new(0.0, 0.0, 10.0, 10.0).bottom_shifted(5.0), FRect::new(0.0, 5.0, 10.0, 10.0));

pub fn center(&self) -> FPoint

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::{FRect, FPoint};
let rect = FRect::new(1.0, 0.0, 2.0, 3.0);
assert_eq!(FPoint::new(2.0, 1.5), rect.center());

pub fn top_left(&self) -> FPoint

Returns the top-left corner of this rectangle.

Example

use sdl2::rect::{FRect, FPoint};
let rect = FRect::new(1.0, 0.0, 2.0, 3.0);
assert_eq!(FPoint::new(1.0, 0.0), rect.top_left());

pub fn top_right(&self) -> FPoint

Returns the top-right corner of this rectangle.

Example

use sdl2::rect::{FRect, FPoint};
let rect = FRect::new(1.0, 0.0, 2.0, 3.0);
assert_eq!(FPoint::new(3.0, 0.0), rect.top_right());

pub fn bottom_left(&self) -> FPoint

Returns the bottom-left corner of this rectangle.

Example

use sdl2::rect::{FRect, FPoint};
let rect = FRect::new(1.0, 0.0, 2.0, 3.0);
assert_eq!(FPoint::new(1.0, 3.0), rect.bottom_left());

pub fn bottom_right(&self) -> FPoint

Returns the bottom-right corner of this rectangle.

Example

use sdl2::rect::{FRect, FPoint};
let rect = FRect::new(1.0, 0.0, 2.0, 3.0);
assert_eq!(FPoint::new(3.0, 3.0), rect.bottom_right());

pub fn set_right(&mut self, right: f32)

Sets the position of the right side of this rectangle to the given value, clamped to be greater than 0.

pub fn set_bottom(&mut self, bottom: f32)

Sets the position of the bottom side of this rectangle to the given value, clamped to be greater than 0.

pub fn center_on<P>(&mut self, point: P)

where P: Into<(f32, f32)>,

Centers the rectangle on the given point (in place).

pub fn centered_on<P>(self, point: P) -> FRect

where P: Into<(f32, f32)>,

Centers the rectangle on the given point.

pub fn offset(&mut self, x: f32, y: f32)

Move this rect.

pub fn reposition<P>(&mut self, point: P)

where P: Into<(f32, f32)>,

Moves this rect to the given position.

pub fn resize(&mut self, width: f32, height: f32)

Resizes this rect to the given size after clamping the values.

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

where P: Into<(f32, f32)>,

Checks whether this rectangle contains a given point.

Points along the right and bottom edges are not considered to be inside the rectangle. 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_frect.

Examples

use sdl2::rect::{FRect, FPoint};
let rect = FRect::new(1.0, 2.0, 3.0, 4.0);
assert!(rect.contains_point(FPoint::new(1.0, 2.0)));
assert!(!rect.contains_point(FPoint::new(0.0, 1.0)));
assert!(rect.contains_point(FPoint::new(3.0, 5.0)));
assert!(!rect.contains_point(FPoint::new(4.0, 6.0)));

pub fn contains_rect(&self, other: FRect) -> 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::FRect;
let rect = FRect::new(1.0, 2.0, 3.0, 4.0);
assert!(rect.contains_rect(rect));
assert!(rect.contains_rect(FRect::new(3.0, 3.0, 1.0, 1.0)));
assert!(!rect.contains_rect(FRect::new(2.0, 1.0, 1.0, 1.0)));
assert!(!rect.contains_rect(FRect::new(3.0, 3.0, 2.0, 1.0)));

pub fn raw(&self) -> *const SDL_FRect

Returns the underlying C FRect.

pub fn raw_mut(&mut self) -> *mut SDL_FRect

pub fn raw_slice(slice: &[FRect]) -> *const SDL_FRect

pub fn from_ll(raw: SDL_FRect) -> FRect

pub fn from_enclose_points<R>( points: &[FPoint], clipping_rect: R, ) -> Option<FRect>

where R: Into<Option<FRect>>,

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: FRect) -> 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::FRect;
let rect = FRect::new(0.0, 0.0, 5.0, 5.0);
assert!(rect.has_intersection(rect));
assert!(rect.has_intersection(FRect::new(2.0, 2.0, 5.0, 5.0)));
assert!(!rect.has_intersection(FRect::new(5.0, 0.0, 5.0, 5.0)));

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

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::FRect;
let rect = FRect::new(0.0, 0.0, 5.0, 5.0);
assert_eq!(rect.intersection(rect), Some(rect));
assert_eq!(rect.intersection(FRect::new(2.0, 2.0, 5.0, 5.0)),
           Some(FRect::new(2.0, 2.0, 3.0, 3.0)));
assert_eq!(rect.intersection(FRect::new(5.0, 0.0, 5.0, 5.0)), None);

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

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::FRect;
let rect = FRect::new(0.0, 0.0, 5.0, 5.0);
assert_eq!(rect.union(rect), rect);
assert_eq!(rect.union(FRect::new(2.0, 2.0, 5.0, 5.0)), FRect::new(0.0, 0.0, 7.0, 7.0));
assert_eq!(rect.union(FRect::new(5.0, 0.0, 5.0, 5.0)), FRect::new(0.0, 0.0, 10.0, 5.0));

pub fn intersect_line( &self, start: FPoint, end: FPoint, ) -> Option<(FPoint, FPoint)>

Calculates the intersection of a rectangle and a line segment and returns the points of their intersection.

Trait Implementations

impl AsMut<SDL_FRect> for FRect

fn as_mut(&mut self) -> &mut SDL_FRect

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<SDL_FRect> for FRect

fn as_ref(&self) -> &SDL_FRect

Converts this type into a shared reference of the (usually inferred) input type.

impl BitAnd for FRect

type Output = Option<FRect>

The resulting type after applying the & operator.

fn bitand(self, rhs: FRect) -> Option<FRect>

Performs the & operation.

impl BitOr for FRect

type Output = FRect

The resulting type after applying the | operator.

fn bitor(self, rhs: FRect) -> FRect

Performs the | operation.

impl Clone for FRect

fn clone(&self) -> FRect

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FRect

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

Formats the value using the given formatter.

impl Deref for FRect

fn deref(&self) -> &SDL_FRect

Example

use sdl2::rect::FRect;
let rect = FRect::new(2.0, 3.0, 4.0, 5.0);
assert_eq!(2.0, rect.x);

type Target = SDL_FRect

The resulting type after dereferencing.

impl DerefMut for FRect

fn deref_mut(&mut self) -> &mut SDL_FRect

Example

use sdl2::rect::FRect;
let mut rect = FRect::new(2.0, 3.0, 4.0, 5.0);
rect.x = 60.0;
assert_eq!(60.0, rect.x);

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

fn from(_: (f32, f32, f32, f32)) -> FRect

Converts to this type from the input type.

impl From<SDL_FRect> for FRect

fn from(raw: SDL_FRect) -> FRect

Converts to this type from the input type.

impl Into<(f32, f32, f32, f32)> for FRect

fn into(self) -> (f32, f32, f32, f32)

Converts this type into the (usually inferred) input type.

impl Into<SDL_FRect> for FRect

fn into(self) -> SDL_FRect

Converts this type into the (usually inferred) input type.

impl PartialEq for FRect

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