[−][src]Struct euclid::Size2D

#[repr(C)]pub struct Size2D<T, U> {
    pub width: T,
    pub height: T,
    // some fields omitted
}

A 2d size tagged with a unit.

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

`impl<T, U> Size2D<T, U>`[src]

`pub fn zero() -> Self where T: Zero,` [src]

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

`pub const fn new(width: T, height: T) -> Self`[src]

Constructor taking scalar values.

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

Constructor taking scalar strongly typed lengths.

`pub fn from_untyped(p: Size2D<T, UnknownUnit>) -> Self`[src]

Tag a unitless value with units.

`impl<T: Copy, U> Size2D<T, U>`[src]

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

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

`pub fn to_tuple(&self) -> (T, T)`[src]

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

`pub fn to_vector(&self) -> Vector2D<T, U>`[src]

Return this size as a vector with width and height.

`pub fn to_untyped(&self) -> Size2D<T, UnknownUnit>`[src]

Drop the units, preserving only the numeric value.

`pub fn cast_unit<V>(&self) -> Size2D<T, V>`[src]

Cast the unit

`#[must_use]pub fn round(&self) -> Self where T: Round,` [src]

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

`#[must_use]pub fn ceil(&self) -> Self where T: Ceil,` [src]

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

`#[must_use]pub fn floor(&self) -> Self where T: Floor,` [src]

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

`pub fn area(&self) -> T::Output where T: Mul,` [src]

Returns result of multiplication of both components

`pub fn lerp(&self, other: Self, t: T) -> Self where T: One + Sub<Output = T> + Mul<Output = T> + Add<Output = T>,` [src]

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));

`impl<T: NumCast + Copy, U> Size2D<T, U>`[src]

`pub fn cast<NewT: NumCast>(&self) -> Size2D<NewT, U>`[src]

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.

`pub fn try_cast<NewT: NumCast>(&self) -> Option<Size2D<NewT, U>>`[src]

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.

`pub fn to_f32(&self) -> Size2D<f32, U>`[src]

Cast into an f32 size.