Struct bevy_internal::math::Rect
source · #[repr(C)]pub struct Rect {
pub min: Vec2,
pub max: Vec2,
}
Expand description
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§
source§impl Rect
impl Rect
sourcepub fn new(x0: f32, y0: f32, x1: f32, y1: f32) -> Rect
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
sourcepub fn from_corners(p0: Vec2, p1: Vec2) -> Rect
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
sourcepub fn from_center_size(origin: Vec2, size: Vec2) -> Rect
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));
sourcepub fn from_center_half_size(origin: Vec2, half_size: Vec2) -> Rect
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));
sourcepub fn is_empty(&self) -> bool
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());
sourcepub fn width(&self) -> f32
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);
sourcepub fn height(&self) -> f32
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);
sourcepub fn size(&self) -> Vec2
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));
sourcepub fn half_size(&self) -> Vec2
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));
sourcepub fn center(&self) -> Vec2
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));
sourcepub fn contains(&self, point: Vec2) -> bool
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));
sourcepub fn union(&self, other: Rect) -> Rect
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));
sourcepub fn union_point(&self, other: Vec2) -> Rect
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));
sourcepub fn intersect(&self, other: Rect) -> Rect
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));
sourcepub fn inset(&self, inset: f32) -> Rect
pub fn inset(&self, inset: f32) -> Rect
Create a new rectangle with a constant inset.
The inset is the extra border on all sides. A positive inset produces a larger rectangle, while a negative inset is allowed and produces a smaller rectangle. If the inset is negative and its absolute value is larger than the rectangle half-size, the created rectangle is empty.
§Examples
let r = Rect::new(0., 0., 5., 1.); // w=5 h=1
let r2 = r.inset(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.inset(-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));
sourcepub fn normalize(&self, other: Rect) -> Rect
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);
Trait Implementations§
source§impl<'de> Deserialize<'de> for Rect
impl<'de> Deserialize<'de> for Rect
source§fn deserialize<__D>(
__deserializer: __D
) -> Result<Rect, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(
__deserializer: __D
) -> Result<Rect, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,
source§impl FromReflect for Rect
impl FromReflect for Rect
source§fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<Rect>
fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<Rect>
Self
from a reflected value.source§fn take_from_reflect(
reflect: Box<dyn Reflect>
) -> Result<Self, Box<dyn Reflect>>
fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>
Self
using,
constructing the value using from_reflect
if that fails. Read moresource§impl GetTypeRegistration for Rect
impl GetTypeRegistration for Rect
source§impl PartialEq for Rect
impl PartialEq for Rect
source§impl Reflect for Rect
impl Reflect for Rect
source§fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut dyn Any
.source§fn into_reflect(self: Box<Rect>) -> Box<dyn Reflect>
fn into_reflect(self: Box<Rect>) -> Box<dyn Reflect>
source§fn as_reflect(&self) -> &(dyn Reflect + 'static)
fn as_reflect(&self) -> &(dyn Reflect + 'static)
source§fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
source§fn clone_value(&self) -> Box<dyn Reflect>
fn clone_value(&self) -> Box<dyn Reflect>
Reflect
trait object. Read moresource§fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>
fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>
source§fn apply(&mut self, value: &(dyn Reflect + 'static))
fn apply(&mut self, value: &(dyn Reflect + 'static))
source§fn reflect_kind(&self) -> ReflectKind
fn reflect_kind(&self) -> ReflectKind
source§fn reflect_ref(&self) -> ReflectRef<'_>
fn reflect_ref(&self) -> ReflectRef<'_>
source§fn reflect_mut(&mut self) -> ReflectMut<'_>
fn reflect_mut(&mut self) -> ReflectMut<'_>
source§fn reflect_owned(self: Box<Rect>) -> ReflectOwned
fn reflect_owned(self: Box<Rect>) -> ReflectOwned
source§fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>
fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>
source§fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
source§fn reflect_hash(&self) -> Option<u64>
fn reflect_hash(&self) -> Option<u64>
source§fn serializable(&self) -> Option<Serializable<'_>>
fn serializable(&self) -> Option<Serializable<'_>>
source§fn is_dynamic(&self) -> bool
fn is_dynamic(&self) -> bool
source§impl Serialize for Rect
impl Serialize for Rect
source§fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,
fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,
source§impl Struct for Rect
impl Struct for Rect
source§fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>
fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>
name
as a &dyn Reflect
.source§fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>
fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>
name
as a
&mut dyn Reflect
.source§fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>
fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>
index
as a
&dyn Reflect
.source§fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>
fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>
index
as a &mut dyn Reflect
.source§fn name_at(&self, index: usize) -> Option<&str>
fn name_at(&self, index: usize) -> Option<&str>
index
.source§fn iter_fields(&self) -> FieldIter<'_> ⓘ
fn iter_fields(&self) -> FieldIter<'_> ⓘ
source§fn clone_dynamic(&self) -> DynamicStruct
fn clone_dynamic(&self) -> DynamicStruct
DynamicStruct
.source§impl TypePath for Rect
impl TypePath for Rect
source§fn type_path() -> &'static str
fn type_path() -> &'static str
source§fn short_type_path() -> &'static str
fn short_type_path() -> &'static str
source§fn type_ident() -> Option<&'static str>
fn type_ident() -> Option<&'static str>
source§fn crate_name() -> Option<&'static str>
fn crate_name() -> Option<&'static str>
impl Copy for Rect
impl StructuralPartialEq for Rect
Auto Trait Implementations§
impl Freeze for Rect
impl RefUnwindSafe for Rect
impl Send for Rect
impl Sync for Rect
impl Unpin for Rect
impl UnwindSafe for Rect
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
source§impl<T> DynamicTypePath for Twhere
T: TypePath,
impl<T> DynamicTypePath for Twhere
T: TypePath,
source§fn reflect_type_path(&self) -> &str
fn reflect_type_path(&self) -> &str
TypePath::type_path
.source§fn reflect_short_type_path(&self) -> &str
fn reflect_short_type_path(&self) -> &str
source§fn reflect_type_ident(&self) -> Option<&str>
fn reflect_type_ident(&self) -> Option<&str>
TypePath::type_ident
.source§fn reflect_crate_name(&self) -> Option<&str>
fn reflect_crate_name(&self) -> Option<&str>
TypePath::crate_name
.source§fn reflect_module_path(&self) -> Option<&str>
fn reflect_module_path(&self) -> Option<&str>
source§impl<T> FromWorld for Twhere
T: Default,
impl<T> FromWorld for Twhere
T: Default,
source§fn from_world(_world: &mut World) -> T
fn from_world(_world: &mut World) -> T
Self
using data from the given World
.source§impl<S> GetField for Swhere
S: Struct,
impl<S> GetField for Swhere
S: Struct,
source§impl<T> GetPath for T
impl<T> GetPath for T
source§fn reflect_path<'p>(
&self,
path: impl ReflectPath<'p>
) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path<'p>( &self, path: impl ReflectPath<'p> ) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>
path
. Read moresource§fn reflect_path_mut<'p>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p> ) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>
path
. Read moresource§fn path<'p, T>(
&self,
path: impl ReflectPath<'p>
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
fn path<'p, T>(
&self,
path: impl ReflectPath<'p>
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
path
. Read moresource§fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
path
. Read more