Struct rgx::math::size::Size

pub struct Size<T = f32> {
    pub w: T,
    pub h: T,
}

Size.

Fields

w: T

Width.

h: T

Height.

Implementations

impl<T> Size<T>

pub fn map<S>(self, f: impl Fn(T) -> S) -> Size<S>

Map a size to another size.

impl<T: Sized> Size<T>

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

Create a new size.

impl Size<f32>

pub fn expand(self) -> Size

Returns a new Size, with width and height rounded away from zero to the nearest integer, unless they are already an integer.

Examples

use rgx::math::Size;

let size_pos = Size::new(3.3, 3.6).expand();
assert_eq!(size_pos.w, 4.0);
assert_eq!(size_pos.h, 4.0);

let size_neg = Size::new(-3.3, -3.6).expand();
assert_eq!(size_neg.w, -4.0);
assert_eq!(size_neg.h, -4.0);

pub fn is_empty(self) -> bool

Whether this size has zero area.

Note: a size with negative area is not considered empty.

pub fn clamp(self, min: Size, max: Size) -> Self

Returns a new size bounded by min and max.

Examples

use rgx::math::Size;

let this = Size::new(0., 100.);
let min = Size::new(10., 10.,);
let max = Size::new(50., 50.);

assert_eq!(this.clamp(min, max), Size::new(10., 50.))

impl<T: Mul<Output = T>> Size<T>

pub fn area(self) -> T

The area covered by this size.

Trait Implementations

impl<T: Add<Output = T>> Add<Size<T>> for Point2D<T>

type Output = Point2D<T, ()>

The resulting type after applying the + operator.

fn add(self, other: Size<T>) -> Self

Performs the + operation.

impl<T: Clone> Clone for Size<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Size<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Size<T>

fn default() -> Size<T>

Returns the “default value” for a type.

impl Div<f32> for Size<f32>

type Output = Size<f32>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl<T> From<[T; 2]> for Size<T>

fn from([w, h]: [T; 2]) -> Self

Converts to this type from the input type.

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

fn from((w, h): (T, T)) -> Self

Converts to this type from the input type.

impl From<LogicalSize> for Size

fn from(other: LogicalSize) -> Self

Converts to this type from the input type.

impl<T> From<Size<T>> for [T; 2]

fn from(size: Size<T>) -> Self

Converts to this type from the input type.

impl From<Size<u32>> for Size<f32>

fn from(other: Size<u32>) -> Self

Converts to this type from the input type.

impl From<Size<usize>> for Size<u32>

fn from(other: Size<usize>) -> Self

Converts to this type from the input type.

impl<T: Copy> From<T> for Size<T>

fn from(n: T) -> Self

Converts to this type from the input type.

impl<T> From<Vector2D<T, ()>> for Size<T>

fn from(other: Vector2D<T>) -> Self

Converts to this type from the input type.

impl<T: Mul<Output = T> + Copy> Mul<T> for Size<T>

type Output = Size<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T: PartialEq> PartialEq<Size<T>> for Size<T>

fn eq(&self, other: &Size<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: Zero + PartialEq> Zero for Size<T>

const ZERO: Self = _

fn is_zero(&self) -> bool

impl<T: Copy> Copy for Size<T>

impl<T: Eq> Eq for Size<T>

impl<T> StructuralEq for Size<T>

impl<T> StructuralPartialEq for Size<T>