Struct Bounds2D

pub struct Bounds2D<T> { /* private fields */ }

A two-dimensional bounding box.

Implementations

impl<T> Bounds2D<T>

where T: Copy,

pub fn new(x: T, y: T, width: T, height: T) -> Self

Creates a new Bounds2D. In most cases you should use the bounds!() macro instead.

Examples

let bounds = Bounds2D::new(20, 50, 80, 90);

// Prefer doing this instead
let bounds = bounds!(20, 50, 80, 90);

pub fn splat(value: T) -> Self

Returns a new Bounds2D where all components are set to value.

Prefer using the splat syntax with the macro instead of calling this directly.

Examples

// This is acceptable, but...
let bounds = Bounds2D::splat(8);

// ...this is the preferred way
let bounds = bounds!(8; 2);

assert_eq!(bounds, bounds!(8, 8, 8, 8));

pub fn from_position_and_size<P, S>(position: P, size: S) -> Self

where P: ToPoint2D<T>, S: ToSize2D<T>,

Creates a new Bounds2D from a position and size. This is useful when you have a size and position, and want to create a bounds out of it.

However, if you already have a Size2D or a Point2D, you should use the .with_ method instead.

Examples

let bounds = Bounds2D::from_position_and_size(point!(20, 40), size!(10, 10));

// Prefer doing this instead
let bounds = point!(20, 40).with_size(size!(10, 10));

pub fn with_position<P: ToPoint2D<T>>(&self, point: P) -> Bounds2D<T>

Creates a new Bounds2D with the specified position.

pub fn with_size<S: ToSize2D<T>>(&self, size: S) -> Bounds2D<T>

Creates a new Bounds2D with the specified size.

pub fn width(&self) -> T

pub fn height(&self) -> T

pub fn top(&self) -> T

pub fn left(&self) -> T

pub fn right(&self) -> T

where T: Add<Output = T>,

pub fn bottom(&self) -> T

where T: Add<Output = T>,

pub fn area(&self) -> T

where T: Mul<Output = T>,

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

pub fn position(&self) -> Point2D<T>

impl<T> Bounds2D<T>

where T: Num + Copy + Ord,

pub fn grow<S: ToSize2D<T>>(&self, size: S) -> Bounds2D<T>

See Size2D::grow() for more information.

pub fn shrink<S: ToSize2D<T>>(&self, size: S) -> Bounds2D<T>

See Size2D::shrink() for more information.

pub fn constrain<S: ToSize2D<T>>(&self, min: S, max: S) -> Bounds2D<T>

See Size2D::constrain() for more information.

pub fn max_area<S: ToSize2D<T>>(&self, size: S) -> Bounds2D<T>

See Size2D::max_area() for more information.

pub fn min_area<S: ToSize2D<T>>(&self, size: S) -> Bounds2D<T>

See Size2D::min_area() for more information.

pub fn clamp_area<S: ToSize2D<T>>(&self, min: S, max: S) -> Bounds2D<T>

See Size2D::clamp_area() for more information.

Trait Implementations

impl<T> Add<Size2D<T>> for Bounds2D<T>

where T: Num + Copy,

type Output = Bounds2D<T>

The resulting type after applying the + operator.

fn add(self, rhs: Size2D<T>) -> Self::Output

Performs the + operation.

impl<T> Add<Vector2D<T, Offset>> for Bounds2D<T>

where T: Num + Copy,

type Output = Bounds2D<T>

The resulting type after applying the + operator.

fn add(self, rhs: Offset2D<T>) -> Self::Output

Performs the + operation.

impl<T: Clone> Clone for Bounds2D<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Bounds2D<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Bounds2D<T>

fn default() -> Bounds2D<T>

Returns the “default value” for a type.

impl<T> From<Bounds2D<T>> for [T; 4]

fn from(bounds: Bounds2D<T>) -> Self

Converts to this type from the input type.

impl<T> From<Bounds2D<T>> for (T, T, T, T)

fn from(bounds: Bounds2D<T>) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for Bounds2D<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> IntoBounds2D<T> for Bounds2D<T>

fn to_bounds(self) -> Bounds2D<T>

impl<T: PartialEq> PartialEq for Bounds2D<T>

fn eq(&self, other: &Bounds2D<T>) -> 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<T> Sub<Size2D<T>> for Bounds2D<T>

where T: Num + Copy,

type Output = Bounds2D<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Size2D<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<Vector2D<T, Offset>> for Bounds2D<T>

where T: Num + Copy,

type Output = Bounds2D<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Offset2D<T>) -> Self::Output

Performs the - operation.

impl<T: Copy> Copy for Bounds2D<T>

impl<T> StructuralPartialEq for Bounds2D<T>