```
#[repr(C)]pub struct DVec2 {
pub x: f64,
pub y: f64,
}
```

## Expand description

A 2-dimensional vector.

## Fields§

§`x: f64`

§`y: f64`

## Implementations§

source§### impl DVec2

### impl DVec2

source#### pub const NEG_INFINITY: Self = _

#### pub const NEG_INFINITY: Self = _

All `f64::NEG_INFINITY`

.

source#### pub fn map<F>(self, f: F) -> Selfwhere
F: Fn(f64) -> f64,

#### pub fn map<F>(self, f: F) -> Selfwhere F: Fn(f64) -> f64,

Returns a vector containing each element of `self`

modified by a mapping function `f`

.

source#### pub fn select(mask: BVec2, if_true: Self, if_false: Self) -> Self

#### pub fn select(mask: BVec2, if_true: Self, if_false: Self) -> Self

Creates a vector from the elements in `if_true`

and `if_false`

, selecting which to use
for each element of `self`

.

A true element in the mask uses the corresponding element from `if_true`

, and false
uses the element from `if_false`

.

source#### pub const fn from_array(a: [f64; 2]) -> Self

#### pub const fn from_array(a: [f64; 2]) -> Self

Creates a new vector from an array.

source#### pub const fn from_slice(slice: &[f64]) -> Self

#### pub const fn from_slice(slice: &[f64]) -> Self

Creates a vector from the first 2 values in `slice`

.

##### Panics

Panics if `slice`

is less than 2 elements long.

source#### pub fn write_to_slice(self, slice: &mut [f64])

#### pub fn write_to_slice(self, slice: &mut [f64])

Writes the elements of `self`

to the first 2 elements in `slice`

.

##### Panics

Panics if `slice`

is less than 2 elements long.

source#### pub const fn extend(self, z: f64) -> DVec3

#### pub const fn extend(self, z: f64) -> DVec3

Creates a 3D vector from `self`

and the given `z`

value.

source#### pub fn dot_into_vec(self, rhs: Self) -> Self

#### pub fn dot_into_vec(self, rhs: Self) -> Self

Returns a vector where every component is the dot product of `self`

and `rhs`

.

source#### pub fn min(self, rhs: Self) -> Self

#### pub fn min(self, rhs: Self) -> Self

Returns a vector containing the minimum values for each element of `self`

and `rhs`

.

In other words this computes `[self.x.min(rhs.x), self.y.min(rhs.y), ..]`

.

source#### pub fn max(self, rhs: Self) -> Self

#### pub fn max(self, rhs: Self) -> Self

Returns a vector containing the maximum values for each element of `self`

and `rhs`

.

In other words this computes `[self.x.max(rhs.x), self.y.max(rhs.y), ..]`

.

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

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

Component-wise clamping of values, similar to `f64::clamp`

.

Each element in `min`

must be less-or-equal to the corresponding element in `max`

.

##### Panics

Will panic if `min`

is greater than `max`

when `glam_assert`

is enabled.

source#### pub fn min_element(self) -> f64

#### pub fn min_element(self) -> f64

Returns the horizontal minimum of `self`

.

In other words this computes `min(x, y, ..)`

.

source#### pub fn max_element(self) -> f64

#### pub fn max_element(self) -> f64

Returns the horizontal maximum of `self`

.

In other words this computes `max(x, y, ..)`

.

source#### pub fn element_sum(self) -> f64

#### pub fn element_sum(self) -> f64

Returns the sum of all elements of `self`

.

In other words, this computes `self.x + self.y + ..`

.

source#### pub fn element_product(self) -> f64

#### pub fn element_product(self) -> f64

Returns the product of all elements of `self`

.

In other words, this computes `self.x * self.y * ..`

.

source#### pub fn cmpeq(self, rhs: Self) -> BVec2

#### pub fn cmpeq(self, rhs: Self) -> BVec2

Returns a vector mask containing the result of a `==`

comparison for each element of
`self`

and `rhs`

.

In other words, this computes `[self.x == rhs.x, self.y == rhs.y, ..]`

for all
elements.

source#### pub fn cmpne(self, rhs: Self) -> BVec2

#### pub fn cmpne(self, rhs: Self) -> BVec2

Returns a vector mask containing the result of a `!=`

comparison for each element of
`self`

and `rhs`

.

In other words this computes `[self.x != rhs.x, self.y != rhs.y, ..]`

for all
elements.

source#### pub fn cmpge(self, rhs: Self) -> BVec2

#### pub fn cmpge(self, rhs: Self) -> BVec2

Returns a vector mask containing the result of a `>=`

comparison for each element of
`self`

and `rhs`

.

In other words this computes `[self.x >= rhs.x, self.y >= rhs.y, ..]`

for all
elements.

source#### pub fn cmpgt(self, rhs: Self) -> BVec2

#### pub fn cmpgt(self, rhs: Self) -> BVec2

Returns a vector mask containing the result of a `>`

comparison for each element of
`self`

and `rhs`

.

In other words this computes `[self.x > rhs.x, self.y > rhs.y, ..]`

for all
elements.

source#### pub fn cmple(self, rhs: Self) -> BVec2

#### pub fn cmple(self, rhs: Self) -> BVec2

Returns a vector mask containing the result of a `<=`

comparison for each element of
`self`

and `rhs`

.

In other words this computes `[self.x <= rhs.x, self.y <= rhs.y, ..]`

for all
elements.

source#### pub fn cmplt(self, rhs: Self) -> BVec2

#### pub fn cmplt(self, rhs: Self) -> BVec2

Returns a vector mask containing the result of a `<`

comparison for each element of
`self`

and `rhs`

.

In other words this computes `[self.x < rhs.x, self.y < rhs.y, ..]`

for all
elements.

source#### pub fn abs(self) -> Self

#### pub fn abs(self) -> Self

Returns a vector containing the absolute value of each element of `self`

.

source#### pub fn signum(self) -> Self

#### pub fn signum(self) -> Self

Returns a vector with elements representing the sign of `self`

.

`1.0`

if the number is positive,`+0.0`

or`INFINITY`

`-1.0`

if the number is negative,`-0.0`

or`NEG_INFINITY`

`NAN`

if the number is`NAN`

source#### pub fn copysign(self, rhs: Self) -> Self

#### pub fn copysign(self, rhs: Self) -> Self

Returns a vector with signs of `rhs`

and the magnitudes of `self`

.

source#### pub fn is_negative_bitmask(self) -> u32

#### pub fn is_negative_bitmask(self) -> u32

Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`

.

A negative element results in a `1`

bit and a positive element in a `0`

bit. Element `x`

goes
into the first lowest bit, element `y`

into the second, etc.

source#### pub fn is_finite(self) -> bool

#### pub fn is_finite(self) -> bool

Returns `true`

if, and only if, all elements are finite. If any element is either
`NaN`

, positive or negative infinity, this will return `false`

.

source#### pub fn is_finite_mask(self) -> BVec2

#### pub fn is_finite_mask(self) -> BVec2

Performs `is_finite`

on each element of self, returning a vector mask of the results.

In other words, this computes `[x.is_finite(), y.is_finite(), ...]`

.

source#### pub fn is_nan_mask(self) -> BVec2

#### pub fn is_nan_mask(self) -> BVec2

Performs `is_nan`

on each element of self, returning a vector mask of the results.

In other words, this computes `[x.is_nan(), y.is_nan(), ...]`

.

source#### pub fn length_squared(self) -> f64

#### pub fn length_squared(self) -> f64

Computes the squared length of `self`

.

This is faster than `length()`

as it avoids a square root operation.

source#### pub fn length_recip(self) -> f64

#### pub fn length_recip(self) -> f64

Computes `1.0 / length()`

.

For valid results, `self`

must *not* be of length zero.

source#### pub fn distance(self, rhs: Self) -> f64

#### pub fn distance(self, rhs: Self) -> f64

Computes the Euclidean distance between two points in space.

source#### pub fn distance_squared(self, rhs: Self) -> f64

#### pub fn distance_squared(self, rhs: Self) -> f64

Compute the squared euclidean distance between two points in space.

source#### pub fn div_euclid(self, rhs: Self) -> Self

#### pub fn div_euclid(self, rhs: Self) -> Self

Returns the element-wise quotient of [Euclidean division] of `self`

by `rhs`

.

source#### pub fn rem_euclid(self, rhs: Self) -> Self

#### pub fn rem_euclid(self, rhs: Self) -> Self

Returns the element-wise remainder of Euclidean division of `self`

by `rhs`

.

source#### pub fn normalize(self) -> Self

#### pub fn normalize(self) -> Self

Returns `self`

normalized to length 1.0.

For valid results, `self`

must be finite and *not* of length zero, nor very close to zero.

See also `Self::try_normalize()`

and `Self::normalize_or_zero()`

.

Panics

Will panic if the resulting normalized vector is not finite when `glam_assert`

is enabled.

source#### pub fn try_normalize(self) -> Option<Self>

#### pub fn try_normalize(self) -> Option<Self>

Returns `self`

normalized to length 1.0 if possible, else returns `None`

.

In particular, if the input is zero (or very close to zero), or non-finite,
the result of this operation will be `None`

.

See also `Self::normalize_or_zero()`

.

source#### pub fn normalize_or(self, fallback: Self) -> Self

#### pub fn normalize_or(self, fallback: Self) -> Self

Returns `self`

normalized to length 1.0 if possible, else returns a
fallback value.

In particular, if the input is zero (or very close to zero), or non-finite, the result of this operation will be the fallback value.

See also `Self::try_normalize()`

.

source#### pub fn normalize_or_zero(self) -> Self

#### pub fn normalize_or_zero(self) -> Self

Returns `self`

normalized to length 1.0 if possible, else returns zero.

In particular, if the input is zero (or very close to zero), or non-finite, the result of this operation will be zero.

See also `Self::try_normalize()`

.

source#### pub fn is_normalized(self) -> bool

#### pub fn is_normalized(self) -> bool

Returns whether `self`

is length `1.0`

or not.

Uses a precision threshold of approximately `1e-4`

.

source#### pub fn project_onto(self, rhs: Self) -> Self

#### pub fn project_onto(self, rhs: Self) -> Self

Returns the vector projection of `self`

onto `rhs`

.

`rhs`

must be of non-zero length.

##### Panics

Will panic if `rhs`

is zero length when `glam_assert`

is enabled.

source#### pub fn reject_from(self, rhs: Self) -> Self

#### pub fn reject_from(self, rhs: Self) -> Self

Returns the vector rejection of `self`

from `rhs`

.

The vector rejection is the vector perpendicular to the projection of `self`

onto
`rhs`

, in rhs words the result of `self - self.project_onto(rhs)`

.

`rhs`

must be of non-zero length.

##### Panics

Will panic if `rhs`

has a length of zero when `glam_assert`

is enabled.

source#### pub fn project_onto_normalized(self, rhs: Self) -> Self

#### pub fn project_onto_normalized(self, rhs: Self) -> Self

Returns the vector projection of `self`

onto `rhs`

.

`rhs`

must be normalized.

##### Panics

Will panic if `rhs`

is not normalized when `glam_assert`

is enabled.

source#### pub fn reject_from_normalized(self, rhs: Self) -> Self

#### pub fn reject_from_normalized(self, rhs: Self) -> Self

Returns the vector rejection of `self`

from `rhs`

.

The vector rejection is the vector perpendicular to the projection of `self`

onto
`rhs`

, in rhs words the result of `self - self.project_onto(rhs)`

.

`rhs`

must be normalized.

##### Panics

Will panic if `rhs`

is not normalized when `glam_assert`

is enabled.

source#### pub fn round(self) -> Self

#### pub fn round(self) -> Self

Returns a vector containing the nearest integer to a number for each element of `self`

.
Round half-way cases away from 0.0.

source#### pub fn floor(self) -> Self

#### pub fn floor(self) -> Self

Returns a vector containing the largest integer less than or equal to a number for each
element of `self`

.

source#### pub fn ceil(self) -> Self

#### pub fn ceil(self) -> Self

Returns a vector containing the smallest integer greater than or equal to a number for
each element of `self`

.

source#### pub fn trunc(self) -> Self

#### pub fn trunc(self) -> Self

Returns a vector containing the integer part each element of `self`

. This means numbers are
always truncated towards zero.

source#### pub fn fract(self) -> Self

#### pub fn fract(self) -> Self

Returns a vector containing the fractional part of the vector as `self - self.trunc()`

.

Note that this differs from the GLSL implementation of `fract`

which returns
`self - self.floor()`

.

Note that this is fast but not precise for large numbers.

source#### pub fn fract_gl(self) -> Self

#### pub fn fract_gl(self) -> Self

Returns a vector containing the fractional part of the vector as `self - self.floor()`

.

Note that this differs from the Rust implementation of `fract`

which returns
`self - self.trunc()`

.

Note that this is fast but not precise for large numbers.

source#### pub fn exp(self) -> Self

#### pub fn exp(self) -> Self

Returns a vector containing `e^self`

(the exponential function) for each element of
`self`

.

source#### pub fn powf(self, n: f64) -> Self

#### pub fn powf(self, n: f64) -> Self

Returns a vector containing each element of `self`

raised to the power of `n`

.

source#### pub fn recip(self) -> Self

#### pub fn recip(self) -> Self

Returns a vector containing the reciprocal `1.0/n`

of each element of `self`

.

source#### pub fn lerp(self, rhs: Self, s: f64) -> Self

#### pub fn lerp(self, rhs: Self, s: f64) -> Self

Performs a linear interpolation between `self`

and `rhs`

based on the value `s`

.

When `s`

is `0.0`

, the result will be equal to `self`

. When `s`

is `1.0`

, the result
will be equal to `rhs`

. When `s`

is outside of range `[0, 1]`

, the result is linearly
extrapolated.

source#### pub fn move_towards(&self, rhs: Self, d: f64) -> Self

#### pub fn move_towards(&self, rhs: Self, d: f64) -> Self

Moves towards `rhs`

based on the value `d`

.

When `d`

is `0.0`

, the result will be equal to `self`

. When `d`

is equal to
`self.distance(rhs)`

, the result will be equal to `rhs`

. Will not go past `rhs`

.

source#### pub fn midpoint(self, rhs: Self) -> Self

#### pub fn midpoint(self, rhs: Self) -> Self

Calculates the midpoint between `self`

and `rhs`

.

The midpoint is the average of, or halfway point between, two vectors.
`a.midpoint(b)`

should yield the same result as `a.lerp(b, 0.5)`

while being slightly cheaper to compute.

source#### pub fn abs_diff_eq(self, rhs: Self, max_abs_diff: f64) -> bool

#### pub fn abs_diff_eq(self, rhs: Self, max_abs_diff: f64) -> bool

Returns true if the absolute difference of all elements between `self`

and `rhs`

is
less than or equal to `max_abs_diff`

.

This can be used to compare if two vectors contain similar elements. It works best when
comparing with a known value. The `max_abs_diff`

that should be used used depends on
the values being compared against.

For more see comparing floating point numbers.

source#### pub fn clamp_length(self, min: f64, max: f64) -> Self

#### pub fn clamp_length(self, min: f64, max: f64) -> Self

Returns a vector with a length no less than `min`

and no more than `max`

.

##### Panics

Will panic if `min`

is greater than `max`

, or if either `min`

or `max`

is negative, when `glam_assert`

is enabled.

source#### pub fn clamp_length_max(self, max: f64) -> Self

#### pub fn clamp_length_max(self, max: f64) -> Self

Returns a vector with a length no more than `max`

.

##### Panics

Will panic if `max`

is negative when `glam_assert`

is enabled.

source#### pub fn clamp_length_min(self, min: f64) -> Self

#### pub fn clamp_length_min(self, min: f64) -> Self

Returns a vector with a length no less than `min`

.

##### Panics

Will panic if `min`

is negative when `glam_assert`

is enabled.

source#### pub fn mul_add(self, a: Self, b: Self) -> Self

#### pub fn mul_add(self, a: Self, b: Self) -> Self

Fused multiply-add. Computes `(self * a) + b`

element-wise with only one rounding
error, yielding a more accurate result than an unfused multiply-add.

Using `mul_add`

*may* be more performant than an unfused multiply-add if the target
architecture has a dedicated fma CPU instruction. However, this is not always true,
and will be heavily dependant on designing algorithms with specific target hardware in
mind.

source#### pub fn reflect(self, normal: Self) -> Self

#### pub fn reflect(self, normal: Self) -> Self

Returns the reflection vector for a given incident vector `self`

and surface normal
`normal`

.

`normal`

must be normalized.

##### Panics

Will panic if `normal`

is not normalized when `glam_assert`

is enabled.

source#### pub fn refract(self, normal: Self, eta: f64) -> Self

#### pub fn refract(self, normal: Self, eta: f64) -> Self

Returns the refraction direction for a given incident vector `self`

, surface normal
`normal`

and ratio of indices of refraction, `eta`

. When total internal reflection occurs,
a zero vector will be returned.

`self`

and `normal`

must be normalized.

##### Panics

Will panic if `self`

or `normal`

is not normalized when `glam_assert`

is enabled.

source#### pub fn from_angle(angle: f64) -> Self

#### pub fn from_angle(angle: f64) -> Self

source#### pub fn to_angle(self) -> f64

#### pub fn to_angle(self) -> f64

Returns the angle (in radians) of this vector in the range `[-π, +π]`

.

The input does not need to be a unit vector however it must be non-zero.

#### pub fn angle_between(self, rhs: Self) -> f64

source#### pub fn angle_to(self, rhs: Self) -> f64

#### pub fn angle_to(self, rhs: Self) -> f64

Returns the angle of rotation (in radians) from `self`

to `rhs`

in the range `[-π, +π]`

.

The inputs do not need to be unit vectors however they must be non-zero.

source#### pub fn perp_dot(self, rhs: Self) -> f64

#### pub fn perp_dot(self, rhs: Self) -> f64

The perpendicular dot product of `self`

and `rhs`

.
Also known as the wedge product, 2D cross product, and determinant.

source#### pub fn rotate(self, rhs: Self) -> Self

#### pub fn rotate(self, rhs: Self) -> Self

Returns `rhs`

rotated by the angle of `self`

. If `self`

is normalized,
then this just rotation. This is what you usually want. Otherwise,
it will be like a rotation with a multiplication by `self`

’s length.

source#### pub fn rotate_towards(&self, rhs: Self, max_angle: f64) -> Self

#### pub fn rotate_towards(&self, rhs: Self, max_angle: f64) -> Self

Rotates towards `rhs`

up to `max_angle`

(in radians).

When `max_angle`

is `0.0`

, the result will be equal to `self`

. When `max_angle`

is equal to
`self.angle_between(rhs)`

, the result will be equal to `rhs`

. If `max_angle`

is negative,
rotates towards the exact opposite of `rhs`

. Will not go past the target.

source#### pub fn as_i16vec2(&self) -> I16Vec2

#### pub fn as_i16vec2(&self) -> I16Vec2

Casts all elements of `self`

to `i16`

.

source#### pub fn as_u16vec2(&self) -> U16Vec2

#### pub fn as_u16vec2(&self) -> U16Vec2

Casts all elements of `self`

to `u16`

.

source#### pub fn as_i64vec2(&self) -> I64Vec2

#### pub fn as_i64vec2(&self) -> I64Vec2

Casts all elements of `self`

to `i64`

.

source#### pub fn as_u64vec2(&self) -> U64Vec2

#### pub fn as_u64vec2(&self) -> U64Vec2

Casts all elements of `self`

to `u64`

.

## Trait Implementations§

source§### impl AddAssign<&DVec2> for DVec2

### impl AddAssign<&DVec2> for DVec2

source§#### fn add_assign(&mut self, rhs: &Self)

#### fn add_assign(&mut self, rhs: &Self)

`+=`

operation. Read moresource§### impl AddAssign<&f64> for DVec2

### impl AddAssign<&f64> for DVec2

source§#### fn add_assign(&mut self, rhs: &f64)

#### fn add_assign(&mut self, rhs: &f64)

`+=`

operation. Read moresource§### impl AddAssign<DVec2> for DVec2

### impl AddAssign<DVec2> for DVec2

source§#### fn add_assign(&mut self, rhs: Self)

#### fn add_assign(&mut self, rhs: Self)

`+=`

operation. Read moresource§### impl AddAssign<f64> for DVec2

### impl AddAssign<f64> for DVec2

source§#### fn add_assign(&mut self, rhs: f64)

#### fn add_assign(&mut self, rhs: f64)

`+=`

operation. Read moresource§### impl DivAssign<&DVec2> for DVec2

### impl DivAssign<&DVec2> for DVec2

source§#### fn div_assign(&mut self, rhs: &Self)

#### fn div_assign(&mut self, rhs: &Self)

`/=`

operation. Read moresource§### impl DivAssign<&f64> for DVec2

### impl DivAssign<&f64> for DVec2

source§#### fn div_assign(&mut self, rhs: &f64)

#### fn div_assign(&mut self, rhs: &f64)

`/=`

operation. Read moresource§### impl DivAssign<DVec2> for DVec2

### impl DivAssign<DVec2> for DVec2

source§#### fn div_assign(&mut self, rhs: Self)

#### fn div_assign(&mut self, rhs: Self)

`/=`

operation. Read moresource§### impl DivAssign<f64> for DVec2

### impl DivAssign<f64> for DVec2

source§#### fn div_assign(&mut self, rhs: f64)

#### fn div_assign(&mut self, rhs: f64)

`/=`

operation. Read moresource§### impl MulAssign<&DVec2> for DVec2

### impl MulAssign<&DVec2> for DVec2

source§#### fn mul_assign(&mut self, rhs: &Self)

#### fn mul_assign(&mut self, rhs: &Self)

`*=`

operation. Read moresource§### impl MulAssign<&f64> for DVec2

### impl MulAssign<&f64> for DVec2

source§#### fn mul_assign(&mut self, rhs: &f64)

#### fn mul_assign(&mut self, rhs: &f64)

`*=`

operation. Read moresource§### impl MulAssign<DVec2> for DVec2

### impl MulAssign<DVec2> for DVec2

source§#### fn mul_assign(&mut self, rhs: Self)

#### fn mul_assign(&mut self, rhs: Self)

`*=`

operation. Read moresource§### impl MulAssign<f64> for DVec2

### impl MulAssign<f64> for DVec2

source§#### fn mul_assign(&mut self, rhs: f64)

#### fn mul_assign(&mut self, rhs: f64)

`*=`

operation. Read moresource§### impl PartialEq<DVec2> for DVec2

### impl PartialEq<DVec2> for DVec2

source§### impl RemAssign<&DVec2> for DVec2

### impl RemAssign<&DVec2> for DVec2

source§#### fn rem_assign(&mut self, rhs: &Self)

#### fn rem_assign(&mut self, rhs: &Self)

`%=`

operation. Read moresource§### impl RemAssign<&f64> for DVec2

### impl RemAssign<&f64> for DVec2

source§#### fn rem_assign(&mut self, rhs: &f64)

#### fn rem_assign(&mut self, rhs: &f64)

`%=`

operation. Read moresource§### impl RemAssign<DVec2> for DVec2

### impl RemAssign<DVec2> for DVec2

source§#### fn rem_assign(&mut self, rhs: Self)

#### fn rem_assign(&mut self, rhs: Self)

`%=`

operation. Read moresource§### impl RemAssign<f64> for DVec2

### impl RemAssign<f64> for DVec2

source§#### fn rem_assign(&mut self, rhs: f64)

#### fn rem_assign(&mut self, rhs: f64)

`%=`

operation. Read moresource§### impl SubAssign<&DVec2> for DVec2

### impl SubAssign<&DVec2> for DVec2

source§#### fn sub_assign(&mut self, rhs: &Self)

#### fn sub_assign(&mut self, rhs: &Self)

`-=`

operation. Read moresource§### impl SubAssign<&f64> for DVec2

### impl SubAssign<&f64> for DVec2

source§#### fn sub_assign(&mut self, rhs: &f64)

#### fn sub_assign(&mut self, rhs: &f64)

`-=`

operation. Read moresource§### impl SubAssign<DVec2> for DVec2

### impl SubAssign<DVec2> for DVec2

source§#### fn sub_assign(&mut self, rhs: DVec2)

#### fn sub_assign(&mut self, rhs: DVec2)

`-=`

operation. Read moresource§### impl SubAssign<f64> for DVec2

### impl SubAssign<f64> for DVec2

source§#### fn sub_assign(&mut self, rhs: f64)

#### fn sub_assign(&mut self, rhs: f64)

`-=`

operation. Read more