Struct dx::platform::core::Quaternion

pub struct Quaternion { /* private fields */ }

Implementations

impl Quaternion

pub fn dot_product(&self, other: &Quaternion) -> f32

A Quaternion

pub fn rotation_angle(&self) -> f32

pub fn rotation_axis(&self) -> f32

vector3

an allocated 3-float array

pub fn init(&mut self, angle: f32, x: f32, y: f32, z: f32)

Initializes a quaternion that rotates angle degrees around the axis vector (x, y, z). The axis vector does not need to be normalized.

angle

The angle you want to rotate around the given axis

x

The x component of your axis vector about which you want to rotate.

y

The y component of your axis vector about which you want to rotate.

z

The z component of your axis vector about which you want to rotate.

pub fn init_from_angle_vector(&mut self, angle: f32, axis3f: &[f32; 3])

Initializes a quaternion that rotates angle degrees around the given axis vector. The axis vector does not need to be normalized.

angle

The angle to rotate around axis3f

axis3f

your 3 component axis vector about which you want to rotate.

pub fn init_from_array(&mut self, array: &[f32])

Initializes a [w (x, y,z)] quaternion directly from an array of 4 floats: w,x,y,z.

array

An array of 4 floats w,(x,y,z)

pub fn init_from_euler(&mut self, euler: &Euler)

euler

A Euler with which to initialize the quaternion

pub fn init_from_matrix(&mut self, matrix: &Matrix)

Initializes a quaternion from a rotation matrix.

matrix

A rotation matrix with which to initialize the quaternion

pub fn init_from_quaternion(&mut self, src: &mut Quaternion)

src

A Quaternion with which to initialize self

pub fn init_from_x_rotation(&mut self, angle: f32)

XXX: check which direction this rotates

angle

The angle to rotate around the x axis

pub fn init_from_y_rotation(&mut self, angle: f32)

angle

The angle to rotate around the y axis

pub fn init_from_z_rotation(&mut self, angle: f32)

angle

The angle to rotate around the z axis

pub fn init_identity(&mut self)

Initializes the quaternion with the canonical quaternion identity [1 (0, 0, 0)] which represents no rotation. Multiplying a quaternion with this identity leaves the quaternion unchanged.

You might also want to consider using get_static_identity_quaternion.

pub fn invert(&mut self)

pub fn multiply(&mut self, left: &Quaternion, right: &Quaternion)

This combines the rotations of two quaternions into self. The operation is not commutative so the order is important because AxB != BxA. follows the standard convention for quaternions here so the rotations are applied right to left. This is similar to the combining of matrices.

It is possible to multiply the a quaternion in-place, so self can be equal to a but can’t be equal to b.

left

The second Quaternion rotation to apply

right

The first Quaternion rotation to apply

pub fn nlerp(&mut self, a: &Quaternion, b: &Quaternion, t: f32)

Performs a normalized linear interpolation between two quaternions. That is it does a linear interpolation of the quaternion components and then normalizes the result. This will follow the shortest arc between the two orientations (just like the slerp function) but will not progress at a constant speed. Unlike slerp nlerp is commutative which is useful if you are blending animations together. (I.e. nlerp (tmp, a, b) followed by nlerp (result, tmp, d) is the same as nlerp (tmp, a, d) followed by nlerp (result, tmp, b)). Finally nlerp is cheaper than slerp so it can be a good choice if you don’t need the constant speed property of the slerp function.

Notable properties:

commutative: Yes

constant velocity: No

torque minimal (travels along the surface of the 4-sphere): Yes

faster than Quaternion::slerp

a

The first Quaternion

b

The second Quaternion

t

The factor in the range 0..1 used to interpolate between quaterion a and b.

pub fn normalize(&mut self)

pub fn pow(&mut self, exponent: f32)

exponent

the exponent

pub fn slerp(&mut self, a: &Quaternion, b: &Quaternion, t: f32)

Performs a spherical linear interpolation between two quaternions.

Noteable properties:

commutative: No

constant velocity: Yes

torque minimal (travels along the surface of the 4-sphere): Yes

more expensive than Quaternion::nlerp

a

The first Quaternion

b

The second Quaternion

t

The factor in the range 0..1 used to interpolate between quaternion a and b.

pub fn squad(
    &mut self,
    prev: &Quaternion,
    a: &Quaternion,
    b: &Quaternion,
    next: &Quaternion,
    t: f32
)

prev

A Quaternion used before a

a

The first Quaternion

b

The second Quaternion

next

A Quaternion that will be used after b

t

The factor in the range 0..1 used to interpolate between quaternion a and b.

Trait Implementations

impl Debug for Quaternion

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

Formats the value using the given formatter.

impl PartialEq<Quaternion> for Quaternion

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<Quaternion> for Quaternion

fn partial_cmp(&self, other: &Quaternion) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Quaternion