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

## Expand description

A 3-dimensional vector.

## Fields§

§`x: f64`

§`y: f64`

§`z: f64`

## Implementations§

source§### impl DVec3

### impl DVec3

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

#### pub const NEG_INFINITY: DVec3 = _

All `f64::NEG_INFINITY`

.

source#### pub fn select(mask: BVec3, if_true: DVec3, if_false: DVec3) -> DVec3

#### pub fn select(mask: BVec3, if_true: DVec3, if_false: DVec3) -> DVec3

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; 3]) -> DVec3

#### pub const fn from_array(a: [f64; 3]) -> DVec3

Creates a new vector from an array.

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

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

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

.

##### §Panics

Panics if `slice`

is less than 3 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 3 elements in `slice`

.

##### §Panics

Panics if `slice`

is less than 3 elements long.

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

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

Creates a 2D vector from the `x`

and `y`

elements of `self`

, discarding `z`

.

Truncation may also be performed by using `self.xy()`

.

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

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

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

and `rhs`

.

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

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

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

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

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

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

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: DVec3) -> BVec3

#### pub fn cmpeq(self, rhs: DVec3) -> BVec3

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: DVec3) -> BVec3

#### pub fn cmpne(self, rhs: DVec3) -> BVec3

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: DVec3) -> BVec3

#### pub fn cmpge(self, rhs: DVec3) -> BVec3

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: DVec3) -> BVec3

#### pub fn cmpgt(self, rhs: DVec3) -> BVec3

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: DVec3) -> BVec3

#### pub fn cmple(self, rhs: DVec3) -> BVec3

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: DVec3) -> BVec3

#### pub fn cmplt(self, rhs: DVec3) -> BVec3

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

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

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

.

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

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

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

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

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

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

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: DVec3) -> f64

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

Computes the Euclidean distance between two points in space.

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

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

Compute the squared euclidean distance between two points in space.

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

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

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

by `rhs`

.

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

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

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

by `rhs`

.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

.

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

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

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

.

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

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

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

. This means numbers are
always truncated towards zero.

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

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

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

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

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

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

Returns a vector containing `e^self`

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

.

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

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

Returns a vector containing each element of `self`

raised to the power of `n`

.

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

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

Returns a vector containing the reciprocal `1.0/n`

of each element of `self`

.

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

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

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

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

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

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

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

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

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

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

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

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

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

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: DVec3, b: DVec3) -> DVec3

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

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 angle_between(self, rhs: DVec3) -> f64

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

Returns the angle (in radians) between two vectors in the range `[0, +π]`

.

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

source#### pub fn any_orthogonal_vector(&self) -> DVec3

#### pub fn any_orthogonal_vector(&self) -> DVec3

Returns some vector that is orthogonal to the given one.

The input vector must be finite and non-zero.

The output vector is not necessarily unit length. For that use
`Self::any_orthonormal_vector()`

instead.

source#### pub fn any_orthonormal_vector(&self) -> DVec3

#### pub fn any_orthonormal_vector(&self) -> DVec3

Returns any unit vector that is orthogonal to the given one.

The input vector must be unit length.

##### §Panics

Will panic if `self`

is not normalized when `glam_assert`

is enabled.

source#### pub fn any_orthonormal_pair(&self) -> (DVec3, DVec3)

#### pub fn any_orthonormal_pair(&self) -> (DVec3, DVec3)

Given a unit vector return two other vectors that together form an orthonormal basis. That is, all three vectors are orthogonal to each other and are normalized.

##### §Panics

Will panic if `self`

is not normalized when `glam_assert`

is enabled.

source#### pub fn as_i16vec3(&self) -> I16Vec3

#### pub fn as_i16vec3(&self) -> I16Vec3

Casts all elements of `self`

to `i16`

.

source#### pub fn as_u16vec3(&self) -> U16Vec3

#### pub fn as_u16vec3(&self) -> U16Vec3

Casts all elements of `self`

to `u16`

.

source#### pub fn as_i64vec3(&self) -> I64Vec3

#### pub fn as_i64vec3(&self) -> I64Vec3

Casts all elements of `self`

to `i64`

.

source#### pub fn as_u64vec3(&self) -> U64Vec3

#### pub fn as_u64vec3(&self) -> U64Vec3

Casts all elements of `self`

to `u64`

.

## Trait Implementations§

source§### impl AddAssign<f64> for DVec3

### impl AddAssign<f64> for DVec3

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

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

`+=`

operation. Read moresource§### impl AddAssign for DVec3

### impl AddAssign for DVec3

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

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

`+=`

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

### impl DivAssign<f64> for DVec3

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

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

`/=`

operation. Read moresource§### impl DivAssign for DVec3

### impl DivAssign for DVec3

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

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

`/=`

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

### impl MulAssign<f64> for DVec3

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

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

`*=`

operation. Read moresource§### impl MulAssign for DVec3

### impl MulAssign for DVec3

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

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

`*=`

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

### impl PartialEq for DVec3

source§### impl RemAssign<f64> for DVec3

### impl RemAssign<f64> for DVec3

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

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

`%=`

operation. Read moresource§### impl RemAssign for DVec3

### impl RemAssign for DVec3

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

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

`%=`

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

### impl SubAssign<f64> for DVec3

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

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

`-=`

operation. Read moresource§### impl SubAssign for DVec3

### impl SubAssign for DVec3

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

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

`-=`

operation. Read moresource§### impl Vec3Swizzles for DVec3

### impl Vec3Swizzles for DVec3

#### type Vec2 = DVec2

#### type Vec4 = DVec4

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### impl Copy for DVec3

### impl StructuralPartialEq for DVec3

## Auto Trait Implementations§

### impl Freeze for DVec3

### impl RefUnwindSafe for DVec3

### impl Send for DVec3

### impl Sync for DVec3

### impl Unpin for DVec3

### impl UnwindSafe for DVec3

## Blanket Implementations§

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> Conv for T

### impl<T> Conv for T

§### 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> FmtForward for T

### impl<T> FmtForward for T

§#### fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,

#### fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,

`self`

to use its `Binary`

implementation when `Debug`

-formatted.§#### fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,

#### fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,

`self`

to use its `Display`

implementation when
`Debug`

-formatted.§#### fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,

#### fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,

`self`

to use its `LowerExp`

implementation when
`Debug`

-formatted.§#### fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,

#### fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,

`self`

to use its `LowerHex`

implementation when
`Debug`

-formatted.§#### fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,

#### fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,

`self`

to use its `Octal`

implementation when `Debug`

-formatted.§#### fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,

#### fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,

`self`

to use its `Pointer`

implementation when
`Debug`

-formatted.§#### fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,

#### fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,

`self`

to use its `UpperExp`

implementation when
`Debug`

-formatted.§#### fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,

#### fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,

`self`

to use its `UpperHex`

implementation when
`Debug`

-formatted.§#### fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,

#### fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,

§### 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> 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>

§### impl<T> Pipe for Twhere
T: ?Sized,

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

§#### fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,

#### fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,

§#### fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,

#### fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,

`self`

and passes that borrow into the pipe function. Read more§#### fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,

#### fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,

`self`

and passes that borrow into the pipe function. Read more§#### fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R

#### fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R

§#### fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R

#### fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R

§#### fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R

#### fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R

`self`

, then passes `self.as_ref()`

into the pipe function.§#### fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R

#### fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R

`self`

, then passes `self.as_mut()`

into the pipe
function.§#### fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R

#### fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R

`self`

, then passes `self.deref()`

into the pipe function.§### impl<T> Tap for T

### impl<T> Tap for T

§#### fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self

#### fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self

`Borrow<B>`

of a value. Read more§#### fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self

#### fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self

`BorrowMut<B>`

of a value. Read more§#### fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self

#### fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self

`AsRef<R>`

view of a value. Read more§#### fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self

#### fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self

`AsMut<R>`

view of a value. Read more§#### fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self

#### fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self

`Deref::Target`

of a value. Read more§#### fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self

#### fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self

`Deref::Target`

of a value. Read more§#### fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

#### fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

`.tap()`

only in debug builds, and is erased in release builds.§#### fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

#### fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

`.tap_mut()`

only in debug builds, and is erased in release
builds.§#### fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self

#### fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self

`.tap_borrow()`

only in debug builds, and is erased in release
builds.§#### fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self

#### fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self

`.tap_borrow_mut()`

only in debug builds, and is erased in release
builds.§#### fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self

#### fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self

`.tap_ref()`

only in debug builds, and is erased in release
builds.§#### fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self

#### fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self

`.tap_ref_mut()`

only in debug builds, and is erased in release
builds.§#### fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self

#### fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self

`.tap_deref()`

only in debug builds, and is erased in release
builds.