```
#[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: DVec2 = _

#### pub const NEG_INFINITY: DVec2 = _

All `f64::NEG_INFINITY`

.

source#### pub const fn new(x: f64, y: f64) -> DVec2

#### pub const fn new(x: f64, y: f64) -> DVec2

Creates a new vector.

##### Examples found in repository?

## More examples

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

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

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

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

Creates a new vector from an array.

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

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

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

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

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

and `rhs`

.

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

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

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

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

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: DVec2, max: DVec2) -> DVec2

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

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: DVec2) -> BVec2

#### pub fn cmpeq(self, rhs: DVec2) -> 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: DVec2) -> BVec2

#### pub fn cmpne(self, rhs: DVec2) -> 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: DVec2) -> BVec2

#### pub fn cmpge(self, rhs: DVec2) -> 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: DVec2) -> BVec2

#### pub fn cmpgt(self, rhs: DVec2) -> 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: DVec2) -> BVec2

#### pub fn cmple(self, rhs: DVec2) -> 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: DVec2) -> BVec2

#### pub fn cmplt(self, rhs: DVec2) -> 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) -> DVec2

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

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

.

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

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

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

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

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_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(), z.is_nan(), w.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: DVec2) -> f64

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

Computes the Euclidean distance between two points in space.

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

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

Compute the squared euclidean distance between two points in space.

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

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

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

by `rhs`

.

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

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

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

by `rhs`

.

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

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

Returns `self`

normalized to length 1.0.

For valid results, `self`

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

See also `Self::try_normalize()`

and `Self::normalize_or_zero()`

.

Panics

Will panic if `self`

is zero length when `glam_assert`

is enabled.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

.

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

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

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

.

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

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

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

. This means numbers are
always truncated towards zero.

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

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

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

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

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

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

Returns a vector containing `e^self`

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

.

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

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

Returns a vector containing each element of `self`

raised to the power of `n`

.

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

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

Returns a vector containing the reciprocal `1.0/n`

of each element of `self`

.

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

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

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: DVec2, d: f64) -> DVec2

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

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

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

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: DVec2, max_abs_diff: f64) -> bool

#### pub fn abs_diff_eq(self, rhs: DVec2, 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) -> DVec2

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

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

and no more than `max`

##### §Panics

Will panic if `min`

is greater than `max`

when `glam_assert`

is enabled.

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

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

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

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

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

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

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

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

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 from_angle(angle: f64) -> DVec2

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

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.

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

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

Returns the angle (in radians) between `self`

and `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: DVec2) -> f64

#### pub fn perp_dot(self, rhs: DVec2) -> 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: DVec2) -> DVec2

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

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 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<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 for DVec2

### impl AddAssign for DVec2

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

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

`+=`

operation. Read more§### impl Animatable for DVec2

### impl Animatable for DVec2

§#### fn blend(inputs: impl Iterator<Item = BlendInput<DVec2>>) -> DVec2

#### fn blend(inputs: impl Iterator<Item = BlendInput<DVec2>>) -> DVec2

§#### fn post_process(&mut self, _world: &World)

#### fn post_process(&mut self, _world: &World)

`World`

.
Most animatable types do not need to implement this.source§### impl<'de> Deserialize<'de> for DVec2

### impl<'de> Deserialize<'de> for DVec2

source§#### fn deserialize<D>(
deserializer: D,
) -> Result<DVec2, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,

#### fn deserialize<D>(
deserializer: D,
) -> Result<DVec2, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,

source§### 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 for DVec2

### impl DivAssign for DVec2

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

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

`/=`

operation. Read more§### impl From<DVec2> for WindowResolution

### impl From<DVec2> for WindowResolution

§#### fn from(res: DVec2) -> WindowResolution

#### fn from(res: DVec2) -> WindowResolution

§### impl FromReflect for DVec2

### impl FromReflect for DVec2

§#### fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<DVec2>

#### fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<DVec2>

`Self`

from a reflected value.§#### fn take_from_reflect(
reflect: Box<dyn Reflect>,
) -> Result<Self, Box<dyn Reflect>>

#### fn take_from_reflect( reflect: Box<dyn Reflect>, ) -> Result<Self, Box<dyn Reflect>>

`Self`

using,
constructing the value using `from_reflect`

if that fails. Read more§### impl GetTypeRegistration for DVec2

### impl GetTypeRegistration for DVec2

§#### fn get_type_registration() -> TypeRegistration

#### fn get_type_registration() -> TypeRegistration

`TypeRegistration`

for this type.§#### fn register_type_dependencies(registry: &mut TypeRegistry)

#### fn register_type_dependencies(registry: &mut TypeRegistry)

source§### 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 for DVec2

### impl MulAssign for DVec2

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

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

`*=`

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

### impl PartialEq for DVec2

§### impl Reflect for DVec2

### impl Reflect for DVec2

§#### fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

#### fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

§#### fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

#### fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

`&mut dyn Any`

.§#### fn as_reflect(&self) -> &(dyn Reflect + 'static)

#### fn as_reflect(&self) -> &(dyn Reflect + 'static)

§#### fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

#### fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

§#### fn clone_value(&self) -> Box<dyn Reflect>

#### fn clone_value(&self) -> Box<dyn Reflect>

`Reflect`

trait object. Read more§#### fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

#### fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

§#### fn reflect_kind(&self) -> ReflectKind

#### fn reflect_kind(&self) -> ReflectKind

§#### fn reflect_ref(&self) -> ReflectRef<'_>

#### fn reflect_ref(&self) -> ReflectRef<'_>

§#### fn reflect_mut(&mut self) -> ReflectMut<'_>

#### fn reflect_mut(&mut self) -> ReflectMut<'_>

§#### fn reflect_owned(self: Box<DVec2>) -> ReflectOwned

#### fn reflect_owned(self: Box<DVec2>) -> ReflectOwned

§#### fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

#### fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

§#### fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>

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

§#### fn apply(&mut self, value: &(dyn Reflect + 'static))

#### fn apply(&mut self, value: &(dyn Reflect + 'static))

§#### fn reflect_hash(&self) -> Option<u64>

#### fn reflect_hash(&self) -> Option<u64>

§#### fn serializable(&self) -> Option<Serializable<'_>>

#### fn serializable(&self) -> Option<Serializable<'_>>

§#### fn is_dynamic(&self) -> bool

#### fn is_dynamic(&self) -> bool

*dynamic*type. Read more

source§### 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 for DVec2

### impl RemAssign for DVec2

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

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

`%=`

operation. Read moresource§### impl Serialize for DVec2

### impl Serialize for DVec2

source§#### fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

#### fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

§### impl Struct for DVec2

### impl Struct for DVec2

§#### fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>

#### fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>

`name`

as a `&dyn Reflect`

.§#### fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>

#### fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>

`name`

as a
`&mut dyn Reflect`

.§#### fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

#### fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

`index`

as a
`&dyn Reflect`

.§#### fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

#### fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

`index`

as a `&mut dyn Reflect`

.§#### fn iter_fields(&self) -> FieldIter<'_> ⓘ

#### fn iter_fields(&self) -> FieldIter<'_> ⓘ

§#### fn clone_dynamic(&self) -> DynamicStruct

#### fn clone_dynamic(&self) -> DynamicStruct

`DynamicStruct`

.source§### 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 for DVec2

### impl SubAssign for DVec2

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

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

`-=`

operation. Read more§### impl TypePath for DVec2

### impl TypePath for DVec2

§#### fn short_type_path() -> &'static str

#### fn short_type_path() -> &'static str

§#### fn type_ident() -> Option<&'static str>

#### fn type_ident() -> Option<&'static str>

§#### fn crate_name() -> Option<&'static str>

#### fn crate_name() -> Option<&'static str>

source§### impl Vec2Swizzles for DVec2

### impl Vec2Swizzles for DVec2

#### type Vec3 = DVec3

#### type Vec4 = DVec4

#### fn xx(self) -> DVec2

#### fn xy(self) -> DVec2

#### fn yx(self) -> DVec2

#### fn yy(self) -> DVec2

#### fn xxx(self) -> DVec3

#### fn xxy(self) -> DVec3

#### fn xyx(self) -> DVec3

#### fn xyy(self) -> DVec3

#### fn yxx(self) -> DVec3

#### fn yxy(self) -> DVec3

#### fn yyx(self) -> DVec3

#### fn yyy(self) -> DVec3

#### fn xxxx(self) -> DVec4

#### fn xxxy(self) -> DVec4

#### fn xxyx(self) -> DVec4

#### fn xxyy(self) -> DVec4

#### fn xyxx(self) -> DVec4

#### fn xyxy(self) -> DVec4

#### fn xyyx(self) -> DVec4

#### fn xyyy(self) -> DVec4

#### fn yxxx(self) -> DVec4

#### fn yxxy(self) -> DVec4

#### fn yxyx(self) -> DVec4

#### fn yxyy(self) -> DVec4

#### fn yyxx(self) -> DVec4

#### fn yyxy(self) -> DVec4

#### fn yyyx(self) -> DVec4

#### fn yyyy(self) -> DVec4

### impl Copy for DVec2

### impl Pod for DVec2

### impl StructuralPartialEq for DVec2

## Auto Trait Implementations§

### impl Freeze for DVec2

### impl RefUnwindSafe for DVec2

### impl Send for DVec2

### impl Sync for DVec2

### impl Unpin for DVec2

### impl UnwindSafe for DVec2

## Blanket Implementations§

§### impl<T, U> AsBindGroupShaderType<U> for T

### impl<T, U> AsBindGroupShaderType<U> for T

§#### fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

#### fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

`T`

`ShaderType`

for `self`

. When used in `AsBindGroup`

derives, it is safe to assume that all images in `self`

exist.source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

§### impl<T> CheckedBitPattern for Twhere
T: AnyBitPattern,

### impl<T> CheckedBitPattern for Twhere
T: AnyBitPattern,

§#### type Bits = T

#### type Bits = T

`Self`

*must*have the same layout as the specified

`Bits`

except for
the possible invalid bit patterns being checked during
`is_valid_bit_pattern`

.§#### fn is_valid_bit_pattern(_bits: &T) -> bool

#### fn is_valid_bit_pattern(_bits: &T) -> bool

`bits`

as `&Self`

.§### impl<T> Downcast for Twhere
T: Any,

### impl<T> Downcast for Twhere
T: Any,

§#### fn into_any(self: Box<T>) -> Box<dyn Any>

#### fn into_any(self: Box<T>) -> Box<dyn Any>

`Box<dyn Trait>`

(where `Trait: Downcast`

) to `Box<dyn Any>`

. `Box<dyn Any>`

can
then be further `downcast`

into `Box<ConcreteType>`

where `ConcreteType`

implements `Trait`

.§#### fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

#### fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

`Rc<Trait>`

(where `Trait: Downcast`

) to `Rc<Any>`

. `Rc<Any>`

can then be
further `downcast`

into `Rc<ConcreteType>`

where `ConcreteType`

implements `Trait`

.§#### fn as_any(&self) -> &(dyn Any + 'static)

#### fn as_any(&self) -> &(dyn Any + 'static)

`&Trait`

(where `Trait: Downcast`

) to `&Any`

. This is needed since Rust cannot
generate `&Any`

’s vtable from `&Trait`

’s.§#### fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

#### fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

`&mut Trait`

(where `Trait: Downcast`

) to `&Any`

. This is needed since Rust cannot
generate `&mut Any`

’s vtable from `&mut Trait`

’s.§### impl<T> DowncastSync for T

### impl<T> DowncastSync for T

§### impl<T> DynamicTypePath for Twhere
T: TypePath,

### impl<T> DynamicTypePath for Twhere
T: TypePath,

§#### fn reflect_type_path(&self) -> &str

#### fn reflect_type_path(&self) -> &str

`TypePath::type_path`

.§#### fn reflect_short_type_path(&self) -> &str

#### fn reflect_short_type_path(&self) -> &str

§#### fn reflect_type_ident(&self) -> Option<&str>

#### fn reflect_type_ident(&self) -> Option<&str>

`TypePath::type_ident`

.§#### fn reflect_crate_name(&self) -> Option<&str>

#### fn reflect_crate_name(&self) -> Option<&str>

`TypePath::crate_name`

.§#### fn reflect_module_path(&self) -> Option<&str>

#### fn reflect_module_path(&self) -> Option<&str>

§### impl<S> FromSample<S> for S

### impl<S> FromSample<S> for S

#### fn from_sample_(s: S) -> S

§### impl<T> FromWorld for Twhere
T: Default,

### impl<T> FromWorld for Twhere
T: Default,

§#### fn from_world(_world: &mut World) -> T

#### fn from_world(_world: &mut World) -> T

`Self`

using data from the given `World`

.§### impl<T> GetPath for T

### impl<T> GetPath for T

§#### fn reflect_path<'p>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>

#### fn reflect_path<'p>( &self, path: impl ReflectPath<'p>, ) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>

`path`

. Read more§#### fn reflect_path_mut<'p>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>

#### fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>

`path`

. Read more§#### fn path<'p, T>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,

#### fn path<'p, T>(
&self,
path: impl ReflectPath<'p>,
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,

`path`

. Read more§#### fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,

#### fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>,
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,

`path`

. Read more§### impl<T> Instrument for T

### impl<T> Instrument for T

§#### fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

#### fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

§#### fn in_current_span(self) -> Instrumented<Self> ⓘ

#### fn in_current_span(self) -> Instrumented<Self> ⓘ

source§### impl<T> IntoEither for T

### impl<T> IntoEither for T

source§#### fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

#### fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left`

is `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read moresource§#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ

`self`

into a `Left`

variant of `Either<Self, Self>`

if `into_left(&self)`

returns `true`

.
Converts `self`

into a `Right`

variant of `Either<Self, Self>`

otherwise. Read more§### impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,

### impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,

#### fn into_sample(self) -> T

§### impl<T> NoneValue for Twhere
T: Default,

### impl<T> NoneValue for Twhere
T: Default,

#### type NoneType = T

§#### fn null_value() -> T

#### fn null_value() -> T

§### impl<T> Pointable for T

### impl<T> Pointable for T

source§### impl<R, P> ReadPrimitive<R> for P

### impl<R, P> ReadPrimitive<R> for P

source§#### fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

#### fn read_from_little_endian(read: &mut R) -> Result<Self, Error>

`ReadEndian::read_from_little_endian()`

.