`#[repr(transparent)]pub struct Quat(/* private fields */);`

## Expand description

A quaternion representing an orientation.

This quaternion is intended to be of unit length but may denormalize due to floating point “error creep” which can occur when successive quaternion operations are applied.

SIMD vector types are used for storage on supported platforms.

This type is 16 byte aligned.

## Implementations§

source§### impl Quat

### impl Quat

source#### pub const fn from_xyzw(x: f32, y: f32, z: f32, w: f32) -> Self

#### pub const fn from_xyzw(x: f32, y: f32, z: f32, w: f32) -> Self

Creates a new rotation quaternion.

This should generally not be called manually unless you know what you are doing.
Use one of the other constructors instead such as `identity`

or `from_axis_angle`

.

`from_xyzw`

is mostly used by unit tests and `serde`

deserialization.

##### Preconditions

This function does not check if the input is normalized, it is up to the user to provide normalized input or to normalized the resulting quaternion.

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

#### pub const fn from_array(a: [f32; 4]) -> Self

Creates a rotation quaternion from an array.

##### Preconditions

This function does not check if the input is normalized, it is up to the user to provide normalized input or to normalized the resulting quaternion.

source#### pub const fn from_vec4(v: Vec4) -> Self

#### pub const fn from_vec4(v: Vec4) -> Self

Creates a new rotation quaternion from a 4D vector.

##### Preconditions

This function does not check if the input is normalized, it is up to the user to provide normalized input or to normalized the resulting quaternion.

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

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

Creates a rotation quaternion from a slice.

##### Preconditions

##### Panics

Panics if `slice`

length is less than 4.

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

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

source#### pub fn from_axis_angle(axis: Vec3, angle: f32) -> Self

#### pub fn from_axis_angle(axis: Vec3, angle: f32) -> Self

Create a quaternion for a normalized rotation `axis`

and `angle`

(in radians).

The axis must be a unit vector.

##### Panics

Will panic if `axis`

is not normalized when `glam_assert`

is enabled.

source#### pub fn from_scaled_axis(v: Vec3) -> Self

#### pub fn from_scaled_axis(v: Vec3) -> Self

Create a quaternion that rotates `v.length()`

radians around `v.normalize()`

.

`from_scaled_axis(Vec3::ZERO)`

results in the identity quaternion.

source#### pub fn from_rotation_x(angle: f32) -> Self

#### pub fn from_rotation_x(angle: f32) -> Self

Creates a quaternion from the `angle`

(in radians) around the x axis.

source#### pub fn from_rotation_y(angle: f32) -> Self

#### pub fn from_rotation_y(angle: f32) -> Self

Creates a quaternion from the `angle`

(in radians) around the y axis.

source#### pub fn from_rotation_z(angle: f32) -> Self

#### pub fn from_rotation_z(angle: f32) -> Self

Creates a quaternion from the `angle`

(in radians) around the z axis.

source#### pub fn from_euler(euler: EulerRot, a: f32, b: f32, c: f32) -> Self

#### pub fn from_euler(euler: EulerRot, a: f32, b: f32, c: f32) -> Self

Creates a quaternion from the given Euler rotation sequence and the angles (in radians).

source#### pub fn from_mat3(mat: &Mat3) -> Self

#### pub fn from_mat3(mat: &Mat3) -> Self

Creates a quaternion from a 3x3 rotation matrix.

Note if the input matrix contain scales, shears, or other non-rotation transformations then the resulting quaternion will be ill-defined.

##### Panics

Will panic if any input matrix column is not normalized when `glam_assert`

is enabled.

source#### pub fn from_mat3a(mat: &Mat3A) -> Self

#### pub fn from_mat3a(mat: &Mat3A) -> Self

Creates a quaternion from a 3x3 SIMD aligned rotation matrix.

Note if the input matrix contain scales, shears, or other non-rotation transformations then the resulting quaternion will be ill-defined.

##### Panics

Will panic if any input matrix column is not normalized when `glam_assert`

is enabled.

source#### pub fn from_mat4(mat: &Mat4) -> Self

#### pub fn from_mat4(mat: &Mat4) -> Self

Creates a quaternion from the upper 3x3 rotation matrix inside a homogeneous 4x4 matrix.

Note if the upper 3x3 matrix contain scales, shears, or other non-rotation transformations then the resulting quaternion will be ill-defined.

##### Panics

Will panic if any column of the upper 3x3 rotation matrix is not normalized when
`glam_assert`

is enabled.

source#### pub fn from_rotation_arc(from: Vec3, to: Vec3) -> Self

#### pub fn from_rotation_arc(from: Vec3, to: Vec3) -> Self

Gets the minimal rotation for transforming `from`

to `to`

. The rotation is in the
plane spanned by the two vectors. Will rotate at most 180 degrees.

The inputs must be unit vectors.

`from_rotation_arc(from, to) * from ≈ to`

.

For near-singular cases (from≈to and from≈-to) the current implementation
is only accurate to about 0.001 (for `f32`

).

##### Panics

Will panic if `from`

or `to`

are not normalized when `glam_assert`

is enabled.

source#### pub fn from_rotation_arc_colinear(from: Vec3, to: Vec3) -> Self

#### pub fn from_rotation_arc_colinear(from: Vec3, to: Vec3) -> Self

Gets the minimal rotation for transforming `from`

to either `to`

or `-to`

. This means
that the resulting quaternion will rotate `from`

so that it is colinear with `to`

.

The rotation is in the plane spanned by the two vectors. Will rotate at most 90 degrees.

The inputs must be unit vectors.

`to.dot(from_rotation_arc_colinear(from, to) * from).abs() ≈ 1`

.

##### Panics

Will panic if `from`

or `to`

are not normalized when `glam_assert`

is enabled.

source#### pub fn from_rotation_arc_2d(from: Vec2, to: Vec2) -> Self

#### pub fn from_rotation_arc_2d(from: Vec2, to: Vec2) -> Self

Gets the minimal rotation for transforming `from`

to `to`

. The resulting rotation is
around the z axis. Will rotate at most 180 degrees.

The inputs must be unit vectors.

`from_rotation_arc_2d(from, to) * from ≈ to`

.

For near-singular cases (from≈to and from≈-to) the current implementation
is only accurate to about 0.001 (for `f32`

).

##### Panics

Will panic if `from`

or `to`

are not normalized when `glam_assert`

is enabled.

source#### pub fn to_axis_angle(self) -> (Vec3, f32)

#### pub fn to_axis_angle(self) -> (Vec3, f32)

Returns the rotation axis (normalized) and angle (in radians) of `self`

.

source#### pub fn to_scaled_axis(self) -> Vec3

#### pub fn to_scaled_axis(self) -> Vec3

Returns the rotation axis scaled by the rotation in radians.

source#### pub fn to_euler(self, order: EulerRot) -> (f32, f32, f32)

#### pub fn to_euler(self, order: EulerRot) -> (f32, f32, f32)

Returns the rotation angles for the given euler rotation sequence.

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

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

Returns the quaternion conjugate of `self`

. For a unit quaternion the
conjugate is also the inverse.

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

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

Returns the inverse of a normalized quaternion.

Typically quaternion inverse returns the conjugate of a normalized quaternion.
Because `self`

is assumed to already be unit length this method *does not* normalize
before returning the conjugate.

##### Panics

Will panic if `self`

is not normalized when `glam_assert`

is enabled.

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

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

Computes the dot product of `self`

and `rhs`

. The dot product is
equal to the cosine of the angle between two quaternion rotations.

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

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

Computes the squared length of `self`

.

This is generally faster than `length()`

as it avoids a square
root operation.

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

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

Computes `1.0 / length()`

.

For valid results, `self`

must *not* be of length zero.

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

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

Returns `self`

normalized to length 1.0.

For valid results, `self`

must *not* be of length zero.

Panics

Will panic if `self`

is zero length when `glam_assert`

is enabled.

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`

.

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

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

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

Returns whether `self`

of length `1.0`

or not.

Uses a precision threshold of `1e-6`

.

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

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

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

Returns the angle (in radians) for the minimal rotation for transforming this quaternion into another.

Both quaternions must be normalized.

##### Panics

Will panic if `self`

or `rhs`

are not normalized when `glam_assert`

is enabled.

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

#### pub fn rotate_towards(&self, rhs: Self, max_angle: f32) -> 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.

Both quaternions must be normalized.

##### Panics

Will panic if `self`

or `rhs`

are not normalized when `glam_assert`

is enabled.

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

#### pub fn abs_diff_eq(self, rhs: Self, max_abs_diff: f32) -> 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 quaternions 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 lerp(self, end: Self, s: f32) -> Self

#### pub fn lerp(self, end: Self, s: f32) -> 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`

.

##### Panics

Will panic if `self`

or `end`

are not normalized when `glam_assert`

is enabled.

source#### pub fn slerp(self, end: Self, s: f32) -> Self

#### pub fn slerp(self, end: Self, s: f32) -> Self

Performs a spherical linear interpolation between `self`

and `end`

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

.

##### Panics

Will panic if `self`

or `end`

are not normalized when `glam_assert`

is enabled.

source#### pub fn mul_vec3(self, rhs: Vec3) -> Vec3

#### pub fn mul_vec3(self, rhs: Vec3) -> Vec3

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

##### Panics

Will panic if `self`

is not normalized when `glam_assert`

is enabled.

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

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

Multiplies two quaternions. If they each represent a rotation, the result will represent the combined rotation.

Note that due to floating point rounding the result may not be perfectly normalized.

##### Panics

Will panic if `self`

or `rhs`

are not normalized when `glam_assert`

is enabled.

source#### pub fn from_affine3(a: &Affine3A) -> Self

#### pub fn from_affine3(a: &Affine3A) -> Self

Creates a quaternion from a 3x3 rotation matrix inside a 3D affine transform.

Note if the input affine matrix contain scales, shears, or other non-rotation transformations then the resulting quaternion will be ill-defined.

##### Panics

Will panic if any input affine matrix column is not normalized when `glam_assert`

is
enabled.

source#### pub fn mul_vec3a(self, rhs: Vec3A) -> Vec3A

#### pub fn mul_vec3a(self, rhs: Vec3A) -> Vec3A

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

#### pub fn as_dquat(self) -> DQuat

## Trait Implementations§

source§### impl Add<Quat> for Quat

### impl Add<Quat> for Quat

source§### impl From<Quat> for float32x4_t

### impl From<Quat> for float32x4_t

source§### impl Mul<Quat> for Quat

### impl Mul<Quat> for Quat

source§#### fn mul(self, rhs: Self) -> Self

#### fn mul(self, rhs: Self) -> Self

Multiplies two quaternions. If they each represent a rotation, the result will represent the combined rotation.

Note that due to floating point rounding the result may not be perfectly normalized.

##### Panics

Will panic if `self`

or `rhs`

are not normalized when `glam_assert`

is enabled.

source§### impl MulAssign<Quat> for Quat

### impl MulAssign<Quat> for Quat

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

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

Multiplies two quaternions. If they each represent a rotation, the result will represent the combined rotation.

Note that due to floating point rounding the result may not be perfectly normalized.

##### Panics

Will panic if `self`

or `rhs`

are not normalized when `glam_assert`

is enabled.