Type Alias euclid::default::Size2D

source ·

pub type Size2D<T> = Size2D<T, UnknownUnit>;

Aliased Type§

struct Size2D<T> {
    pub width: T,
    pub height: T,
    /* private fields */
}

Fields§

§width: T

The extent of the element in the U units along the x axis (usually horizontal).

§height: T

The extent of the element in the U units along the y axis (usually vertical).

Implementations§

source §

impl<T, U> Size2D<T, U>

source

pub fn zero() -> Selfwhere T: Zero,

The same as Zero::zero() but available without importing trait.

source

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

Constructor taking scalar values.

source

pub fn from_lengths(width: Length<T, U>, height: Length<T, U>) -> Self

Constructor taking scalar strongly typed lengths.

source

pub fn splat(v: T) -> Selfwhere T: Clone,

Constructor setting all components to the same value.

source

pub fn from_untyped(p: Size2D<T, UnknownUnit>) -> Self

Tag a unitless value with units.

source §

impl<T: Copy, U> Size2D<T, U>

source

pub fn to_array(self) -> [T; 2]

Return this size as an array of two elements (width, then height).

source

pub fn to_tuple(self) -> (T, T)

Return this size as a tuple of two elements (width, then height).

source

pub fn to_vector(self) -> Vector2D<T, U>

Return this size as a vector with width and height.

source

pub fn to_untyped(self) -> Size2D<T, UnknownUnit>

Drop the units, preserving only the numeric value.

source

pub fn cast_unit<V>(self) -> Size2D<T, V>

Cast the unit

source

pub fn round(self) -> Selfwhere T: Round,

Rounds each component to the nearest integer value.

This behavior is preserved for negative values (unlike the basic cast).

enum Mm {}

assert_eq!(size2::<_, Mm>(-0.1, -0.8).round(), size2::<_, Mm>(0.0, -1.0))

source

pub fn ceil(self) -> Selfwhere T: Ceil,

Rounds each component to the smallest integer equal or greater than the original value.

This behavior is preserved for negative values (unlike the basic cast).

enum Mm {}

assert_eq!(size2::<_, Mm>(-0.1, -0.8).ceil(), size2::<_, Mm>(0.0, 0.0))

source

pub fn floor(self) -> Selfwhere T: Floor,

Rounds each component to the biggest integer equal or lower than the original value.

This behavior is preserved for negative values (unlike the basic cast).

enum Mm {}

assert_eq!(size2::<_, Mm>(-0.1, -0.8).floor(), size2::<_, Mm>(-1.0, -1.0))

source

pub fn area(self) -> T::Outputwhere T: Mul,

Returns result of multiplication of both components

source

pub fn lerp(self, other: Self, t: T) -> Selfwhere T: One + Sub<Output = T> + Mul<Output = T> + Add<Output = T>,

Linearly interpolate each component between this size and another size.

Example

use euclid::size2;
use euclid::default::Size2D;

let from: Size2D<_> = size2(0.0, 10.0);
let to:  Size2D<_> = size2(8.0, -4.0);

assert_eq!(from.lerp(to, -1.0), size2(-8.0,  24.0));
assert_eq!(from.lerp(to,  0.0), size2( 0.0,  10.0));
assert_eq!(from.lerp(to,  0.5), size2( 4.0,   3.0));
assert_eq!(from.lerp(to,  1.0), size2( 8.0,  -4.0));
assert_eq!(from.lerp(to,  2.0), size2(16.0, -18.0));

source §

impl<T: NumCast + Copy, U> Size2D<T, U>

source

pub fn cast<NewT: NumCast>(self) -> Size2D<NewT, U>

Cast from one numeric representation to another, preserving the units.

When casting from floating point to integer coordinates, the decimals are truncated as one would expect from a simple cast, but this behavior does not always make sense geometrically. Consider using round(), ceil() or floor() before casting.

source

pub fn try_cast<NewT: NumCast>(self) -> Option<Size2D<NewT, U>>

Fallible cast from one numeric representation to another, preserving the units.

When casting from floating point to integer coordinates, the decimals are truncated as one would expect from a simple cast, but this behavior does not always make sense geometrically. Consider using round(), ceil() or floor() before casting.

source

pub fn to_f32(self) -> Size2D<f32, U>

Cast into an f32 size.

source

pub fn to_f64(self) -> Size2D<f64, U>

Cast into an f64 size.

source