Struct Quaternion

pub struct Quaternion(/* private fields */);

Implementations

impl Quaternion

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

b

A Quaternion

pub fn get_rotation_angle(&self) -> f32

pub fn get_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 cogl_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. Cogl follows the standard convention for quaternions here so the rotations are applied right to left. This is similar to the combining of matrices.

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

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: <itemizedlist> <listitem> commutative: Yes </listitem> <listitem> constant velocity: No </listitem> <listitem> torque minimal (travels along the surface of the 4-sphere): Yes </listitem> <listitem> faster than Quaternion::slerp </listitem> </itemizedlist>

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: <itemizedlist> <listitem> commutative: No </listitem> <listitem> constant velocity: Yes </listitem> <listitem> torque minimal (travels along the surface of the 4-sphere): Yes </listitem> <listitem> more expensive than Quaternion::nlerp </listitem> </itemizedlist>

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 Clone for Quaternion

fn clone(&self) -> Quaternion

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Quaternion

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

Formats the value using the given formatter.

impl Ord for Quaternion

fn cmp(&self, other: &Quaternion) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Quaternion

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd 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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl StaticType for Quaternion

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Quaternion