Struct hektor::Quat

#[repr(C)]
pub struct Quat { /* fields omitted */ }

A Quaternion: one scalar part (a) and three imaginary parts (b, c, and d).

This is a borderline magical mathematical construct. You can read about it on wikipedia, and 3blue1brown also did a video on them.

The basic idea is that, in similar to how you describe a standard complex number with one real part and one imaginary part, this thing is made up of a real part and three imaginary parts. Because there's three imaginary dimensions as well as a real one, it's kinda a four dimensional thing. This can be difficult to envision, because if you're reading this you're probably only three dimensional.

The practical application of it all is that you can store rotation and/or orientation information very well by using a quaternion.

Methods

impl Quat

Accessors

pub fn a(self) -> f32

Gets the real coefficient of this quaternion.

pub fn b(self) -> f32

Gets the i coefficient of this quaternion.

pub fn c(self) -> f32

Gets the j coefficient of this quaternion.

pub fn d(self) -> f32

Gets the k coefficient of this quaternion.

pub fn a_mut(&mut self) -> &mut f32

&mut to the real coefficient of this quaternion.

pub fn b_mut(&mut self) -> &mut f32

&mut to the i coefficient of this quaternion.

pub fn c_mut(&mut self) -> &mut f32

&mut to the j coefficient of this quaternion.

pub fn d_mut(&mut self) -> &mut f32

&mut to the k coefficient of this quaternion.

impl Quat

Constructors

pub fn new(a: f32, b: f32, c: f32, d: f32) -> Self

Makes a new quaternion using the coefficients given.

pub fn splat(v: f32) -> Self

Splats the given value across all coefficients.

pub fn length(self) -> f32

The length / magnitude of the Quaternion.

• sqrt(a^2 + b^2 + c^2 + d^2)

pub fn length2(self) -> f32

The squared length / magnitude of the Quaternion.

• a^2 + b^2 + c^2 + d^2

pub fn normalize(self) -> Self

Generates a new quaternion where the length is 1.0

Or, well, as close as it can get. Floating point, and all that.

pub fn conjugate(self) -> Self

The conjugate has the same length/magnitude, but the sign of the imaginary parts flipped.

This has various interesting properties which I don't at the moment fully understand the use of.

Trait Implementations

impl Display for Quat

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

Shows the quaternion in a standard a + bi + cj+ dk style.

Passes the formatter along to the fields, so you can use any normal f32 Display format arguments that you like.

impl Debug for Quat

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

Shows the fields with labels a, b, c, and d.

Passes the formatter along to the fields, so you can use any normal f32 Debug format arguments that you like.

impl UpperExp for Quat

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

UpperExp formats like Display, but with the upper exponent.

Passes the formatter along to the fields, so you can use any normal f32 UpperExp format arguments that you like.

impl LowerExp for Quat

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

LowerExp formats like Display, but with the lower exponent.

Passes the formatter along to the fields, so you can use any normal f32 LowerExp format arguments that you like.

impl PartialEq<Quat> 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 Mul<f32> for Quat

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Quat> for f32

type Output = Quat

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Quat> for Quat

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<f32> for Quat

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign<Quat> for Quat

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Index<usize> for Quat

type Output = f32

The returned type after indexing.

fn index(&self, index: usize) -> &f32

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Quat

fn index_mut(&mut self, index: usize) -> &mut f32

Performs the mutable indexing (container[index]) operation.

impl Copy for Quat

impl AsRef<[f32; 4]> for Quat

fn as_ref(&self) -> &[f32; 4]

Performs the conversion.

impl AsMut<[f32; 4]> for Quat

fn as_mut(&mut self) -> &mut [f32; 4]

Performs the conversion.

impl From<[f32; 4]> for Quat

fn from([a, b, c, d]: [f32; 4]) -> Self

Performs the conversion.

impl From<Quat> for [f32; 4]

fn from(Quat { a: a, b: b, c: c, d: d }: Quat) -> Self

Performs the conversion.

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 Default for Quat

fn default() -> Quat

Returns the "default value" for a type.

impl Pod for Quat

impl Zeroable for Quat

fn zeroed() -> Self

Calls zeroed.