Struct Mat4

#[repr(C)]
pub struct Mat4<T>(/* private fields */);

4x4 matrix

Implementations

impl<T> Mat4<T>

where T: Copy,

pub fn transpose(self) -> Mat4<T>

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> Mat4<T>

where T: Num,

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

impl<T> Mat4<T>

where T: Float,

pub fn inverse(self) -> Mat4<T>

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> Mat4<T>

where T: Float,

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

Construct prespective projection matrix.

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

Construct frustum projection matrix.

impl<T> Mat4<T>

where T: Num + Copy,

pub fn scale_uniform(factor: T) -> Mat4<T>

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>) -> Mat4<T>

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>) -> Mat4<T>

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> Mat4<T>

where T: Float,

pub fn rotate_x(angle: T) -> Mat4<T>

Construct matrix rotating around x axis.

pub fn rotate_y(angle: T) -> Mat4<T>

Construct matrix rotating around y axis.

pub fn rotate_z(angle: T) -> Mat4<T>

Construct matrix rotating around z axis.

pub fn rotate(v: Vec3<T>, angle: T) -> Mat4<T>

where T: SubAssign + AddAssign,

impl<T> Mat4<T>

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

where F: Fn(T) -> U,

impl<T> Mat4<T>

where T: Copy,

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

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> Mat4<T>

where T: Num + Copy,

pub fn zero() -> Mat4<T>

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() -> Mat4<T>

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> Add for Mat4<T>

where T: Num + Copy,

type Output = Mat4<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> AddAssign for Mat4<T>

where T: Num + Copy + AddAssign,

fn add_assign(&mut self, rhs: Mat4<T>)

Performs the += operation.

impl<T> ApproxEq for Mat4<T>

where T: Float,

fn approx_distance_to(&self, other: &Mat4<T>) -> f32

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

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

impl<T> Clone for Mat4<T>

where T: Clone,

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 for Mat4<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 Mat4<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Div<T> for Mat4<T>

where T: Num + Copy,

type Output = Mat4<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> DivAssign<T> for Mat4<T>

where T: Num + Copy + DivAssign,

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> Index<(usize, usize)> for Mat4<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

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

where T: Num + Copy,

type Output = Mat4<T>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: Num + Copy,

type Output = Vec4<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul for Mat4<T>

where T: Num + Copy + AddAssign,

type Output = Mat4<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> MulAssign<T> for Mat4<T>

where T: Num + Copy + MulAssign,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T> MulAssign for Mat4<T>

where T: Num + Copy + AddAssign,

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

Performs the *= operation.

impl<T> Neg for Mat4<T>

where T: Num<Output = T> + Copy + Neg,

type Output = Mat4<T>

The resulting type after applying the - operator.

fn neg(self) -> Mat4<T>

Performs the unary - operation.

impl<T> Serialize for Mat4<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> Sub for Mat4<T>

where T: Num + Copy,

type Output = Mat4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Mat4<T>) -> Mat4<T>

Performs the - operation.

impl<T> SubAssign for Mat4<T>

where T: Num + Copy + SubAssign,

fn sub_assign(&mut self, rhs: Mat4<T>)

Performs the -= operation.

impl Uniform for Mat4<f32>

fn apply(&self, gl: &Context, info: &UniformInfo)

impl<T> Copy for Mat4<T>

where T: Copy,