Struct Mat4 

#[repr(C)]
pub struct Mat4<T> {

    pub a1: T,
    pub a2: T,
    pub a3: T,
    pub a4: T,
    pub b1: T,
    pub b2: T,
    pub b3: T,
    pub b4: T,
    pub c1: T,
    pub c2: T,
    pub c3: T,
    pub c4: T,
    pub d1: T,
    pub d2: T,
    pub d3: T,
    pub d4: T,
}

Fields

a1: T

a2: T

a3: T

a4: T

b1: T

b2: T

b3: T

b4: T

c1: T

c2: T

c3: T

c4: T

d1: T

d2: T

d3: T

d4: T

Implementations

impl<T> Mat4<T>

where T: Copy,

pub fn new( m11: T, m12: T, m13: T, m14: T, m21: T, m22: T, m23: T, m24: T, m31: T, m32: T, m33: T, m34: T, m41: T, m42: T, m43: T, m44: T, ) -> Self

pub fn right(&self) -> Vec3<T>

pub fn up(&self) -> Vec3<T>

pub fn forward(&self) -> Vec3<T>

pub fn position(&self) -> Vec3<T>

impl<T> Mat4<T>

where T: Vec + Math + PiByC180,

pub fn rotate_x(theta: T) -> Self

pub fn rotate_y(theta: T) -> Self

pub fn rotate_z(theta: T) -> Self

pub fn rotate(axis: Vec3<T>, theta: T) -> Self

pub fn scale(x: T, y: T, z: T) -> Self

pub fn translate(x: T, y: T, z: T) -> Self

pub fn det(&self) -> T

pub fn inverse(&self) -> Self

pub fn transform_inverse(&self) -> Self

pub fn ortho_lh(left: T, right: T, bottom: T, top: T, znear: T, zfar: T) -> Self

pub fn ortho_rh(left: T, right: T, bottom: T, top: T, znear: T, zfar: T) -> Self

pub fn perspective_fov_lh(fov: T, aspect: T, znear: T, zfar: T) -> Self

pub fn perspective_fov_rh(fov: T, aspect: T, znear: T, zfar: T) -> Self

pub fn lookat_lh(eye: Vec3<T>, center: Vec3<T>, up: Vec3<T>) -> Self

pub fn lookat_rh(eye: Vec3<T>, center: Vec3<T>, up: Vec3<T>) -> Self

pub fn as_ptr(&self) -> *const T

pub fn to_array(&self) -> [T; 16]

Trait Implementations

impl<T> Add for Mat4<T>

where T: Add<Output = T>,

type Output = Mat4<T>

The resulting type after applying the + operator.

fn add(self, m: Self) -> Self

Performs the + operation.

impl<T> AsMut<Mat4<T>> for Mat4<T>

fn as_mut(&mut self) -> &mut Mat4<T>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<Mat4<T>> for Mat4<T>

fn as_ref(&self) -> &Mat4<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for Mat4<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Mat4<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Mat4<T>

fn default() -> Mat4<T>

Returns the “default value” for a type.

impl<T> From<[T; 16]> for Mat4<T>

where T: Copy,

fn from(v: [T; 16]) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for Mat4<T>

where T: Copy,

fn from(v: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T: Vec> From<Mat3<T>> for Mat4<T>

fn from(m: Mat3<T>) -> Self

Converts to this type from the input type.

impl<T: Vec> From<Quat<T>> for Mat4<T>

fn from(q: Quat<T>) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for Mat4<T>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Mul<Mat4<T>> for Vec3<T>

where T: Copy + Add<Output = T> + Div<Output = T> + Mul<Output = T>,

type Output = Vec3<T>

The resulting type after applying the * operator.

fn mul(self, m: Mat4<T>) -> Self

Performs the * operation.

impl<T> Mul<Mat4<T>> for Vec4<T>

where T: Copy + Add<Output = T> + Mul<Output = T>,

type Output = Vec4<T>

The resulting type after applying the * operator.

fn mul(self, m: Mat4<T>) -> Self

Performs the * operation.

impl<T> Mul<Vec3<T>> for Mat4<T>

where T: Copy + Add<Output = T> + Sub<Output = T> + Mul<Output = T>,

type Output = Mat4<T>

The resulting type after applying the * operator.

fn mul(self, v: Vec3<T>) -> Self

Performs the * operation.

impl<T> Mul<Vec4<T>> for Mat4<T>

where T: Copy + Add<Output = T> + Mul<Output = T>,

type Output = Mat4<T>

The resulting type after applying the * operator.

fn mul(self, v: Vec4<T>) -> Self

Performs the * operation.

impl<T> Mul for Mat4<T>

where T: Copy + Mul<Output = T> + Add<Output = T>,

type Output = Mat4<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> One for Mat4<T>

where T: One + Zero,

fn one() -> Self

impl<T: PartialEq> PartialEq for Mat4<T>

fn eq(&self, other: &Mat4<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Sub for Mat4<T>

where T: Sub<Output = T>,

type Output = Mat4<T>

The resulting type after applying the - operator.

fn sub(self, m: Self) -> Self

Performs the - operation.

impl<T> TypeSize<Mat4<T>> for Mat4<T>

fn type_size() -> usize

impl<T> Zero for Mat4<T>

where T: Zero,

fn zero() -> Self

impl<T: Copy> Copy for Mat4<T>

impl<T: Eq> Eq for Mat4<T>

impl<T> StructuralPartialEq for Mat4<T>