Struct geng::prelude::Aabb2

pub struct Aabb2<T> {
    pub min: vec2<T>,
    pub max: vec2<T>,
}

2d Axis aligned bounding box.

Fields

min: vec2<T>

Minimum coordinates

max: vec2<T>

Maximum coordinates

Implementations

impl<T> Aabb2<T>

where T: Copy,

pub fn bottom_left(&self) -> vec2<T>

Get the bottom-left corner of the Aabb2.

pub fn bottom_right(&self) -> vec2<T>

Get the bottom-right corner of the Aabb2.

pub fn top_left(&self) -> vec2<T>

Get the top-left corner of the Aabb2.

pub fn top_right(&self) -> vec2<T>

Get the top-right corner of the Aabb2.

pub fn corners(&self) -> [vec2<T>; 4]

Get an array of all four corner points

impl<T> Aabb2<T>

where T: UNum,

pub const ZERO: Aabb2<T> = _

An Aabb2 with both position and size equal to (0, 0).

pub fn from_corners(p1: vec2<T>, p2: vec2<T>) -> Aabb2<T>

Construct an Aabb2 from two opposite corners. The two corners can be given in any order.

Examples

let aabb = Aabb2::from_corners(vec2(-5.0, -5.0), vec2(5.0, 5.0));
let same = Aabb2::from_corners(vec2(5.0, -5.0), vec2(-5.0, 5.0));
assert_eq!(aabb, same);

pub fn point(point: vec2<T>) -> Aabb2<T>

Create an Aabb2 at given position of size (0, 0).

Examples

assert_eq!(Aabb2::<f32>::ZERO, Aabb2::point(vec2::ZERO));

pub fn extend_uniform(self, extend: T) -> Aabb2<T>

Extend boundaries of the Aabb2 by a given value in each direction.

Examples

let aabb = Aabb2::point(vec2(5, 5)).extend_uniform(10);
assert_eq!(aabb, Aabb2::from_corners(vec2(-5, -5), vec2(15, 15)));

pub fn extend_symmetric(self, extend: vec2<T>) -> Aabb2<T>

Extend the boundaries equally right and left and equally up and down

Examples

let aabb = Aabb2::ZERO.extend_symmetric(vec2(10, 5));
let same = Aabb2::from_corners(vec2(-10, -5), vec2(10, 5));
assert_eq!(aabb, same);

pub fn extend_positive(self, extend: vec2<T>) -> Aabb2<T>

Extend the boundaries to the right and up by the given values

Examples

let aabb = Aabb2::point(vec2(-10.0, -5.0)).extend_positive(vec2(20.0, 10.0));
let same = Aabb2::ZERO.extend_symmetric(vec2(10.0, 5.0));
assert_eq!(aabb, same);

pub fn extend_left(self, extend: T) -> Aabb2<T>

Extend the left edge of the Aabb2 by a given value.

pub fn extend_right(self, extend: T) -> Aabb2<T>

Extend the right edge of the Aabb2 by a given value.

pub fn extend_up(self, extend: T) -> Aabb2<T>

Extend the top edge of the Aabb2 by a given value.

pub fn extend_down(self, extend: T) -> Aabb2<T>

Extend the bottom edge of the Aabb2 by a given value.

pub fn normalized(self) -> Aabb2<T>

Ensure that the Aabb2 has positive size

Examples

let original = Aabb2::point(vec2(10.0, 5.0)).extend_positive(vec2(-20.0, -10.0));
let normalized = Aabb2::ZERO.extend_symmetric(vec2(10.0, 5.0));
assert_eq!(original.normalized(), normalized);

pub fn center(&self) -> vec2<T>

Get the center position of the Aabb2.

pub fn map<U, F>(self, f: F) -> Aabb2<U>

where U: UNum, F: Fn(T) -> U,

Map every value (coordinate) of the Aabb2.

pub fn zip<U>(self, other: Aabb2<U>) -> Aabb2<(T, U)>

Zip every value (coordinate) with another Aabb2

pub fn map_bounds<U, F>(self, f: F) -> Aabb2<U>

where U: UNum, F: Fn(vec2<T>) -> vec2<U>,

Map bounds (min & max vectors)

pub fn width(&self) -> T

Returns the width of the Aabb2.

pub fn height(&self) -> T

Returns the height of the Aabb2.

pub fn size(&self) -> vec2<T>

Return the size of the Aabb2.

pub fn contains(&self, point: vec2<T>) -> bool

Check if a point is inside the Aabb2.

Examples

let rect = Aabb2::from_corners(vec2(1, 2), vec2(3, 4));
assert!(rect.contains(vec2(2, 3)));
assert!(!rect.contains(vec2(5, 5)));

pub fn intersects(&self, other: &Aabb2<T>) -> bool

Checks whether two Aabb2’s intersect.

pub fn translate(self, v: vec2<T>) -> Aabb2<T>

Moves the Aabb2 by a given vector.

pub fn points(self) -> impl Iterator<Item = vec2<T>>

where Range<T>: Iterator<Item = T>,

Returns an iterator over points inside the Aabb2.

pub fn points_bounding_box( points: impl IntoIterator<Item = vec2<T>> ) -> Option<Aabb2<T>>

Returns the smallest possible Aabb2 such that it contains all the points.

Examples

let aabb = Aabb2::points_bounding_box([
    vec2(3, 0),
    vec2(0, -2),
    vec2(1, 4),
    vec2(-1, -1),
    vec2(0, 3),
]).unwrap();
assert_eq!(aabb, Aabb2 { min: vec2(-1, -2), max: vec2(3, 4) });

Trait Implementations

impl<T> Clone for Aabb2<T>

where T: Clone,

fn clone(&self) -> Aabb2<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Aabb2<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Aabb2<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> FitTarget2d<T> for Aabb2<T>

where T: Float,

fn make_fit(&self, object: &mut impl Transform2d<T>)

Make given object’s bounding Quad fit into self

impl<T> PartialEq for Aabb2<T>

where T: PartialEq,

fn eq(&self, other: &Aabb2<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for Aabb2<T>

where T: Serialize,

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<T> Copy for Aabb2<T>

where T: Copy,

impl<T> Eq for Aabb2<T>

where T: Eq,

impl<T> StructuralEq for Aabb2<T>

impl<T> StructuralPartialEq for Aabb2<T>