Struct geng_core::prelude::Quat

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

Fields

i: T

j: T

k: T

w: T

Implementations

impl<T> Quat<T>

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

impl<T> Quat<T> where
    T: Float, 

pub fn identity() -> Quat<T>

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

pub fn len(self) -> T

pub fn len_sqr(self) -> T

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

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

Trait Implementations

impl<T> Add<Quat<T>> 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> Copy for Quat<T> where
    T: Copy, 

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>

Performs the conversion.

impl<T> Mul<Quat<T>> 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> 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> MulAssign<Quat<T>> for Quat<T> where
    T: Float, 

fn mul_assign(&mut self, rhs: 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> 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.