Struct Vec2 

#[repr(C)]
pub struct Vec2(pub f32, pub f32);

2D vector

Usually used as either a coordinate or a difference of coordinates, but may have some other uses.

Vec2 implements PartialOrd such that the comparison must be true of all components: for example a < b == a.0 < b.0 && a.1 < b.1. If c == Vec2(0, 1) and d == Vec2(1, 0) then c != d && !(c < d) && !(c > d). Vec2 does not implement Ord.

Tuple Fields

0: f32

1: f32

Implementations

impl Vec2

pub const ZERO: Vec2

Zero

pub const ONE: Vec2

One

pub const NEG_INFINITY: Vec2

Negative infinity

pub const INFINITY: Vec2

Positive infinity

pub const NAN: Vec2

Not a Number (NaN)

pub const fn splat(value: f32) -> Self

Constructs a new instance with each element initialized to value.

pub fn min_comp(self) -> f32

Take the minimum component

pub fn max_comp(self) -> f32

Take the maximum component

pub fn min(self, other: Self) -> Self

Return the minimum, componentwise

pub fn max(self, other: Self) -> Self

Return the maximum, componentwise

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

Restrict a value to a certain interval unless it is NaN

Returns max if self is greater than max, and min if self is less than min. Otherwise this returns self.

Note that this function returns NaN if the initial value was NaN as well.

Panics

Panics if min > max, min is NaN, or max is NaN.

pub fn abs(self) -> Self

Take the absolute value of each component

pub fn floor(self) -> Self

Take the floor of each component

pub fn ceil(self) -> Self

Take the ceiling of each component

pub fn round(self) -> Self

Round each component to the nearest integer

pub fn trunc(self) -> Self

Take the trunc of each component

pub fn fract(self) -> Self

Take the fract of each component

pub fn sign(self) -> Self

For each component, return ±1 with the same sign as self.

pub fn complex_mul(self, rhs: Self) -> Self

Multiply two vectors as if they are complex numbers

pub fn complex_div(self, rhs: Self) -> Self

Divide by a second vector as if they are complex numbers

pub fn complex_inv(self) -> Self

Take the complex reciprocal

If both components are zero then the result will not be finite.

pub fn sum(self) -> f32

Return the sum of the terms

pub fn sum_square(self) -> f32

Return the sum of the square of the terms

pub fn distance_l1(self) -> f32

Return the L1 (rectilinear / taxicab) distance

pub fn distance_l_inf(self) -> f32

Return the L-inf (max) distance

pub fn extract<D: Directional>(self, dir: D) -> f32

Extract one component, based on a direction

This merely extracts the horizontal or vertical component. It never negates it, even if the axis is reversed.

pub fn is_finite(self) -> bool

Returns true if all components are neither infinite nor NaN

pub fn is_normal(self) -> bool

Returns true if no components are zero, infinite, submormal or NaN

Trait Implementations

impl Add<Vec2> for Quad

type Output = Quad

The resulting type after applying the + operator.

fn add(self, rhs: Vec2) -> Self::Output

Performs the + operation.

impl Add<f32> for Vec2

type Output = Vec2

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Vec2

type Output = Vec2

The resulting type after applying the + operator.

fn add(self, rhs: Vec2) -> Self::Output

Performs the + operation.

impl AddAssign<Vec2> for Quad

fn add_assign(&mut self, rhs: Vec2)

Performs the += operation.

impl AddAssign<f32> for Vec2

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl AddAssign for Vec2

fn add_assign(&mut self, rhs: Vec2)

Performs the += operation.

impl Clone for Vec2

fn clone(&self) -> Vec2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Conv<(f32, f32)> for Vec2

fn conv(arg: (f32, f32)) -> Self

Convert from T to Self

fn try_conv(v: (f32, f32)) -> Result<Self>

Try converting from T to Self

impl Conv<Coord> for Vec2

fn try_conv(arg: Coord) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Offset> for Vec2

fn try_conv(arg: Offset) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for Vec2

fn try_conv(arg: Size) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Vec2> for (f32, f32)

fn conv(v: Vec2) -> Self

Convert from T to Self

fn try_conv(v: Vec2) -> Result<Self>

Try converting from T to Self

impl Conv<Vec2> for DVec2

fn try_conv(v: Vec2) -> Result<DVec2>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Vec2> for Vec2

fn conv(size: Vec2) -> Self

Convert from T to Self

fn try_conv(v: Vec2) -> Result<Self>

Try converting from T to Self

impl Conv<Vec2> for Vec2

fn conv(size: Vec2) -> Vec2

Convert from T to Self

fn try_conv(v: Vec2) -> Result<Self>

Try converting from T to Self

impl ConvApprox<DVec2> for Vec2

fn try_conv_approx(size: DVec2) -> Result<Vec2>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvApprox<Vec2> for Coord

fn try_conv_approx(arg: Vec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvApprox<Vec2> for Offset

fn try_conv_approx(arg: Vec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvApprox<Vec2> for Size

fn try_conv_approx(arg: Vec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvFloat<Vec2> for Coord

fn try_conv_trunc(x: Vec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: Vec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: Vec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: Vec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl ConvFloat<Vec2> for Offset

fn try_conv_trunc(x: Vec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: Vec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: Vec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: Vec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl ConvFloat<Vec2> for Size

fn try_conv_trunc(x: Vec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: Vec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: Vec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: Vec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl Debug for Vec2

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

Formats the value using the given formatter.

impl Default for Vec2

fn default() -> Vec2

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Vec2

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<f32> for Vec2

type Output = Vec2

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for Vec2

type Output = Vec2

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<f32> for Vec2

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl From<(f32, f32)> for Vec2

fn from(arg: (f32, f32)) -> Self

Converts to this type from the input type.

impl From<LogicalSize> for Vec2

fn from(LogicalSize: LogicalSize) -> Self

Converts to this type from the input type.

impl From<PhysicalPosition<f32>> for Vec2

fn from(pos: PhysicalPosition<f32>) -> Self

Converts to this type from the input type.

impl From<PhysicalSize<f32>> for Vec2

fn from(size: PhysicalSize<f32>) -> Self

Converts to this type from the input type.

impl From<Vec2> for (f32, f32)

fn from(v: Vec2) -> Self

Converts to this type from the input type.

impl From<Vec2> for DVec2

fn from(v: Vec2) -> DVec2

Converts to this type from the input type.

impl From<Vec2> for LogicalSize

fn from(Vec2: Vec2) -> Self

Converts to this type from the input type.

impl From<Vec2> for Vec2

fn from(size: Vec2) -> Self

Converts to this type from the input type.

impl From<Vec2> for Vec2

fn from(size: Vec2) -> Vec2

Converts to this type from the input type.

impl Mul<f32> for Vec2

type Output = Vec2

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Vec2

type Output = Vec2

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<f32> for Vec2

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign for Vec2

fn mul_assign(&mut self, rhs: Vec2)

Performs the *= operation.

impl Neg for Vec2

type Output = Vec2

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq<Coord> for Vec2

fn eq(&self, rhs: &Coord) -> 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 PartialEq for Vec2

fn eq(&self, other: &Vec2) -> 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 PartialOrd<Coord> for Vec2

fn partial_cmp(&self, rhs: &Coord) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &Coord) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &Coord) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn ge(&self, rhs: &Coord) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

fn gt(&self, rhs: &Coord) -> bool

Tests greater than (for self and other) and is used by the > operator.

impl PartialOrd for Vec2

fn partial_cmp(&self, rhs: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &Self) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &Self) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn ge(&self, rhs: &Self) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

fn gt(&self, rhs: &Self) -> bool

Tests greater than (for self and other) and is used by the > operator.

impl Serialize for Vec2

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<Vec2> for Quad

type Output = Quad

The resulting type after applying the - operator.

fn sub(self, rhs: Vec2) -> Self::Output

Performs the - operation.

impl Sub<f32> for Vec2

type Output = Vec2

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Vec2

type Output = Vec2

The resulting type after applying the - operator.

fn sub(self, rhs: Vec2) -> Self::Output

Performs the - operation.

impl SubAssign<Vec2> for Quad

fn sub_assign(&mut self, rhs: Vec2)

Performs the -= operation.

impl SubAssign<f32> for Vec2

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl SubAssign for Vec2

fn sub_assign(&mut self, rhs: Vec2)

Performs the -= operation.

impl Copy for Vec2

impl StructuralPartialEq for Vec2