Struct cogl::Quaternion

pub struct Quaternion(_);

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_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 copy of the value.

pub 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 Hash for Quaternion

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl StaticType for Quaternion

fn static_type() -> Type

Returns the type identifier of Self.