Struct batbox::Mat4

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

4x4 matrix

Implementations

impl<T: Copy> Mat4<T>

pub fn transpose(self) -> Self

Get transposed matrix.

Examples

use batbox::*;
let matrix = Mat4::translate(vec3(1, 2, 3));
let matrix_transposed = matrix.transpose();
for i in 0..4 {
    for j in 0..4 {
        assert_eq!(matrix[(i, j)], matrix_transposed[(j, i)]);
    }
}

impl<T: Num> Mat4<T>

pub fn from_orts(x: Vec3<T>, y: Vec3<T>, z: Vec3<T>) -> Self

impl<T: Float> Mat4<T>

pub fn inverse(self) -> Self

Get inverse matrix.

Examples

use batbox::*;
let matrix = Mat4::<f64>::rotate_x(0.123);
let matrix_inv = matrix.inverse();
let mult = matrix * matrix_inv;
for i in 0..4 {
    for j in 0..4 {
        assert!((mult[(i, j)] - if i == j { 1.0 } else { 0.0 }).abs() < 1e-5);
    }
}

impl<T: Float> Mat4<T>

pub fn perspective(fov: T, aspect: T, near: T, far: T) -> Self

Construct prespective projection matrix.

pub fn frustum(left: T, right: T, bottom: T, top: T, near: T, far: T) -> Self

Construct frustum projection matrix.

impl<T: Num + Copy> Mat4<T>

pub fn scale_uniform(factor: T) -> Self

Construct a uniform scale matrix.

Examples

use batbox::*;
let matrix = Mat4::scale_uniform(2);
assert_eq!(matrix * vec4(1, 2, 3, 1), vec4(2, 4, 6, 1));

pub fn scale(factor: Vec3<T>) -> Self

Construct a scale matrix.

Examples

use batbox::*;
let matrix = Mat4::scale(vec3(1, 2, 3));
assert_eq!(matrix * vec4(1, 2, 3, 1), vec4(1, 4, 9, 1));

pub fn translate(dv: Vec3<T>) -> Self

Construct a translation matrix.

Examples

use batbox::*;
let matrix = Mat4::translate(vec3(3, 2, 1));
assert_eq!(matrix * vec4(1, 2, 3, 1), vec4(4, 4, 4, 1));

impl<T: Float> Mat4<T>

pub fn rotate_x(angle: T) -> Self

Construct matrix rotating around x axis.

pub fn rotate_y(angle: T) -> Self

Construct matrix rotating around y axis.

pub fn rotate_z(angle: T) -> Self

Construct matrix rotating around z axis.

pub fn rotate(v: Vec3<T>, angle: T) -> Self where
    T: SubAssign + AddAssign, 

impl<T> Mat4<T>

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

impl<T: Copy> Mat4<T>

pub fn new(values: [[T; 4]; 4]) -> Self

Construct a matrix.

Examples

use batbox::*;
let matrix = Mat4::new([
    [1, 2, 3, 4],
    [3, 4, 5, 6],
    [5, 6, 7, 8],
    [0, 5, 2, 9],
]);

pub fn row(&self, row_index: usize) -> Vec4<T>

impl<T> Mat4<T>

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

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

impl<T: Num + Copy> Mat4<T>

pub fn zero() -> Self

Construct zero matrix.

Examples

use batbox::*;
let matrix = Mat4::<i32>::zero();
for i in 0..4 {
    for j in 0..4 {
        assert_eq!(matrix[(i, j)], 0);
    }
}

pub fn identity() -> Self

Construct identity matrix.

Examples

use batbox::*;
let matrix = Mat4::<i32>::identity();
for i in 0..4 {
    for j in 0..4 {
        assert_eq!(matrix[(i, j)], if i == j { 1 } else { 0 });
    }
}

Trait Implementations

impl<T: Num + Copy> Add<Mat4<T>> for Mat4<T>

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Num + Copy + AddAssign> AddAssign<Mat4<T>> for Mat4<T>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Float> ApproxEq for Mat4<T>

fn approx_distance_to(&self, other: &Self) -> f32

fn approx_eq(&self, other: &Self) -> bool

fn approx_eq_eps(&self, other: &Self, eps: f32) -> bool

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Mat4<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: Num + Copy> Div<T> for Mat4<T>

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self

Performs the / operation.

impl<T: Num + Copy + DivAssign> DivAssign<T> for Mat4<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

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

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

Performs the conversion.

impl<T> Index<(usize, usize)> for Mat4<T>

type Output = T

The returned type after indexing.

fn index(&self, (row, col): (usize, usize)) -> &T

Performs the indexing (container[index]) operation.

impl<T> IndexMut<(usize, usize)> for Mat4<T>

fn index_mut(&mut self, (row, col): (usize, usize)) -> &mut T

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

impl<T: Num + Copy + AddAssign> Mul<Mat4<T>> for Mat4<T>

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Num + Copy> Mul<T> for Mat4<T>

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Num + Copy> Mul<Vec4<T>> for Mat4<T>

type Output = Vec4<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Num + Copy + AddAssign> MulAssign<Mat4<T>> for Mat4<T>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: Num + Copy + MulAssign> MulAssign<T> for Mat4<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Num + Copy + Neg<Output = T>> Neg for Mat4<T>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T> Serialize for Mat4<T> where
    T: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<T: Num + Copy> Sub<Mat4<T>> for Mat4<T>

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Num + Copy + SubAssign> SubAssign<Mat4<T>> for Mat4<T>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.