Struct Aabb2d

pub struct Aabb2d {
    pub min: Vec2,
    pub max: Vec2,
}

A 2D axis-aligned bounding box, or bounding rectangle

Fields

min: Vec2

The minimum, conventionally bottom-left, point of the box

max: Vec2

The maximum, conventionally top-right, point of the box

Implementations

impl Aabb2d

pub fn new(center: Vec2, half_size: Vec2) -> Aabb2d

Constructs an AABB from its center and half-size.

pub fn from_point_cloud( isometry: impl Into<Isometry2d>, points: &[Vec2], ) -> Aabb2d

Computes the smallest Aabb2d containing the given set of points, transformed by the rotation and translation of the given isometry.

Panics

Panics if the given set of points is empty.

pub fn bounding_circle(&self) -> BoundingCircle

Computes the smallest BoundingCircle containing this Aabb2d.

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

Finds the point on the AABB that is closest to the given point.

If the point is outside the AABB, the returned point will be on the perimeter of the AABB. Otherwise, it will be inside the AABB and returned as is.

Trait Implementations

impl BoundingVolume for Aabb2d

fn transformed_by( self, translation: impl Into<<Aabb2d as BoundingVolume>::Translation>, rotation: impl Into<<Aabb2d as BoundingVolume>::Rotation>, ) -> Aabb2d

Transforms the bounding volume by first rotating it around the origin and then applying a translation.

The result is an Axis-Aligned Bounding Box that encompasses the rotated shape.

Note that the result may not be as tightly fitting as the original, and repeated rotations can cause the AABB to grow indefinitely. Avoid applying multiple rotations to the same AABB, and consider storing the original AABB and rotating that every time instead.

fn transform_by( &mut self, translation: impl Into<<Aabb2d as BoundingVolume>::Translation>, rotation: impl Into<<Aabb2d as BoundingVolume>::Rotation>, )

Transforms the bounding volume by first rotating it around the origin and then applying a translation.

The result is an Axis-Aligned Bounding Box that encompasses the rotated shape.

Note that the result may not be as tightly fitting as the original, and repeated rotations can cause the AABB to grow indefinitely. Avoid applying multiple rotations to the same AABB, and consider storing the original AABB and rotating that every time instead.

fn rotated_by( self, rotation: impl Into<<Aabb2d as BoundingVolume>::Rotation>, ) -> Aabb2d

Rotates the bounding volume around the origin by the given rotation.

The result is an Axis-Aligned Bounding Box that encompasses the rotated shape.

Note that the result may not be as tightly fitting as the original, and repeated rotations can cause the AABB to grow indefinitely. Avoid applying multiple rotations to the same AABB, and consider storing the original AABB and rotating that every time instead.

fn rotate_by( &mut self, rotation: impl Into<<Aabb2d as BoundingVolume>::Rotation>, )

Rotates the bounding volume around the origin by the given rotation.

The result is an Axis-Aligned Bounding Box that encompasses the rotated shape.

Note that the result may not be as tightly fitting as the original, and repeated rotations can cause the AABB to grow indefinitely. Avoid applying multiple rotations to the same AABB, and consider storing the original AABB and rotating that every time instead.

type Translation = Vec2

The position type used for the volume. This should be Vec2 for 2D and Vec3 for 3D.

type Rotation = Rot2

The rotation type used for the volume. This should be f32 for 2D and Quat for 3D.

type HalfSize = Vec2

The type used for the size of the bounding volume. Usually a half size. For example an f32 radius for a circle, or a Vec3 with half sizes for x, y and z for a 3D axis-aligned bounding box

fn center(&self) -> <Aabb2d as BoundingVolume>::Translation

Returns the center of the bounding volume.

fn half_size(&self) -> <Aabb2d as BoundingVolume>::HalfSize

Returns the half size of the bounding volume.

fn visible_area(&self) -> f32

Computes the visible surface area of the bounding volume. This method can be useful to make decisions about merging bounding volumes, using a Surface Area Heuristic.

fn contains(&self, other: &Aabb2d) -> bool

Checks if this bounding volume contains another one.

fn merge(&self, other: &Aabb2d) -> Aabb2d

Computes the smallest bounding volume that contains both self and other.

fn grow( &self, amount: impl Into<<Aabb2d as BoundingVolume>::HalfSize>, ) -> Aabb2d

Increases the size of the bounding volume in each direction by the given amount.

fn shrink( &self, amount: impl Into<<Aabb2d as BoundingVolume>::HalfSize>, ) -> Aabb2d

Decreases the size of the bounding volume in each direction by the given amount.

fn scale_around_center( &self, scale: impl Into<<Aabb2d as BoundingVolume>::HalfSize>, ) -> Aabb2d

Scale the size of the bounding volume around its center by the given amount

fn translate_by( &mut self, translation: impl Into<<Aabb2d as BoundingVolume>::Translation>, )

Translates the bounding volume by the given translation.

fn translated_by(self, translation: impl Into<Self::Translation>) -> Self

Translates the bounding volume by the given translation.

impl Clone for Aabb2d

fn clone(&self) -> Aabb2d

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Aabb2d

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

Formats the value using the given formatter.

impl FromReflect for Aabb2d

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

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

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 Aabb2d

where Aabb2d: 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 IntersectsVolume<Aabb2d> for Aabb2d

fn intersects(&self, other: &Aabb2d) -> bool

Check if a volume intersects with this intersection test

impl IntersectsVolume<Aabb2d> for AabbCast2d

fn intersects(&self, volume: &Aabb2d) -> bool

Check if a volume intersects with this intersection test

impl IntersectsVolume<Aabb2d> for BoundingCircle

fn intersects(&self, aabb: &Aabb2d) -> bool

Check if a volume intersects with this intersection test

impl IntersectsVolume<Aabb2d> for RayCast2d

fn intersects(&self, volume: &Aabb2d) -> bool

Check if a volume intersects with this intersection test

impl IntersectsVolume<BoundingCircle> for Aabb2d

fn intersects(&self, circle: &BoundingCircle) -> bool

Check if a volume intersects with this intersection test

impl PartialReflect for Aabb2d

where Aabb2d: 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 clone_value(&self) -> Box<dyn PartialReflect>

Clones the value as a Reflect trait object.

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<Aabb2d>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Aabb2d>, ) -> 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<Aabb2d>) -> 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 apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

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

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

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for Aabb2d

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

fn into_any(self: Box<Aabb2d>) -> 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<Aabb2d>) -> 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 Struct for Aabb2d

where Aabb2d: 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 clone_dynamic(&self) -> DynamicStruct

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 Aabb2d

where Aabb2d: 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 Aabb2d

where Aabb2d: 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 Aabb2d