Struct gamemath::Quat

pub struct Quat {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub w: f32,
}

A quaternion data type used for representing spatial rotation in a 3D enviornment.

Fields

x: f32

The X/first component of the quaternion.

y: f32

The Y/first component of the quaternion.

z: f32

The Z/first component of the quaternion.

w: f32

The W/first component of the quaternion.

Methods

impl Quat

pub fn identity() -> Quat

Constructs an identity quaternion.

Examples

use gamemath::Quat;

let q = Quat::identity();

assert_eq!(q, (0.0, 0.0, 0.0, 1.0).into());

pub fn rotation(radians: f32, axis: Vec3<f32>) -> Quat

Constructs a rotation quaternion from an angle and an axis.

Examples

use gamemath::{Vec3, Quat};

let q = Quat::rotation(1.0, Vec3::new(1.0, 2.0, 3.0));

assert_eq!(q, (0.12813187, 0.25626373, 0.38439557, 0.87758255).into());

pub fn rotated(&self, radians: f32, axis: Vec3<f32>) -> Quat

Calculate and returns a quaternion representing the calling object rotated by an angle around an axis.

Examples

use gamemath::{Vec3, Quat};

let q = Quat::identity();

assert_eq!(q.rotated(1.0, Vec3::new(1.0, 2.0, 3.0)), (0.12813187, 0.25626373, 0.38439557, 0.87758255).into());

pub fn rotate(&mut self, radians: f32, axis: Vec3<f32>)

Applies a rotation around and axis by an angle on the calling Quat object.

Examples

use gamemath::{Vec3, Quat};

let mut q = Quat::identity();

q.rotate(1.0, Vec3::new(1.0, 2.0, 3.0));

assert_eq!(q, (0.12813187, 0.25626373, 0.38439557, 0.87758255).into());

pub fn length_squared(&self) -> f32

Calculates the squared length/magnitude/norm of a Quat. This saves an expensive square root calculation compared to calculating the actual length, and comparing two squared lengths can therefore often be cheaper than, and yield the same result as, computing two real lengths.

Examples

use gamemath::Quat;

let q: Quat = (1.0, 2.0, 3.0, 4.0).into();

assert_eq!(q.length_squared(), 30.0);

pub fn length(&self) -> f32

Calculates the real length/magnitude/norm of a Quat. This results in an expensive square root calculation, and you might want to consider using a squared length instead when possible.

Examples

use gamemath::Quat;

let q: Quat = (1.0, 4.0, 4.0, 16.0).into();

assert_eq!(q.length(), 17.0);

pub fn normalized(&self) -> Quat

Calculates and returns the unit quaternion representation of a Quat. This results in an an expensive square root calculation.

Examples

use gamemath::Quat;

let q: Quat = (1.0, 2.0, 2.0, 4.0).into();

assert_eq!(q.normalized(), (0.2, 0.4, 0.4, 0.8).into());

pub fn normalize(&mut self)

Normalizes a Quat into its unit quaternion representation. This results in an an expensive square root calculation.

Examples

use gamemath::Quat;

let mut q: Quat = (1.0, 2.0, 2.0, 4.0).into();

q.normalize();

assert_eq!(q, (0.2, 0.4, 0.4, 0.8).into());

pub fn extract_matrix(&self) -> Mat4

Calculates and returns a Mat4 object representing the rotation of the calling Quat object.

Examples

use gamemath::{Vec3, Mat4, Quat};

let q = Quat::rotation(1.0, Vec3::new(1.0, 2.0, 3.0));

assert_eq!(q.extract_matrix(), (( 0.5731379,  0.74034876, -0.35127854, 0.0),
                                (-0.6090066,  0.67164457,  0.42190588, 0.0),
                                ( 0.5482918, -0.027879298, 0.8358222,  0.0),
                                ( 0.0,        0.0,         0.0,        1.0)).into());

Trait Implementations

impl From<Quat> for Mat4

fn from(quat: Quat) -> Mat4

Performs the conversion.

impl Copy for Quat

impl Clone for Quat

fn clone(&self) -> Quat

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Quat

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

Formats the value using the given formatter.

impl PartialEq for Quat

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

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

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

This method tests for !=.

impl Default for Quat

fn default() -> Quat

Returns the "default value" for a type.

impl From<f32> for Quat

fn from(value: f32) -> Quat

Performs the conversion.

impl From<Vec4<f32>> for Quat

fn from(vec: Vec4<f32>) -> Quat

Performs the conversion.

impl From<(f32, f32, f32, f32)> for Quat

fn from(tuple: (f32, f32, f32, f32)) -> Quat

Performs the conversion.

impl From<[f32; 4]> for Quat

fn from(slice: [f32; 4]) -> Quat

Performs the conversion.

impl Mul<Quat> for Quat

type Output = Quat

The resulting type after applying the * operator.

fn mul(self, right: Quat) -> Quat

Performs the * operation.

impl MulAssign<Quat> for Quat

fn mul_assign(&mut self, right: Quat)

Performs the *= operation.

impl Add<Quat> for Quat

type Output = Quat

The resulting type after applying the + operator.

fn add(self, right: Quat) -> Quat

Performs the + operation.

impl AddAssign<Quat> for Quat

fn add_assign(&mut self, right: Quat)

Performs the += operation.