Struct geng::prelude::Quat

#[repr(C)]
pub struct Quat<T> {
    pub i: T,
    pub j: T,
    pub k: T,
    pub w: T,
}

A quaternion

Fields

i: T

First imaginary component

j: T

Second imaginary component

k: T

Third imaginary component

w: T

Real component

Implementations

impl<T> Quat<T>

pub fn map<U, F>(self, f: F) -> Quat<U>

where F: Fn(T) -> U,

Map every component

impl<T> Quat<T>

where T: Float,

pub fn identity() -> Quat<T>

Identity element - 1

pub fn from_axis_angle(axis: vec3<T>, angle: Angle<T>) -> Quat<T>

Construct a quaternion representing rotation around given axis by given angle

pub fn len(self) -> T

Calculate length of this quaternion

pub fn len_sqr(self) -> T

Calculate squared length of this quaternion

pub fn normalize(self) -> Quat<T>

Normalize this quaternion

pub fn lerp(v0: Quat<T>, v1: Quat<T>, t: T) -> Quat<T>

Lerp - calculate v0 * (1 - t) + v1 * t

Trait Implementations

impl<T> Add for Quat<T>

where T: Num,

type Output = Quat<T>

The resulting type after applying the + operator.

fn add(self, rhs: Quat<T>) -> Quat<T>

Performs the + operation.

impl<T> Clone for Quat<T>

where T: Clone,

fn clone(&self) -> Quat<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Quat<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Quat<T>

where T: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D ) -> Result<Quat<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Div<T> for Quat<T>

where T: Float,

type Output = Quat<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Quat<T>

Performs the / operation.

impl<T> DivAssign<T> for Quat<T>

where T: Float,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T> From<Quat<T>> for mat4<T>

where T: Float,

fn from(quat: Quat<T>) -> mat4<T>

Converts to this type from the input type.

impl<T> Mul<T> for Quat<T>

where T: Float,

type Output = Quat<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul for Quat<T>

where T: Float,

type Output = Quat<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> MulAssign<T> for Quat<T>

where T: Float,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T> MulAssign for Quat<T>

where T: Float,

fn mul_assign(&mut self, rhs: Quat<T>)

Performs the *= operation.

impl<T> Neg for Quat<T>

where T: Neg<Output = T>,

type Output = Quat<T>

The resulting type after applying the - operator.

fn neg(self) -> Quat<T>

Performs the unary - operation.

impl<T> Serialize for Quat<T>

where T: Serialize,

fn serialize<__S>( &self, __serializer: __S ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Copy for Quat<T>

where T: Copy,