Struct Rect 

#[repr(C)]
pub struct Rect {
    pub min: Vec2,
    pub max: Vec2,
}

A rectangle defined by two opposite corners.

The rectangle is axis aligned, and defined by its minimum and maximum coordinates, stored in Rect::min and Rect::max, respectively. The minimum/maximum invariant must be upheld by the user when directly assigning the fields, otherwise some methods produce invalid results. It is generally recommended to use one of the constructor methods instead, which will ensure this invariant is met, unless you already have the minimum and maximum corners.

Fields

min: Vec2

The minimum corner point of the rect.

max: Vec2

The maximum corner point of the rect.

Implementations

impl Rect

pub const EMPTY: Rect

An empty Rect, represented by maximum and minimum corner points at Vec2::NEG_INFINITY and Vec2::INFINITY, respectively. This is so the Rect has a infinitely negative size. This is useful, because when taking a union B of a non-empty Rect A and this empty Rect, B will simply equal A.

pub fn new(x0: f32, y0: f32, x1: f32, y1: f32) -> Rect

Create a new rectangle from two corner points.

The two points do not need to be the minimum and/or maximum corners. They only need to be two opposite corners.

Examples

let r = Rect::new(0., 4., 10., 6.); // w=10 h=2
let r = Rect::new(2., 3., 5., -1.); // w=3 h=4

pub fn from_corners(p0: Vec2, p1: Vec2) -> Rect

Create a new rectangle from two corner points.

The two points do not need to be the minimum and/or maximum corners. They only need to be two opposite corners.

Examples

// Unit rect from [0,0] to [1,1]
let r = Rect::from_corners(Vec2::ZERO, Vec2::ONE); // w=1 h=1
// Same; the points do not need to be ordered
let r = Rect::from_corners(Vec2::ONE, Vec2::ZERO); // w=1 h=1

pub fn from_center_size(origin: Vec2, size: Vec2) -> Rect

Create a new rectangle from its center and size.

Panics

This method panics if any of the components of the size is negative.

Examples

let r = Rect::from_center_size(Vec2::ZERO, Vec2::ONE); // w=1 h=1
assert!(r.min.abs_diff_eq(Vec2::splat(-0.5), 1e-5));
assert!(r.max.abs_diff_eq(Vec2::splat(0.5), 1e-5));

pub fn from_center_half_size(origin: Vec2, half_size: Vec2) -> Rect

Create a new rectangle from its center and half-size.

Panics

This method panics if any of the components of the half-size is negative.

Examples

let r = Rect::from_center_half_size(Vec2::ZERO, Vec2::ONE); // w=2 h=2
assert!(r.min.abs_diff_eq(Vec2::splat(-1.), 1e-5));
assert!(r.max.abs_diff_eq(Vec2::splat(1.), 1e-5));

pub fn is_empty(&self) -> bool

Check if the rectangle is empty.

Examples

let r = Rect::from_corners(Vec2::ZERO, Vec2::new(0., 1.)); // w=0 h=1
assert!(r.is_empty());

pub fn width(&self) -> f32

Rectangle width (max.x - min.x).

Examples

let r = Rect::new(0., 0., 5., 1.); // w=5 h=1
assert!((r.width() - 5.).abs() <= 1e-5);

pub fn height(&self) -> f32

Rectangle height (max.y - min.y).

Examples

let r = Rect::new(0., 0., 5., 1.); // w=5 h=1
assert!((r.height() - 1.).abs() <= 1e-5);

pub fn size(&self) -> Vec2

Rectangle size.

Examples

let r = Rect::new(0., 0., 5., 1.); // w=5 h=1
assert!(r.size().abs_diff_eq(Vec2::new(5., 1.), 1e-5));

pub fn half_size(&self) -> Vec2

Rectangle half-size.

Examples

let r = Rect::new(0., 0., 5., 1.); // w=5 h=1
assert!(r.half_size().abs_diff_eq(Vec2::new(2.5, 0.5), 1e-5));

pub fn center(&self) -> Vec2

The center point of the rectangle.

Examples

let r = Rect::new(0., 0., 5., 1.); // w=5 h=1
assert!(r.center().abs_diff_eq(Vec2::new(2.5, 0.5), 1e-5));

pub fn contains(&self, point: Vec2) -> bool

Check if a point lies within this rectangle, inclusive of its edges.

Examples

let r = Rect::new(0., 0., 5., 1.); // w=5 h=1
assert!(r.contains(r.center()));
assert!(r.contains(r.min));
assert!(r.contains(r.max));

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

Build a new rectangle formed of the union of this rectangle and another rectangle.

The union is the smallest rectangle enclosing both rectangles.

Examples

let r1 = Rect::new(0., 0., 5., 1.); // w=5 h=1
let r2 = Rect::new(1., -1., 3., 3.); // w=2 h=4
let r = r1.union(r2);
assert!(r.min.abs_diff_eq(Vec2::new(0., -1.), 1e-5));
assert!(r.max.abs_diff_eq(Vec2::new(5., 3.), 1e-5));

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

Build a new rectangle formed of the union of this rectangle and a point.

The union is the smallest rectangle enclosing both the rectangle and the point. If the point is already inside the rectangle, this method returns a copy of the rectangle.

Examples

let r = Rect::new(0., 0., 5., 1.); // w=5 h=1
let u = r.union_point(Vec2::new(3., 6.));
assert!(u.min.abs_diff_eq(Vec2::ZERO, 1e-5));
assert!(u.max.abs_diff_eq(Vec2::new(5., 6.), 1e-5));

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

Build a new rectangle formed of the intersection of this rectangle and another rectangle.

The intersection is the largest rectangle enclosed in both rectangles. If the intersection is empty, this method returns an empty rectangle (Rect::is_empty() returns true), but the actual values of Rect::min and Rect::max are implementation-dependent.

Examples

let r1 = Rect::new(0., 0., 5., 1.); // w=5 h=1
let r2 = Rect::new(1., -1., 3., 3.); // w=2 h=4
let r = r1.intersect(r2);
assert!(r.min.abs_diff_eq(Vec2::new(1., 0.), 1e-5));
assert!(r.max.abs_diff_eq(Vec2::new(3., 1.), 1e-5));

pub fn inflate(&self, expansion: f32) -> Rect

Create a new rectangle by expanding it evenly on all sides.

A positive expansion value produces a larger rectangle, while a negative expansion value produces a smaller rectangle. If this would result in zero or negative width or height, Rect::EMPTY is returned instead.

Examples

let r = Rect::new(0., 0., 5., 1.); // w=5 h=1
let r2 = r.inflate(3.); // w=11 h=7
assert!(r2.min.abs_diff_eq(Vec2::splat(-3.), 1e-5));
assert!(r2.max.abs_diff_eq(Vec2::new(8., 4.), 1e-5));

let r = Rect::new(0., -1., 6., 7.); // w=6 h=8
let r2 = r.inflate(-2.); // w=11 h=7
assert!(r2.min.abs_diff_eq(Vec2::new(2., 1.), 1e-5));
assert!(r2.max.abs_diff_eq(Vec2::new(4., 5.), 1e-5));

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

Build a new rectangle from this one with its coordinates expressed relative to other in a normalized ([0..1] x [0..1]) coordinate system.

Examples

let r = Rect::new(2., 3., 4., 6.);
let s = Rect::new(0., 0., 10., 10.);
let n = r.normalize(s);

assert_eq!(n.min.x, 0.2);
assert_eq!(n.min.y, 0.3);
assert_eq!(n.max.x, 0.4);
assert_eq!(n.max.y, 0.6);

pub fn as_irect(&self) -> IRect

Returns self as IRect (i32)

pub fn as_urect(&self) -> URect

Returns self as URect (u32)

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

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

Formats the value using the given formatter.

impl Default for Rect

fn default() -> Rect

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Rect

fn deserialize<__D>( __deserializer: __D, ) -> Result<Rect, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromReflect for Rect

where Rect: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<Rect>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for Rect

where Rect: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl PartialEq for Rect

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

where Rect: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Rect>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Rect>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Rect>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn clone_value(&self) -> Box<dyn PartialReflect>

👎Deprecated since 0.16.0: to clone reflected values, prefer using reflect_clone. To convert reflected values to dynamic ones, use to_dynamic.

Clones Self into its dynamic representation.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for Rect

where Rect: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_any(self: Box<Rect>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Rect>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Serialize for Rect

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Struct for Rect

where Rect: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> DynamicStruct

fn clone_dynamic(&self) -> DynamicStruct

👎Deprecated since 0.16.0: use to_dynamic_struct instead

Clones the struct into a DynamicStruct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for Rect

where Rect: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for Rect

where Rect: Any + Send + Sync, Vec2: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for Rect

impl StructuralPartialEq for Rect