# Struct bevy::math::Vec3

``````pub struct Vec3 {
pub x: f32,
pub y: f32,
pub z: f32,
}``````
Expand description

A 3-dimensional vector.

## Fields

`x: f32``y: f32``z: f32`

## Implementations

All zeroes.

All ones.

All negative ones.

All NAN.

A unit-length vector pointing along the positive X axis.

A unit-length vector pointing along the positive Y axis.

A unit-length vector pointing along the positive Z axis.

A unit-length vector pointing along the negative X axis.

A unit-length vector pointing along the negative Y axis.

A unit-length vector pointing along the negative Z axis.

The unit axes.

Creates a new vector.

Creates a vector with all elements set to `v`.

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`.

Creates a new vector from an array.

`[x, y, z]`

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

##### Panics

Panics if `slice` is less than 3 elements long.

Writes the elements of `self` to the first 3 elements in `slice`.

##### Panics

Panics if `slice` is less than 3 elements long.

Creates a 4D vector from `self` and the given `w` value.

Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`.

Truncation may also be performed by using `self.xy()` or `Vec2::from()`.

Computes the dot product of `self` and `rhs`.

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

Computes the cross product of `self` and `rhs`.

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), ..]`.

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), ..]`.

Component-wise clamping of values, similar to `f32::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.

Returns the horizontal minimum of `self`.

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

Returns the horizontal maximum of `self`.

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

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.

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.

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.

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.

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.

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.

Returns a vector containing the absolute value of each element of `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`

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.

Returns `true` if, and only if, all elements are finite. If any element is either `NaN`, positive or negative infinity, this will return `false`.

Returns `true` if any elements are `NaN`.

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()]`.

Computes the length of `self`.

Computes the squared length of `self`.

This is faster than `length()` as it avoids a square root operation.

Computes `1.0 / length()`.

For valid results, `self` must not be of length zero.

Computes the Euclidean distance between two points in space.

Compute the squared euclidean distance between two points in space.

Returns `self` normalized to length 1.0.

For valid results, `self` must not be of length zero, nor very close to zero.

Panics

Will panic if `self` is zero length when `glam_assert` is enabled.

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`.

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`.

Returns whether `self` is length `1.0` or not.

Uses a precision threshold of `1e-6`.

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.

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.

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.

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.

Returns a vector containing the nearest integer to a number for each element of `self`. Round half-way cases away from 0.0.

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

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

Returns a vector containing the fractional part of the vector, e.g. `self - self.floor()`.

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

Returns a vector containing `e^self` (the exponential function) for each element of `self`.

Returns a vector containing each element of `self` raised to the power of `n`.

Returns a vector containing the reciprocal `1.0/n` of each element of `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.

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.

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.

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

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

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.

Returns the angle (in radians) between two vectors.

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

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.

Returns any unit-length vector that is orthogonal to the given one. The input vector must be finite and non-zero.

##### Panics

Will panic if `self` is not normalized when `glam_assert` is enabled.

Given a unit-length 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.

Casts all elements of `self` to `f64`.

Casts all elements of `self` to `i32`.

Casts all elements of `self` to `u32`.

## Trait Implementations

The resulting type after applying the `+` operator.
Performs the `+` operation. Read more
The resulting type after applying the `+` operator.
Performs the `+` operation. Read more
Performs the `+=` operation. Read more
Performs the `+=` operation. Read more
Converts this type into a mutable reference of the (usually inferred) input type.
Converts this type into a shared reference of the (usually inferred) input type.
Returns a copy of the value. Read more
Performs copy-assignment from `source`. Read more
Formats the value using the given formatter. Read more
Returns the “default value” for a type. Read more
Deserialize this value from the given Serde deserializer. Read more
Formats the value using the given formatter. Read more
The resulting type after applying the `/` operator.
Performs the `/` operation. Read more
The resulting type after applying the `/` operator.
Performs the `/` operation. Read more
Performs the `/=` operation. Read more
Performs the `/=` operation. Read more
Converts to this type from the input type.
Converts to this type from the input type.
Converts to this type from the input type.
Converts to this type from the input type.
Converts to this type from the input type.
Converts to this type from the input type.
Converts to this type from the input type.
Constructs a concrete instance of `Self` from a reflected value.
The returned type after indexing.
Performs the indexing (`container[index]`) operation. Read more
Performs the mutable indexing (`container[index]`) operation. Read more
The resulting type after applying the `*` operator.
Performs the `*` operation. Read more
The resulting type after applying the `*` operator.
Performs the `*` operation. Read more
The resulting type after applying the `*` operator.
Performs the `*` operation. Read more
The resulting type after applying the `*` operator.
Performs the `*` operation. Read more

Multiplies a quaternion and a 3D vector, returning the rotated vector.

##### Panics

Will panic if `self` is not normalized when `glam_assert` is enabled.

The resulting type after applying the `*` operator.
The resulting type after applying the `*` operator.
Performs the `*` operation. Read more
The resulting type after applying the `*` operator.
Performs the `*` operation. Read more
The resulting type after applying the `*` operator.
Performs the `*` operation. Read more
Performs the `*=` operation. Read more
Performs the `*=` operation. Read more
Performs the `*=` operation. Read more
The resulting type after applying the `-` operator.
Performs the unary `-` operation. Read more
This method tests for `self` and `other` values to be equal, and is used by `==`. Read more
This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason. Read more
Method which takes an iterator and generates `Self` from the elements by multiplying the items. Read more
Method which takes an iterator and generates `Self` from the elements by multiplying the items. Read more
Returns the type name of the underlying type.
Returns the `TypeInfo` of the underlying type. Read more
Returns the value as a `Box<dyn Any>`.
Returns the value as a `&dyn Any`.
Returns the value as a `&mut dyn Any`.
Casts this type to a boxed reflected value.
Casts this type to a reflected value.
Casts this type to a mutable reflected value.
Clones the value as a `Reflect` trait object. Read more
Performs a type-checked assignment of a reflected value to this value. Read more
Applies a reflected value to this value. Read more
Returns an enumeration of “kinds” of type. Read more
Returns a mutable enumeration of “kinds” of type. Read more
Returns an owned enumeration of “kinds” of type. Read more
Returns a “partial equality” comparison result. Read more
Debug formatter for the value. Read more
Returns a hash of the value (which includes the type). Read more
Returns a serializable version of the value. Read more
The resulting type after applying the `%` operator.
Performs the `%` operation. Read more
The resulting type after applying the `%` operator.
Performs the `%` operation. Read more
Performs the `%=` operation. Read more
Performs the `%=` operation. Read more
Serialize this value into the given Serde serializer. Read more
Represents the minimum size of `Self` (equivalent to GPUBufferBindingLayout.minBindingSize) Read more
Returns the size of `Self` at runtime Read more
Asserts that `Self` meets the requirements of the uniform address space restrictions on stored values and the uniform address space layout constraints Read more
Returns a reference to the value of the field named `name` as a `&dyn Reflect`. Read more
Returns a mutable reference to the value of the field named `name` as a `&mut dyn Reflect`. Read more
Returns a reference to the value of the field with index `index` as a `&dyn Reflect`. Read more
Returns a mutable reference to the value of the field with index `index` as a `&mut dyn Reflect`. Read more
Returns the name of the field with index `index`.
Returns the number of fields in the struct.
Returns an iterator over the values of the reflectable fields for this struct.
Clones the struct into a `DynamicStruct`.
The resulting type after applying the `-` operator.
Performs the `-` operation. Read more
The resulting type after applying the `-` operator.
Performs the `-` operation. Read more
Performs the `-=` operation. Read more
Performs the `-=` operation. Read more
Method which takes an iterator and generates `Self` from the elements by “summing up” the items. Read more
Method which takes an iterator and generates `Self` from the elements by “summing up” the items. Read more
Returns the compile-time info for the underlying type. Read more

## Blanket Implementations

Gets the `TypeId` of `self`. Read more
Return the `T` `ShaderType` for `self`. When used in `AsBindGroup` derives, it is safe to assume that all images in `self` exist. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more
`Self` must have the same layout as the specified `Bits` except for the possible invalid bit patterns being checked during `is_valid_bit_pattern`. Read more
If this function returns true, then it must be valid to reinterpret `bits` as `&Self`. Read more
Convert `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`. Read more
Convert `Rc<Trait>` (where `Trait: Downcast`) to `Rc<Any>`. `Rc<Any>` can then be further `downcast` into `Rc<ConcreteType>` where `ConcreteType` implements `Trait`. Read more
Convert `&Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&Any`’s vtable from `&Trait`’s. Read more
Convert `&mut Trait` (where `Trait: Downcast`) to `&Any`. This is needed since Rust cannot generate `&mut Any`’s vtable from `&mut Trait`’s. Read more
Convert `Arc<Trait>` (where `Trait: Downcast`) to `Arc<Any>`. `Arc<Any>` can then be further `downcast` into `Arc<ConcreteType>` where `ConcreteType` implements `Trait`. Read more

Returns the argument unchanged.

Creates `Self` using data from the given World
Returns a reference to the value of the field named `name`, downcast to `T`. Read more
Returns a mutable reference to the value of the field named `name`, downcast to `T`. Read more
Returns a reference to the value specified by `path`. Read more
Returns a mutable reference to the value specified by `path`. Read more
Returns a statically typed reference to the value specified by `path`.
Returns a statically typed mutable reference to the value specified by `path`. Read more
Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

The resulting type after obtaining ownership.
Creates owned data from borrowed data, usually by cloning. Read more
Uses borrowed data to replace owned data, usually by cloning. Read more
Converts the given value to a `String`. Read more
The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.
Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more