Struct geng_core::prelude::Mat4

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

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<T> + AddAssign<T>, 

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<Mat4<T>> 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<Mat4<T>> for Mat4<T> where
    T: Num + Copy + AddAssign<T>, 

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 copy of the value.

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

Performs copy-assignment from source.

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

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

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

type Output = T

The returned type after indexing.

fn index(&self, (usize, usize)) -> &Tⓘ

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

Performs the indexing (container[index]) operation.

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

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

Important traits for &'_ mut R

impl<'_, R> Read for &'_ mut R where
    R: Read + ?Sized, impl<'_, W> Write for &'_ mut W where
    W: Write + ?Sized, impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized,  type Output = <F as Future>::Output;

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

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

type Output = Mat4<T>

The resulting type after applying the * operator.

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

Performs the * 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> MulAssign<Mat4<T>> for Mat4<T> where
    T: Num + Copy + AddAssign<T>, 

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

Performs the *= operation.

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

fn mul_assign(&mut self, rhs: 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<Mat4<T>> 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<Mat4<T>> for Mat4<T> where
    T: Num + Copy + SubAssign<T>, 

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

Performs the -= operation.

impl Uniform for Mat4<f32>

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