Struct vodk_math::matrix::Matrix4x4

pub struct Matrix4x4<From, To> {
    pub _11: f32,
    pub _21: f32,
    pub _31: f32,
    pub _41: f32,
    pub _12: f32,
    pub _22: f32,
    pub _32: f32,
    pub _42: f32,
    pub _13: f32,
    pub _23: f32,
    pub _33: f32,
    pub _43: f32,
    pub _14: f32,
    pub _24: f32,
    pub _34: f32,
    pub _44: f32,
    // some fields omitted
}

Fields

_11: f32

_21: f32

_31: f32

_41: f32

_12: f32

_22: f32

_32: f32

_42: f32

_13: f32

_23: f32

_33: f32

_43: f32

_14: f32

_24: f32

_34: f32

_44: f32

Methods

impl<From, To> Matrix4x4<From, To>

fn from_slice(from: &[f32]) -> Matrix4x4<From, To>

fn as_slice<'l>(&'l self) -> &'l [f32]

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

fn as_mut_slice<'l>(&'l mut self) -> &'l mut [f32]

fn transform(&self, p: Vector4D<From>) -> Vector4D<To>

fn row_1<'l>(&'l self) -> &'l [f32; 4]

fn row_2<'l>(&'l self) -> &'l [f32; 4]

fn row_3<'l>(&'l self) -> &'l [f32; 4]

fn row_4<'l>(&'l self) -> &'l [f32; 4]

fn identity() -> Matrix4x4<From, To>

fn scale(v: Vector3D<To>) -> Matrix4x4<From, To>

fn translation(v: Vector3D<To>) -> Matrix4x4<From, To>

fn set_indentity(&mut self)

impl<From, To> Matrix4x4<From, To>

fn rotate(&mut self, rad: f32, axis: Vector3D<From>)

fn translate(&mut self, v: Vector3D<To>)

fn pre_translate(&mut self, v: Vector3D<From>)

Similar to translate, but the translation is applied before the matrix's existing transformation.

fn scale_by(&mut self, v: Vector3D<To>)

fn invert(&self, out: &mut Matrix4x4<To, From>) -> bool

fn is_2d(&self) -> bool

fn has_non_translation(&self) -> bool

impl<From, To> Matrix4x4<From, To>

fn new(
    a11: f32,
    a21: f32,
    a31: f32,
    a41: f32,
    a12: f32,
    a22: f32,
    a32: f32,
    a42: f32,
    a13: f32,
    a23: f32,
    a33: f32,
    a43: f32,
    a14: f32,
    a24: f32,
    a34: f32,
    a44: f32
) -> Matrix4x4<From, To>

fn perspective(
    fovy: f32,
    aspect: f32,
    near: f32,
    far: f32,
    mat: &mut Matrix4x4<From, To>
)

fn rotation(rad: f32, s: Vector3D<From>) -> Matrix4x4<From, To>

Trait Implementations

impl<From: PartialEq, To: PartialEq> PartialEq for Matrix4x4<From, To>

fn eq(&self, __arg_0: &Matrix4x4<From, To>) -> bool

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

fn ne(&self, __arg_0: &Matrix4x4<From, To>) -> bool

This method tests for !=.

impl<From, Inter, To> Mul<Matrix4x4<Inter, To>> for Matrix4x4<From, Inter>

type Output = Matrix4x4<From, To>

The resulting type after applying the * operator

fn mul(self, rhs: Matrix4x4<Inter, To>) -> Matrix4x4<From, To>

The method for the * operator

impl<From, To> Copy for Matrix4x4<From, To>

impl<From, To> Clone for Matrix4x4<From, To>

fn clone(&self) -> Matrix4x4<From, To>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<From: Unit, To: Unit> Debug for Matrix4x4<From, To>

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

Formats the value using the given formatter.