Struct veloren_voxygen_anim :: vek :: Mat4 Copy item path

impl<T> Mat4<T>

pub fn identity() -> Mat4<T>
where T: Zero + One,

The identity matrix, which is also the default value for square matrices.

assert_eq!(Mat4::<f32>::default(), Mat4::<f32>::identity());

pub fn zero() -> Mat4<T>
where T: Zero,

The matrix with all elements set to zero.

pub fn apply<F>(&mut self, f: F)
where T: Copy, F: FnMut(T) -> T,

Applies the function f to each element of this matrix, in-place.

For an example, see the map() method.

pub fn apply2<F, S>(&mut self, other: Mat4<S>, f: F)
where T: Copy, F: FnMut(T, S) -> T,

Applies the function f to each element of this matrix, in-place.

For an example, see the map2() method.

pub fn numcast<D>(self) -> Option<Mat4<D>>
where T: NumCast, D: NumCast,

Returns a memberwise-converted copy of this matrix, using NumCast.

let m = Mat4::<f32>::identity();
let m: Mat4<i32> = m.numcast().unwrap();
assert_eq!(m, Mat4::identity());

pub fn broadcast_diagonal(val: T) -> Mat4<T>
where T: Zero + Copy,

Initializes a new matrix with elements of the diagonal set to val and the other to zero.

In a way, this is the same as single-argument matrix constructors in GLSL and GLM.

assert_eq!(Mat4::broadcast_diagonal(0), Mat4::zero());
assert_eq!(Mat4::broadcast_diagonal(1), Mat4::identity());
assert_eq!(Mat4::broadcast_diagonal(2), Mat4::new(
    2,0,0,0,
    0,2,0,0,
    0,0,2,0,
    0,0,0,2,
));

pub fn with_diagonal(d: Vec4<T>) -> Mat4<T>
where T: Zero + Copy,

Initializes a matrix by its diagonal, setting other elements to zero.

pub fn diagonal(self) -> Vec4<T>

Gets the matrix’s diagonal into a vector.

assert_eq!(Mat4::<u32>::zero().diagonal(), Vec4::zero());
assert_eq!(Mat4::<u32>::identity().diagonal(), Vec4::one());

let mut m = Mat4::zero();
m[(0, 0)] = 1;
m[(1, 1)] = 2;
m[(2, 2)] = 3;
m[(3, 3)] = 4;
assert_eq!(m.diagonal(), Vec4::new(1, 2, 3, 4));
assert_eq!(m.diagonal(), Vec4::iota() + 1);

pub fn trace(self) -> T
where T: Add<Output = T>,

The sum of the diagonal’s elements.

assert_eq!(Mat4::<u32>::zero().trace(), 0);
assert_eq!(Mat4::<u32>::identity().trace(), 4);

pub fn mul_memberwise(self, m: Mat4<T>) -> Mat4<T>
where T: Mul<Output = T>,

Multiply elements of this matrix with another’s.


let m = Mat4::new(
    0, 1, 2, 3,
    1, 2, 3, 4,
    2, 3, 4, 5,
    3, 4, 5, 6,
);
let r = Mat4::new(
    0, 1, 4, 9,
    1, 4, 9, 16,
    4, 9, 16, 25,
    9, 16, 25, 36,
);
assert_eq!(m.mul_memberwise(m), r);

pub fn row_count(&self) -> usize

Convenience for getting the number of rows of this matrix.

pub fn col_count(&self) -> usize

Convenience for getting the number of columns of this matrix.

pub const ROW_COUNT: usize = 4usize

Convenience constant representing the number of rows for matrices of this type.

pub const COL_COUNT: usize = 4usize

Convenience constant representing the number of columns for matrices of this type.

pub fn is_packed(&self) -> bool

Are all elements of this matrix tightly packed together in memory ?

This might not be the case for matrices in the repr_simd module (it depends on the target architecture).

impl<T> Mat4<T>

pub fn map_cols<D, F>(self, f: F) -> Mat4<D>
where F: FnMut(Vec4<T>) -> Vec4<D>,

Returns a column-wise-converted copy of this matrix, using the given conversion closure.

use vek::mat::repr_c::column_major::Mat4;

let m = Mat4::<f32>::new(
    0.25, 1.25, 5.56, 8.66,
    8.53, 2.92, 3.86, 9.36,
    1.02, 0.28, 5.52, 6.06,
    6.20, 7.01, 4.90, 5.26
);
let m = m.map_cols(|col| col.map(|x| x.round() as i32));
assert_eq!(m, Mat4::new(
    0, 1, 6, 9,
    9, 3, 4, 9,
    1, 0, 6, 6,
    6, 7, 5, 5
));

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

Converts this matrix into a fixed-size array of elements.

use vek::mat::repr_c::column_major::Mat4;

let m = Mat4::<u32>::new(
     0,  1,  2,  3,
     4,  5,  6,  7,
     8,  9, 10, 11,
    12, 13, 14, 15
);
let array = [
    0, 4, 8, 12,
    1, 5, 9, 13,
    2, 6, 10, 14,
    3, 7, 11, 15
];
assert_eq!(m.into_col_array(), array);

pub fn into_col_arrays(self) -> [[T; 4]; 4]

Converts this matrix into a fixed-size array of fixed-size arrays of elements.

use vek::mat::repr_c::column_major::Mat4;

let m = Mat4::<u32>::new(
     0,  1,  2,  3,
     4,  5,  6,  7,
     8,  9, 10, 11,
    12, 13, 14, 15
);
let array = [
    [ 0, 4,  8, 12, ],
    [ 1, 5,  9, 13, ],
    [ 2, 6, 10, 14, ],
    [ 3, 7, 11, 15, ],
];
assert_eq!(m.into_col_arrays(), array);

pub fn from_col_array(array: [T; 16]) -> Mat4<T>

Converts a fixed-size array of elements into a matrix.

use vek::mat::repr_c::column_major::Mat4;

let m = Mat4::<u32>::new(
     0,  1,  2,  3,
     4,  5,  6,  7,
     8,  9, 10, 11,
    12, 13, 14, 15
);
let array = [
    0, 4, 8, 12,
    1, 5, 9, 13,
    2, 6, 10, 14,
    3, 7, 11, 15
];
assert_eq!(m, Mat4::from_col_array(array));

pub fn from_col_arrays(array: [[T; 4]; 4]) -> Mat4<T>

Converts a fixed-size array of fixed-size arrays of elements into a matrix.

use vek::mat::repr_c::column_major::Mat4;

let m = Mat4::<u32>::new(
     0,  1,  2,  3,
     4,  5,  6,  7,
     8,  9, 10, 11,
    12, 13, 14, 15
);
let array = [
    [ 0, 4,  8, 12, ],
    [ 1, 5,  9, 13, ],
    [ 2, 6, 10, 14, ],
    [ 3, 7, 11, 15, ],
];
assert_eq!(m, Mat4::from_col_arrays(array));

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

Converts this matrix into a fixed-size array of elements.

use vek::mat::repr_c::column_major::Mat4;

let m = Mat4::<u32>::new(
     0,  1,  2,  3,
     4,  5,  6,  7,
     8,  9, 10, 11,
    12, 13, 14, 15
);
let array = [
     0,  1,  2,  3,
     4,  5,  6,  7,
     8,  9, 10, 11,
    12, 13, 14, 15
];
assert_eq!(m.into_row_array(), array);

pub fn into_row_arrays(self) -> [[T; 4]; 4]

Converts this matrix into a fixed-size array of fixed-size arrays of elements.

use vek::mat::repr_c::column_major::Mat4;

let m = Mat4::<u32>::new(
     0,  1,  2,  3,
     4,  5,  6,  7,
     8,  9, 10, 11,
    12, 13, 14, 15
);
let array = [
    [  0,  1,  2,  3, ],
    [  4,  5,  6,  7, ],
    [  8,  9, 10, 11, ],
    [ 12, 13, 14, 15, ],
];
assert_eq!(m.into_row_arrays(), array);

pub fn from_row_array(array: [T; 16]) -> Mat4<T>

Converts a fixed-size array of elements into a matrix.

use vek::mat::repr_c::column_major::Mat4;

let m = Mat4::<u32>::new(
     0,  1,  2,  3,
     4,  5,  6,  7,
     8,  9, 10, 11,
    12, 13, 14, 15
);
let array = [
     0,  1,  2,  3,
     4,  5,  6,  7,
     8,  9, 10, 11,
    12, 13, 14, 15
];
assert_eq!(m, Mat4::from_row_array(array));

pub fn from_row_arrays(array: [[T; 4]; 4]) -> Mat4<T>

Converts a fixed-size array of fixed-size array of elements into a matrix.

use vek::mat::repr_c::column_major::Mat4;

let m = Mat4::<u32>::new(
     0,  1,  2,  3,
     4,  5,  6,  7,
     8,  9, 10, 11,
    12, 13, 14, 15
);
let array = [
    [  0,  1,  2,  3, ],
    [  4,  5,  6,  7, ],
    [  8,  9, 10, 11, ],
    [ 12, 13, 14, 15, ],
];
assert_eq!(m, Mat4::from_row_arrays(array));

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

Gets a const pointer to this matrix’s elements.

§Panics

Panics if the matrix’s elements are not tightly packed in memory, which may be the case for matrices in the repr_simd module. You may check this with the is_packed() method.

pub fn as_mut_col_ptr(&mut self) -> *mut T

Gets a mut pointer to this matrix’s elements.

§Panics

Panics if the matrix’s elements are not tightly packed in memory, which may be the case for matrices in the repr_simd module. You may check this with the is_packed() method.

pub fn as_col_slice(&self) -> &[T]

View this matrix as an immutable slice.

§Panics

Panics if the matrix’s elements are not tightly packed in memory, which may be the case for matrices in the repr_simd module. You may check this with the is_packed() method.

pub fn as_mut_col_slice(&mut self) -> &mut [T]

View this matrix as a mutable slice.

§Panics

Panics if the matrix’s elements are not tightly packed in memory, which may be the case for matrices in the repr_simd module. You may check this with the is_packed() method.

impl<T> Mat4<T>

pub fn gl_should_transpose(&self) -> bool

Gets the transpose parameter to pass to OpenGL glUniformMatrix*() functions.

The return value is a plain bool which you may directly cast to a GLboolean.

This takes &self to prevent surprises when changing the type of matrix you plan to send.

pub const GL_SHOULD_TRANSPOSE: bool = false

The transpose parameter to pass to OpenGL glUniformMatrix*() functions.

impl<T> Mat4<T>

pub fn new( m00: T, m01: T, m02: T, m03: T, m10: T, m11: T, m12: T, m13: T, m20: T, m21: T, m22: T, m23: T, m30: T, m31: T, m32: T, m33: T, ) -> Mat4<T>

Creates a new 4x4 matrix from elements in a layout-agnostic way.

The parameters are named mij where i is the row index and j the column index. Their order is always the same regardless of the matrix’s layout.

impl<T> Mat4<T>

pub fn map<D, F>(self, f: F) -> Mat4<D>
where F: FnMut(T) -> D,

Returns an element-wise-converted copy of this matrix, using the given conversion closure.

use vek::mat::repr_c::row_major::Mat4;

let m = Mat4::<f32>::new(
    0.25, 1.25, 5.56, 8.66,
    8.53, 2.92, 3.86, 9.36,
    1.02, 0.28, 5.52, 6.06,
    6.20, 7.01, 4.90, 5.26
);
let m = m.map(|x| x.round() as i32);
assert_eq!(m, Mat4::new(
    0, 1, 6, 9,
    9, 3, 4, 9,
    1, 0, 6, 6,
    6, 7, 5, 5
));

pub fn as_<D>(self) -> Mat4<D>
where T: AsPrimitive<D>, D: 'static + Copy,

Returns a memberwise-converted copy of this matrix, using AsPrimitive.

§Examples

let v = Vec4::new(0_f32, 1., 2., 3.);
let i: Vec4<i32> = v.as_();
assert_eq!(i, Vec4::new(0, 1, 2, 3));

§Safety

In Rust versions before 1.45.0, some uses of the as operator were not entirely safe. In particular, it was undefined behavior if a truncated floating point value could not fit in the target integer type (#10184);

let x: u8 = (1.04E+17).as_(); // UB

pub fn map2<D, F, S>(self, other: Mat4<S>, f: F) -> Mat4<D>
where F: FnMut(T, S) -> D,

Applies the function f to each element of two matrices, pairwise, and returns the result.

use vek::mat::repr_c::row_major::Mat4;

let a = Mat4::<f32>::new(
    0.25, 1.25, 2.52, 2.99,
    0.25, 1.25, 2.52, 2.99,
    0.25, 1.25, 2.52, 2.99,
    0.25, 1.25, 2.52, 2.99
);
let b = Mat4::<i32>::new(
    0, 1, 0, 0,
    1, 0, 0, 0,
    0, 0, 1, 0,
    0, 0, 0, 1
);
let m = a.map2(b, |a, b| a.round() as i32 + b);
assert_eq!(m, Mat4::new(
    0, 2, 3, 3,
    1, 1, 3, 3,
    0, 1, 4, 3,
    0, 1, 3, 4
));

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

The matrix’s transpose.

For orthogonal matrices, the transpose is the same as the inverse. All pure rotation matrices are orthogonal, and therefore can be inverted faster by simply computing their transpose.

use std::f32::consts::PI;

let m = Mat4::new(
    0, 1, 2, 3,
    4, 5, 6, 7,
    8, 9, 0, 1,
    2, 3, 4, 5
);
let t = Mat4::new(
    0, 4, 8, 2,
    1, 5, 9, 3,
    2, 6, 0, 4,
    3, 7, 1, 5
);
assert_eq!(m.transposed(), t);
assert_eq!(m, m.transposed().transposed());

// By the way, demonstrate ways to invert a rotation matrix,
// from fastest (specific) to slowest (general-purpose).
let m = Mat4::rotation_x(PI/7.);
let id = Mat4::identity();
assert_relative_eq!(id, m * m.transposed());
assert_relative_eq!(id, m.transposed() * m);
assert_relative_eq!(id, m * m.inverted_affine_transform_no_scale());
assert_relative_eq!(id, m.inverted_affine_transform_no_scale() * m);
assert_relative_eq!(id, m * m.inverted_affine_transform());
assert_relative_eq!(id, m.inverted_affine_transform() * m);
assert_relative_eq!(id, m * m.inverted());
assert_relative_eq!(id, m.inverted() * m);

pub fn transpose(&mut self)

Transpose this matrix.


let mut m = Mat4::new(
    0, 1, 2, 3,
    4, 5, 6, 7,
    8, 9, 0, 1,
    2, 3, 4, 5
);
let t = Mat4::new(
    0, 4, 8, 2,
    1, 5, 9, 3,
    2, 6, 0, 4,
    3, 7, 1, 5
);
m.transpose();
assert_eq!(m, t);

pub fn determinant(self) -> T
where T: Copy + Mul<Output = T> + Sub<Output = T> + Add<Output = T>,

Get this matrix’s determinant.

A matrix is invertible if its determinant is non-zero.

pub fn invert(&mut self)
where T: Real,

Inverts this matrix, blindly assuming that it is invertible. See inverted() for more info.

pub fn inverted(self) -> Mat4<T>
where T: Real,

Returns this matrix’s inverse, blindly assuming that it is invertible.

All affine matrices have inverses; Your matrices may be affine as long as they consist of any combination of pure rotations, translations, scales and shears.

use vek::vec::repr_c::Vec3;
use vek::mat::repr_c::row_major::Mat4 as Rows4;
use vek::mat::repr_c::column_major::Mat4 as Cols4;
use std::f32::consts::PI;

let a = Rows4::scaling_3d(1.77_f32)
    .rotated_3d(PI*4./5., Vec3::new(5., 8., 10.))
    .translated_3d(Vec3::new(1., 2., 3.));
let b = a.inverted();
assert_relative_eq!(a*b, Rows4::identity(), epsilon = 0.000001);
assert_relative_eq!(b*a, Rows4::identity(), epsilon = 0.000001);

let a = Cols4::scaling_3d(1.77_f32)
    .rotated_3d(PI*4./5., Vec3::new(5., 8., 10.))
    .translated_3d(Vec3::new(1., 2., 3.));
let b = a.inverted();
assert_relative_eq!(a*b, Cols4::identity(), epsilon = 0.000001);
assert_relative_eq!(b*a, Cols4::identity(), epsilon = 0.000001);

// Beware, projection matrices are not invertible!
// Notice that we assert _inequality_ below.
let a = Cols4::perspective_rh_zo(60_f32.to_radians(), 16./9., 0.001, 1000.) * a;
let b = a.inverted();
assert_relative_ne!(a*b, Cols4::identity(), epsilon = 0.000001);
assert_relative_ne!(b*a, Cols4::identity(), epsilon = 0.000001);

pub fn invert_affine_transform_no_scale(&mut self)
where T: Real,

Returns this matrix’s inverse, blindly assuming that it is an invertible transform matrix which scale is 1.

See inverted_affine_transform_no_scale() for more info.

pub fn inverted_affine_transform_no_scale(self) -> Mat4<T>
where T: Real,

Returns this matrix’s inverse, blindly assuming that it is an invertible transform matrix which scale is 1.

A transform matrix is invertible this way as long as it consists of translations, rotations, and shears. It’s not guaranteed to work if the scale is not 1.

use vek::vec::repr_c::Vec3;
use vek::mat::repr_c::row_major::Mat4 as Rows4;
use vek::mat::repr_c::column_major::Mat4 as Cols4;
use std::f32::consts::PI;

let a = Rows4::rotation_3d(PI*4./5., Vec3::new(5., 8., 10.))
    .translated_3d(Vec3::new(1., 2., 3.));
let b = a.inverted_affine_transform_no_scale();
assert_relative_eq!(a*b, Rows4::identity(), epsilon = 0.000001);
assert_relative_eq!(b*a, Rows4::identity(), epsilon = 0.000001);

let a = Cols4::rotation_3d(PI*4./5., Vec3::new(5., 8., 10.))
    .translated_3d(Vec3::new(1., 2., 3.));
let b = a.inverted_affine_transform_no_scale();
assert_relative_eq!(a*b, Cols4::identity(), epsilon = 0.000001);
assert_relative_eq!(b*a, Cols4::identity(), epsilon = 0.000001);

// Look! It stops working as soon as we add a scale.
// Notice that we assert _inequality_ below.
let a = Rows4::scaling_3d(5_f32)
    .rotated_3d(PI*4./5., Vec3::new(5., 8., 10.))
    .translated_3d(Vec3::new(1., 2., 3.));
let b = a.inverted_affine_transform_no_scale();
assert_relative_ne!(a*b, Rows4::identity(), epsilon = 0.000001);
assert_relative_ne!(b*a, Rows4::identity(), epsilon = 0.000001);

pub fn invert_affine_transform(&mut self)
where T: Real,

Inverts this matrix, blindly assuming that it is an invertible transform matrix. See inverted_affine_transform() for more info.

pub fn inverted_affine_transform(self) -> Mat4<T>
where T: Real,

Returns this matrix’s inverse, blindly assuming that it is an invertible transform matrix.

A transform matrix is invertible this way as long as it consists of translations, rotations, scales and shears.

use vek::vec::repr_c::Vec3;
use vek::mat::repr_c::row_major::Mat4 as Rows4;
use vek::mat::repr_c::column_major::Mat4 as Cols4;
use std::f32::consts::PI;

let a = Rows4::scaling_3d(1.77_f32)
    .rotated_3d(PI*4./5., Vec3::new(5., 8., 10.))
    .translated_3d(Vec3::new(1., 2., 3.));
let b = a.inverted_affine_transform();
assert_relative_eq!(a*b, Rows4::identity(), epsilon = 0.000001);
assert_relative_eq!(b*a, Rows4::identity(), epsilon = 0.000001);

let a = Cols4::scaling_3d(1.77_f32)
    .rotated_3d(PI*4./5., Vec3::new(5., 8., 10.))
    .translated_3d(Vec3::new(1., 2., 3.));
let b = a.inverted_affine_transform();
assert_relative_eq!(a*b, Cols4::identity(), epsilon = 0.000001);
assert_relative_eq!(b*a, Cols4::identity(), epsilon = 0.000001);

pub fn mul_point<V>(self, rhs: V) -> V
where V: Into<Vec3<T>> + From<Vec4<T>>, T: Real + MulAdd<Output = T>,

Shortcut for self * Vec4::from_point(rhs).

pub fn mul_direction<V>(self, rhs: V) -> V
where V: Into<Vec3<T>> + From<Vec4<T>>, T: Real + MulAdd<Output = T>,

Shortcut for self * Vec4::from_direction(rhs).

pub fn translate_2d<V>(&mut self, v: V)
where V: Into<Vec2<T>>, T: Real + MulAdd<Output = T>,

Translates this matrix in 2D.

pub fn translated_2d<V>(self, v: V) -> Mat4<T>
where V: Into<Vec2<T>>, T: Real + MulAdd<Output = T>,

Returns this matrix translated in 2D.

pub fn translation_2d<V>(v: V) -> Mat4<T>
where V: Into<Vec2<T>>, T: Zero + One,

Creates a 2D translation matrix.

pub fn translate_3d<V>(&mut self, v: V)
where V: Into<Vec3<T>>, T: Real + MulAdd<Output = T>,

Translates this matrix in 3D.

pub fn translated_3d<V>(self, v: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Real + MulAdd<Output = T>,

Returns this matrix translated in 3D.

pub fn translation_3d<V>(v: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Zero + One,

Creates a 3D translation matrix.

pub fn scale_3d<V>(&mut self, v: V)
where V: Into<Vec3<T>>, T: Real + MulAdd<Output = T>,

Scales this matrix in 3D.

pub fn scaled_3d<V>(self, v: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Real + MulAdd<Output = T>,

Returns this matrix scaled in 3D.

pub fn scaling_3d<V>(v: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Zero + One,

Creates a 3D scaling matrix.

pub fn rotate_x(&mut self, angle_radians: T)
where T: Real + MulAdd<Output = T>,

Rotates this matrix around the X axis.

pub fn rotated_x(self, angle_radians: T) -> Mat4<T>
where T: Real + MulAdd<Output = T>,

Returns this matrix rotated around the X axis.

pub fn rotation_x(angle_radians: T) -> Mat4<T>
where T: Real,

Creates a matrix that rotates around the X axis.

pub fn rotate_y(&mut self, angle_radians: T)
where T: Real + MulAdd<Output = T>,

Rotates this matrix around the Y axis.

pub fn rotated_y(self, angle_radians: T) -> Mat4<T>
where T: Real + MulAdd<Output = T>,

Returns this matrix rotated around the Y axis.

pub fn rotation_y(angle_radians: T) -> Mat4<T>
where T: Real,

Creates a matrix that rotates around the Y axis.

pub fn rotate_z(&mut self, angle_radians: T)
where T: Real + MulAdd<Output = T>,

Rotates this matrix around the Z axis.

pub fn rotated_z(self, angle_radians: T) -> Mat4<T>
where T: Real + MulAdd<Output = T>,

Returns this matrix rotated around the Z axis.

pub fn rotation_z(angle_radians: T) -> Mat4<T>
where T: Real,

Creates a matrix that rotates around the Z axis.

pub fn rotate_3d<V>(&mut self, angle_radians: T, axis: V)
where V: Into<Vec3<T>>, T: Real<Output = T> + MulAdd<Output = T> + Add,

Rotates this matrix around a 3D axis. The axis is not required to be normalized.

pub fn rotated_3d<V>(self, angle_radians: T, axis: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Real<Output = T> + MulAdd<Output = T> + Add,

Returns this matrix rotated around a 3D axis. The axis is not required to be normalized.

pub fn rotation_3d<V>(angle_radians: T, axis: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Real<Output = T> + Add,

Creates a matrix that rotates around a 3D axis. The axis is not required to be normalized.

use std::f32::consts::PI;

let v = Vec4::unit_x();

let m = Mat4::rotation_z(PI);
assert_relative_eq!(m * v, -v);

let m = Mat4::rotation_z(PI * 0.5);
assert_relative_eq!(m * v, Vec4::unit_y());

let m = Mat4::rotation_z(PI * 1.5);
assert_relative_eq!(m * v, -Vec4::unit_y());

let angles = 32;
for i in 0..angles {
    let theta = PI * 2. * (i as f32) / (angles as f32);

    // See what rotating unit vectors do for most angles between 0 and 2*PI.
    // It's helpful to picture this as a right-handed coordinate system.

    let v = Vec4::unit_y();
    let m = Mat4::rotation_x(theta);
    assert_relative_eq!(m * v, Vec4::new(0., theta.cos(), theta.sin(), 0.));

    let v = Vec4::unit_z();
    let m = Mat4::rotation_y(theta);
    assert_relative_eq!(m * v, Vec4::new(theta.sin(), 0., theta.cos(), 0.));

    let v = Vec4::unit_x();
    let m = Mat4::rotation_z(theta);
    assert_relative_eq!(m * v, Vec4::new(theta.cos(), theta.sin(), 0., 0.));

    assert_relative_eq!(Mat4::rotation_x(theta), Mat4::rotation_3d(theta, Vec4::unit_x()));
    assert_relative_eq!(Mat4::rotation_y(theta), Mat4::rotation_3d(theta, Vec4::unit_y()));
    assert_relative_eq!(Mat4::rotation_z(theta), Mat4::rotation_3d(theta, Vec4::unit_z()));
}

pub fn rotation_from_to_3d<V>(from: V, to: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Real<Output = T> + Add,

Creates a matrix that would rotate a from direction to to.


let (from, to) = (Vec4::<f32>::unit_x(), Vec4::<f32>::unit_z());
let m = Mat4::<f32>::rotation_from_to_3d(from, to);
assert_relative_eq!(m * from, to);

let (from, to) = (Vec4::<f32>::unit_x(), -Vec4::<f32>::unit_x());
let m = Mat4::<f32>::rotation_from_to_3d(from, to);
assert_relative_eq!(m * from, to);

pub fn basis_to_local<V>(origin: V, i: V, j: V, k: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Zero<Output = T> + One + Neg<Output = T> + Real + Add,

Builds a change of basis matrix that transforms points and directions from any space to the canonical one.

origin is the origin of the child space. i, j and k are all required to be normalized; They are the unit basis vector along the target space x-axis, y-axis and z-axis respectively, expressed in canonical-space coordinates.

    let origin = Vec3::new(1_f32, 2., 3.);
    let i = Vec3::unit_z();
    let j = Vec3::unit_y();
    let k = Vec3::unit_x();
    let m = Mat4::basis_to_local(origin, i, j, k);
    assert_relative_eq!(m.mul_point(origin), Vec3::zero());
    assert_relative_eq!(m.mul_point(origin+i), Vec3::unit_x());
    assert_relative_eq!(m.mul_point(origin+j), Vec3::unit_y());
    assert_relative_eq!(m.mul_point(origin+k), Vec3::unit_z());

    // `local_to_basis` and `basis_to_local` undo each other
    let a = Mat4::<f32>::basis_to_local(origin, i, j, k);
    let b = Mat4::<f32>::local_to_basis(origin, i, j, k);
    assert_relative_eq!(a*b, Mat4::identity());
    assert_relative_eq!(b*a, Mat4::identity());

Slightly more contrived example:

    let origin = Vec3::new(1_f32, 2., 3.);
    let r = Mat4::rotation_3d(3., Vec3::new(2_f32, 1., 3.));
    let i = r.mul_direction(Vec3::unit_x());
    let j = r.mul_direction(Vec3::unit_y());
    let k = r.mul_direction(Vec3::unit_z());
    let m = Mat4::basis_to_local(origin, i, j, k);
    assert_relative_eq!(m.mul_point(origin), Vec3::zero(), epsilon = 0.000001);
    assert_relative_eq!(m.mul_point(origin+i), Vec3::unit_x(), epsilon = 0.000001);
    assert_relative_eq!(m.mul_point(origin+j), Vec3::unit_y(), epsilon = 0.000001);
    assert_relative_eq!(m.mul_point(origin+k), Vec3::unit_z(), epsilon = 0.000001);

pub fn local_to_basis<V>(origin: V, i: V, j: V, k: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Zero + One,

Builds a change of basis matrix that transforms points and directions from canonical space to another space.

origin is the origin of the child space. i, j and k are all required to be normalized; They are the unit basis vector along the target space x-axis, y-axis and z-axis respectively, expressed in canonical-space coordinates.

    let origin = Vec3::new(1_f32, 2., 3.);
    let i = Vec3::unit_z();
    let j = Vec3::unit_y();
    let k = Vec3::unit_x();
    let m = Mat4::local_to_basis(origin, i, j, k);
    assert_relative_eq!(origin,   m.mul_point(Vec3::zero()));
    assert_relative_eq!(origin+i, m.mul_point(Vec3::unit_x()));
    assert_relative_eq!(origin+j, m.mul_point(Vec3::unit_y()));
    assert_relative_eq!(origin+k, m.mul_point(Vec3::unit_z()));

    // `local_to_basis` and `basis_to_local` undo each other
    let a = Mat4::<f32>::local_to_basis(origin, i, j, k);
    let b = Mat4::<f32>::basis_to_local(origin, i, j, k);
    assert_relative_eq!(a*b, Mat4::identity());
    assert_relative_eq!(b*a, Mat4::identity());

Slightly more contrived example:

    // Sanity test
    let origin = Vec3::new(1_f32, 2., 3.);
    let r = Mat4::rotation_3d(3., Vec3::new(2_f32, 1., 3.));
    let i = r.mul_direction(Vec3::unit_x());
    let j = r.mul_direction(Vec3::unit_y());
    let k = r.mul_direction(Vec3::unit_z());
    let m = Mat4::local_to_basis(origin, i, j, k);
    assert_relative_eq!(origin,   m.mul_point(Vec3::zero()));
    assert_relative_eq!(origin+i, m.mul_point(Vec3::unit_x()));
    assert_relative_eq!(origin+j, m.mul_point(Vec3::unit_y()));
    assert_relative_eq!(origin+k, m.mul_point(Vec3::unit_z()));

pub fn look_at<V>(eye: V, target: V, up: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Real<Output = T> + Add,

👎Deprecated since 0.9.7: Use look_at_lh() or look_at_rh() instead depending on your space’s handedness

Builds a “look at” view transform from an eye position, a target position, and up vector. Commonly used for cameras - in short, it maps points from world-space to eye-space.

pub fn look_at_lh<V>(eye: V, target: V, up: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Real<Output = T> + Add,

Builds a “look at” view transform for left-handed spaces from an eye position, a target position, and up vector. Commonly used for cameras - in short, it maps points from world-space to eye-space.

let eye = Vec4::new(1_f32, 0., 1., 1.);
let target = Vec4::new(2_f32, 0., 2., 1.);
let view = Mat4::<f32>::look_at_lh(eye, target, Vec4::unit_y());
assert_relative_eq!(view * eye, Vec4::unit_w());
assert_relative_eq!(view * target, Vec4::new(0_f32, 0., 2_f32.sqrt(), 1.));

pub fn look_at_rh<V>(eye: V, target: V, up: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Real<Output = T> + Add,

Builds a “look at” view transform for right-handed spaces from an eye position, a target position, and up vector. Commonly used for cameras - in short, it maps points from world-space to eye-space.

let eye = Vec4::new(1_f32, 0., 1., 1.);
let target = Vec4::new(2_f32, 0., 2., 1.);
let view = Mat4::<f32>::look_at_rh(eye, target, Vec4::unit_y());
assert_relative_eq!(view * eye, Vec4::unit_w());
assert_relative_eq!(view * target, Vec4::new(0_f32, 0., -2_f32.sqrt(), 1.));

pub fn model_look_at<V>(eye: V, target: V, up: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Real<Output = T> + Add,

👎Deprecated since 0.9.7: Use model_look_at_lh() or model_look_at_rh() instead depending on your space’s handedness

Builds a “look at” model transform from an eye position, a target position, and up vector. Preferred for transforming objects.

pub fn model_look_at_lh<V>(eye: V, target: V, up: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Real<Output = T> + Add,

Builds a “look at” model transform for left-handed spaces from an eye position, a target position, and up vector. Preferred for transforming objects.

let eye = Vec4::new(1_f32, 0., 1., 1.);
let target = Vec4::new(2_f32, 0., 2., 1.);
let model = Mat4::<f32>::model_look_at_lh(eye, target, Vec4::unit_y());
assert_relative_eq!(model * Vec4::unit_w(), eye);
let d = 2_f32.sqrt();
assert_relative_eq!(model * Vec4::new(0_f32, 0., d, 1.), target);

// A "model" look-at essentially undoes a "view" look-at
let view = Mat4::look_at_lh(eye, target, Vec4::unit_y());
assert_relative_eq!(view * model, Mat4::identity());
assert_relative_eq!(model * view, Mat4::identity());

pub fn model_look_at_rh<V>(eye: V, target: V, up: V) -> Mat4<T>
where V: Into<Vec3<T>>, T: Real<Output = T> + Add + MulAdd<Output = T>,

Builds a “look at” model transform for right-handed spaces from an eye position, a target position, and up vector. Preferred for transforming objects.

let eye = Vec4::new(1_f32, 0., -1., 1.);
let forward = Vec4::new(0_f32, 0., -1., 0.);
let model = Mat4::<f32>::model_look_at_rh(eye, eye + forward, Vec4::unit_y());
assert_relative_eq!(model * Vec4::unit_w(), eye);
assert_relative_eq!(model * forward, forward);

// A "model" look-at essentially undoes a "view" look-at
let view = Mat4::look_at_rh(eye, eye + forward, Vec4::unit_y());
assert_relative_eq!(view * model, Mat4::identity());
assert_relative_eq!(model * view, Mat4::identity());

pub fn orthographic_without_depth_planes(o: FrustumPlanes<T>) -> Mat4<T>
where T: Real,

Returns an orthographic projection matrix that doesn’t use near and far planes.

pub fn orthographic_lh_zo(o: FrustumPlanes<T>) -> Mat4<T>
where T: Real,

Returns an orthographic projection matrix for left-handed spaces, for a depth clip space ranging from 0 to 1 (GL_DEPTH_ZERO_TO_ONE, hence the _zo suffix).

let m = Mat4::orthographic_lh_zo(FrustumPlanes {
    left: -1_f32, right: 1., bottom: -1., top: 1.,
    near: 0., far: 1.
});
let v = Vec4::new(0_f32, 0., 1., 1.); // "forward"
assert_relative_eq!(m * v, Vec4::new(0., 0., 1., 1.)); // "far"

pub fn orthographic_lh_no(o: FrustumPlanes<T>) -> Mat4<T>
where T: Real,

Returns an orthographic projection matrix for left-handed spaces, for a depth clip space ranging from -1 to 1 (GL_DEPTH_NEGATIVE_ONE_TO_ONE, hence the _no suffix).

let m = Mat4::orthographic_lh_no(FrustumPlanes {
    left: -1_f32, right: 1., bottom: -1., top: 1.,
    near: 0., far: 1.
});
let v = Vec4::new(0_f32, 0., 1., 1.); // "forward"
assert_relative_eq!(m * v, Vec4::new(0., 0., 1., 1.)); // "far"

pub fn orthographic_rh_zo(o: FrustumPlanes<T>) -> Mat4<T>
where T: Real,

Returns an orthographic projection matrix for right-handed spaces, for a depth clip space ranging from 0 to 1 (GL_DEPTH_ZERO_TO_ONE, hence the _zo suffix).

let m = Mat4::orthographic_rh_zo(FrustumPlanes {
    left: -1_f32, right: 1., bottom: -1., top: 1.,
    near: 0., far: 1.
});
let v = Vec4::new(0_f32, 0., -1., 1.); // "forward"
assert_relative_eq!(m * v, Vec4::new(0., 0., 1., 1.)); // "far"

pub fn orthographic_rh_no(o: FrustumPlanes<T>) -> Mat4<T>
where T: Real,

Returns an orthographic projection matrix for right-handed spaces, for a depth clip space ranging from -1 to 1 (GL_DEPTH_NEGATIVE_ONE_TO_ONE, hence the _no suffix).

let m = Mat4::orthographic_rh_no(FrustumPlanes {
    left: -1_f32, right: 1., bottom: -1., top: 1.,
    near: 0., far: 1.
});
let v = Vec4::new(0_f32, 0., -1., 1.); // "forward"
assert_relative_eq!(m * v, Vec4::new(0., 0., 1., 1.)); // "far"

pub fn frustum_lh_zo(o: FrustumPlanes<T>) -> Mat4<T>
where T: Real,

Creates a perspective projection matrix from a frustum (left-handed, zero-to-one depth clip planes).

pub fn frustum_lh_no(o: FrustumPlanes<T>) -> Mat4<T>
where T: Real,

Creates a perspective projection matrix from a frustum (left-handed, negative-one-to-one depth clip planes).

pub fn frustum_rh_zo(o: FrustumPlanes<T>) -> Mat4<T>
where T: Real,

Creates a perspective projection matrix from a frustum (right-handed, zero-to-one depth clip planes).

pub fn frustum_rh_no(o: FrustumPlanes<T>) -> Mat4<T>
where T: Real,

Creates a perspective projection matrix from a frustum (right-handed, negative-one-to-one depth clip planes).

pub fn perspective_rh_zo( fov_y_radians: T, aspect_ratio: T, near: T, far: T, ) -> Mat4<T>
where T: Real + FloatConst + Debug,

Creates a perspective projection matrix for right-handed spaces, with zero-to-one depth clip planes.

pub fn perspective_lh_zo( fov_y_radians: T, aspect_ratio: T, near: T, far: T, ) -> Mat4<T>
where T: Real + FloatConst + Debug,

Creates a perspective projection matrix for left-handed spaces, with zero-to-one depth clip planes.

pub fn perspective_rh_no( fov_y_radians: T, aspect_ratio: T, near: T, far: T, ) -> Mat4<T>
where T: Real + FloatConst + Debug,

Creates a perspective projection matrix for right-handed spaces, with negative-one-to-one depth clip planes.

pub fn perspective_lh_no( fov_y_radians: T, aspect_ratio: T, near: T, far: T, ) -> Mat4<T>
where T: Real + FloatConst + Debug,

Creates a perspective projection matrix for left-handed spaces, with negative-one-to-one depth clip planes.

pub fn perspective_fov_rh_zo( fov_y_radians: T, width: T, height: T, near: T, far: T, ) -> Mat4<T>
where T: Real + FloatConst + Debug,

Creates a perspective projection matrix for right-handed spaces, with zero-to-one depth clip planes.

§Panics

width, height and fov_y_radians must all be strictly greater than zero.

pub fn perspective_fov_lh_zo( fov_y_radians: T, width: T, height: T, near: T, far: T, ) -> Mat4<T>
where T: Real + FloatConst + Debug,

Creates a perspective projection matrix for left-handed spaces, with zero-to-one depth clip planes.

§Panics

width, height and fov_y_radians must all be strictly greater than zero.

pub fn perspective_fov_rh_no( fov_y_radians: T, width: T, height: T, near: T, far: T, ) -> Mat4<T>
where T: Real + FloatConst + Debug,

Creates a perspective projection matrix for right-handed spaces, with negative-one-to-one depth clip planes.

§Panics

width, height and fov_y_radians must all be strictly greater than zero.

pub fn perspective_fov_lh_no( fov_y_radians: T, width: T, height: T, near: T, far: T, ) -> Mat4<T>
where T: Real + FloatConst + Debug,

Creates a perspective projection matrix for left-handed spaces, with negative-one-to-one depth clip planes.

§Panics

width, height and fov_y_radians must all be strictly greater than zero.

pub fn tweaked_infinite_perspective_rh( fov_y_radians: T, aspect_ratio: T, near: T, epsilon: T, ) -> Mat4<T>
where T: Real + FloatConst + Debug,

Creates an infinite perspective projection matrix for right-handed spaces.

Link to PDF

pub fn tweaked_infinite_perspective_lh( fov_y_radians: T, aspect_ratio: T, near: T, epsilon: T, ) -> Mat4<T>
where T: Real + FloatConst + Debug,

Creates an infinite perspective projection matrix for left-handed spaces.

pub fn infinite_perspective_rh( fov_y_radians: T, aspect_ratio: T, near: T, ) -> Mat4<T>
where T: Real + FloatConst + Debug,

Creates an infinite perspective projection matrix for right-handed spaces.

pub fn infinite_perspective_lh( fov_y_radians: T, aspect_ratio: T, near: T, ) -> Mat4<T>
where T: Real + FloatConst + Debug,

Creates an infinite perspective projection matrix for left-handed spaces.

pub fn picking_region<V2>( center: V2, delta: V2, viewport: Rect<T, T>, ) -> Mat4<T>
where V2: Into<Vec2<T>>, T: Real + MulAdd<Output = T>,

GLM’s pickMatrix. Creates a projection matrix that can be used to restrict drawing to a small region of the viewport.

§Panics

delta’s x and y are required to be strictly greater than zero.

pub fn world_to_viewport_no<V3>( obj: V3, modelview: Mat4<T>, proj: Mat4<T>, viewport: Rect<T, T>, ) -> Vec3<T>
where T: Real + MulAdd<Output = T>, V3: Into<Vec3<T>>,

Projects a world-space coordinate into screen space, for a depth clip space ranging from -1 to 1 (GL_DEPTH_NEGATIVE_ONE_TO_ONE, hence the _no suffix).

pub fn world_to_viewport_zo<V3>( obj: V3, modelview: Mat4<T>, proj: Mat4<T>, viewport: Rect<T, T>, ) -> Vec3<T>
where T: Real + MulAdd<Output = T>, V3: Into<Vec3<T>>,

Projects a world-space coordinate into screen space, for a depth clip space ranging from 0 to 1 (GL_DEPTH_ZERO_TO_ONE, hence the _zo suffix).

pub fn viewport_to_world_zo<V3>( ray: V3, modelview: Mat4<T>, proj: Mat4<T>, viewport: Rect<T, T>, ) -> Vec3<T>
where T: Real + MulAdd<Output = T>, V3: Into<Vec3<T>>,

Projects a screen-space coordinate into world space, for a depth clip space ranging from 0 to 1 (GL_DEPTH_ZERO_TO_ONE, hence the _zo suffix).

pub fn viewport_to_world_no<V3>( ray: V3, modelview: Mat4<T>, proj: Mat4<T>, viewport: Rect<T, T>, ) -> Vec3<T>
where T: Real + MulAdd<Output = T>, V3: Into<Vec3<T>>,

Projects a screen-space coordinate into world space, for a depth clip space ranging from -1 to 1 (GL_DEPTH_NEGATIVE_ONE_TO_ONE, hence the _no suffix).

Trait Implementations§

impl<T> AbsDiffEq for Mat4<T>
where T: AbsDiffEq, <T as AbsDiffEq>::Epsilon: Copy,

type Epsilon = <T as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> <T as AbsDiffEq>::Epsilon

The default tolerance to use when testing values that are close together. Read more

fn abs_diff_eq( &self, other: &Mat4<T>, epsilon: <Mat4<T> as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of [AbsDiffEq::abs_diff_eq].

impl<T> Add<T> for Mat4<T>
where T: Copy + Add<Output = T>,

type Output = Mat4<T>

The resulting type after applying the + operator.

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

Performs the + operation. Read more

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, rhs: Mat4<T>) -> <Mat4<T> as Add>::Output

Performs the + operation. Read more

impl<T> AddAssign<T> for Mat4<T>
where T: Add<Output = T> + Copy,

fn add_assign(&mut self, rhs: T)

Performs the += operation. Read more

impl<T> AddAssign for Mat4<T>
where T: Add<Output = T> + Copy,

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

Performs the += operation. Read more

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

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

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

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

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

Formats the value using the given formatter. Read more

impl<T> Default for Mat4<T>
where T: Zero + One,

The default value for a square matrix is the identity.

assert_eq!(Mat4::<f32>::default(), Mat4::<f32>::identity());

fn default() -> Mat4<T>

Returns the “default value” for a type. Read more

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. Read more

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

Displays this matrix using the following format:

(i being the number of rows and j the number of columns)

( m00 ... m0j
  ... ... ...
  mi0 ... mij )

Note that elements are not comma-separated. This format doesn’t depend on the matrix’s storage layout.

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

Formats the value using the given formatter. Read more

impl<T> Div<T> for Mat4<T>
where T: Copy + Div<Output = T>,

type Output = Mat4<T>

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl<T> Div for Mat4<T>
where T: Div<Output = T>,

type Output = Mat4<T>

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl<T> DivAssign<T> for Mat4<T>
where T: Div<Output = T> + Copy,

fn div_assign(&mut self, rhs: T)

Performs the /= operation. Read more

impl<T> DivAssign for Mat4<T>
where T: Div<Output = T> + Copy,

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

Performs the /= operation. Read more

impl<T> From<ColumnMatrix4<T>> for Mat4<T>

fn from(m: ColumnMatrix4<T>) -> Mat4<T>

Converts to this type from the input type.

impl<T> From<Mat2<T>> for Mat4<T>
where T: Zero + One,

fn from(m: Mat2<T>) -> Mat4<T>

Converts to this type from the input type.

impl<T> From<Mat3<T>> for Mat4<T>
where T: Zero + One,

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

Converts to this type from the input type.

impl<T> From<Mat4<T>> for Mat4<T>

fn from(m: Mat4<T>) -> Mat4<T>

Converts to this type from the input type.

impl<T> From<Quaternion<T>> for Mat4<T>
where T: One<Output = T> + Mul + Add<Output = T> + Copy + Sub<Output = T> + Zero,

Rotation matrices can be obtained from quaternions. This implementation only works properly if the quaternion is normalized.

use std::f32::consts::PI;

let angles = 32;
for i in 0..angles {
    let theta = PI * 2. * (i as f32) / (angles as f32);

    assert_relative_eq!(Mat4::rotation_x(theta), Mat4::from(Quaternion::rotation_x(theta)), epsilon = 0.000001);
    assert_relative_eq!(Mat4::rotation_y(theta), Mat4::from(Quaternion::rotation_y(theta)), epsilon = 0.000001);
    assert_relative_eq!(Mat4::rotation_z(theta), Mat4::from(Quaternion::rotation_z(theta)), epsilon = 0.000001);

    assert_relative_eq!(Mat4::rotation_x(theta), Mat4::rotation_3d(theta, Vec4::unit_x()));
    assert_relative_eq!(Mat4::rotation_y(theta), Mat4::rotation_3d(theta, Vec4::unit_y()));
    assert_relative_eq!(Mat4::rotation_z(theta), Mat4::rotation_3d(theta, Vec4::unit_z()));

    // See what rotating unit vectors do for most angles between 0 and 2*PI.
    // It's helpful to picture this as a right-handed coordinate system.

    let v = Vec4::unit_y();
    let m = Mat4::rotation_x(theta);
    assert_relative_eq!(m * v, Vec4::new(0., theta.cos(), theta.sin(), 0.));

    let v = Vec4::unit_z();
    let m = Mat4::rotation_y(theta);
    assert_relative_eq!(m * v, Vec4::new(theta.sin(), 0., theta.cos(), 0.));

    let v = Vec4::unit_x();
    let m = Mat4::rotation_z(theta);
    assert_relative_eq!(m * v, Vec4::new(theta.cos(), theta.sin(), 0., 0.));
}

fn from(q: Quaternion<T>) -> Mat4<T>

Converts to this type from the input type.

impl<T> From<RowMatrix4<T>> for Mat4<T>

fn from(m: RowMatrix4<T>) -> Mat4<T>

Converts to this type from the input type.

impl<T> From<Transform<T, T, T>> for Mat4<T>
where T: Real + MulAdd<Output = T>,

A Mat4 can be obtained from a Transform, by rotating, then scaling, then translating.

fn from(xform: Transform<T, T, T>) -> Mat4<T>

Converts to this type from the input type.

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

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

Feeds this value into the given Hasher. Read more

1.3.0 · source§

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

Feeds a slice of this type into the given Hasher. Read more

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

Index this matrix in a layout-agnostic way with an (i, j) (row index, column index) tuple.

Matrices cannot be indexed by Vec2s because that would be likely to cause confusion: should x be the row index (because it’s the first element) or the column index (because it’s a horizontal position) ?

type Output = T

The returned type after indexing.

fn index( &self, t: (usize, usize), ) -> &<Mat4<T> as Index<(usize, usize)>>::Output

Performs the indexing (container[index]) operation. Read more

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

fn index_mut( &mut self, t: (usize, usize), ) -> &mut <Mat4<T> as Index<(usize, usize)>>::Output

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

impl<T> Into<ColumnMatrix4<T>> for Mat4<T>

fn into(self) -> ColumnMatrix4<T>

Converts this type into the (usually inferred) input type.

impl<T> Into<RowMatrix4<T>> for Mat4<T>

fn into(self) -> RowMatrix4<T>

Converts this type into the (usually inferred) input type.

impl<T> Mul<CubicBezier3<T>> for Mat4<T>
where T: Real + MulAdd<Output = T>,

type Output = CubicBezier3<T>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T> Mul<Mat4<T>> for Mat4<T>
where T: Mul<Output = T> + MulAdd<Output = T> + Copy,

Multiplies a column-major matrix with a row-major matrix.

use vek::mat::row_major::Mat4 as Rows4;
use vek::mat::column_major::Mat4 as Cols4;

let m = Cols4::<u32>::new(
    0, 1, 2, 3,
    4, 5, 6, 7,
    8, 9, 0, 1,
    2, 3, 4, 5
);
let b = Rows4::from(m);
let r = Rows4::<u32>::new(
    26, 32, 18, 24,
    82, 104, 66, 88,
    38, 56, 74, 92,
    54, 68, 42, 56
);
assert_eq!(m * b, r);
assert_eq!(m * Rows4::<u32>::identity(), m.into());
assert_eq!(Cols4::<u32>::identity() * b, m.into());

type Output = Mat4<T>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T> Mul<Mat4<T>> for Vec4<T>
where T: Mul<Output = T> + MulAdd<Output = T> + Copy,

Multiplies a row vector with a column-major matrix, giving a row vector.

use vek::mat::column_major::Mat4;
use vek::vec::Vec4;

let m = Mat4::new(
    0, 1, 2, 3,
    4, 5, 6, 7,
    8, 9, 0, 1,
    2, 3, 4, 5
);
let v = Vec4::new(0, 1, 2, 3);
let r = Vec4::new(26, 32, 18, 24);
assert_eq!(v * m, r);

type Output = Vec4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Mat4<T>) -> <Vec4<T> as Mul<Mat4<T>>>::Output

Performs the * operation. Read more

impl<T> Mul<QuadraticBezier3<T>> for Mat4<T>
where T: Real + MulAdd<Output = T>,

type Output = QuadraticBezier3<T>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T> Mul<T> for Mat4<T>
where T: Zero<Output = T> + Add + Mul<Output = T> + Copy,

type Output = Mat4<T>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T> Mul<Vec4<T>> for Mat4<T>
where T: Mul<Output = T> + MulAdd<Output = T> + Copy,

Multiplies a column-major matrix with a column vector, giving a column vector.

With SIMD vectors, this is the most efficient way.

use vek::mat::column_major::Mat4;
use vek::vec::Vec4;

let m = Mat4::new(
    0, 1, 2, 3,
    4, 5, 6, 7,
    8, 9, 0, 1,
    2, 3, 4, 5
);
let v = Vec4::new(0, 1, 2, 3);
let r = Vec4::new(14, 38, 12, 26);
assert_eq!(m * v, r);

type Output = Vec4<T>

The resulting type after applying the * operator.

fn mul(self, v: Vec4<T>) -> <Mat4<T> as Mul<Vec4<T>>>::Output

Performs the * operation. Read more

impl<T> Mul for Mat4<T>
where T: Mul<Output = T> + MulAdd<Output = T> + Copy,

Multiplies a column-major matrix with another.

use vek::mat::column_major::Mat4;

let m = Mat4::<u32>::new(
    0, 1, 2, 3,
    4, 5, 6, 7,
    8, 9, 0, 1,
    2, 3, 4, 5
);
let r = Mat4::<u32>::new(
    26, 32, 18, 24,
    82, 104, 66, 88,
    38, 56, 74, 92,
    54, 68, 42, 56
);
assert_eq!(m * m, r);
assert_eq!(m, m * Mat4::<u32>::identity());
assert_eq!(m, Mat4::<u32>::identity() * m);

type Output = Mat4<T>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl<T> MulAssign<T> for Mat4<T>
where T: Zero<Output = T> + Add + Mul<Output = T> + Copy,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation. Read more

impl<T> MulAssign for Mat4<T>
where T: Add<Output = T> + Mul<Output = T> + Copy + MulAdd<Output = T> + Zero,

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

Performs the *= operation. Read more

impl<T> Neg for Mat4<T>
where T: Neg<Output = T>,

type Output = Mat4<T>

The resulting type after applying the - operator.

fn neg(self) -> <Mat4<T> as Neg>::Output

Performs the unary - operation. Read more

impl<T> One for Mat4<T>
where T: Zero + One + Copy + MulAdd<Output = T>,

fn one() -> Mat4<T>

Returns the multiplicative identity element of Self, 1. Read more

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

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

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

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

1.0.0 · source§

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

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

impl<T> RelativeEq for Mat4<T>
where T: RelativeEq, <T as AbsDiffEq>::Epsilon: Copy,

fn default_max_relative() -> <T as AbsDiffEq>::Epsilon

The default relative tolerance for testing values that are far-apart. Read more

fn relative_eq( &self, other: &Mat4<T>, epsilon: <T as AbsDiffEq>::Epsilon, max_relative: <T as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of [RelativeEq::relative_eq].

impl<T> Rem<T> for Mat4<T>
where T: Copy + Rem<Output = T>,

type Output = Mat4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> <Mat4<T> as Rem<T>>::Output

Performs the % operation. Read more

impl<T> Rem for Mat4<T>
where T: Rem<Output = T>,

type Output = Mat4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Mat4<T>) -> <Mat4<T> as Rem>::Output

Performs the % operation. Read more

impl<T> RemAssign<T> for Mat4<T>
where T: Rem<Output = T> + Copy,

fn rem_assign(&mut self, rhs: T)

Performs the %= operation. Read more

impl<T> RemAssign for Mat4<T>
where T: Rem<Output = T> + Copy,

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

Performs the %= operation. Read more

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. Read more

impl<T> Sub<T> for Mat4<T>
where T: Copy + Sub<Output = T>,

type Output = Mat4<T>

The resulting type after applying the - operator.

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

Performs the - operation. Read more

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, rhs: Mat4<T>) -> <Mat4<T> as Sub>::Output

Performs the - operation. Read more

impl<T> SubAssign<T> for Mat4<T>
where T: Sub<Output = T> + Copy,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation. Read more

impl<T> SubAssign for Mat4<T>
where T: Sub<Output = T> + Copy,

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

Performs the -= operation. Read more

impl<T> UlpsEq for Mat4<T>
where T: UlpsEq, <T as AbsDiffEq>::Epsilon: Copy,

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart. Read more

fn ulps_eq( &self, other: &Mat4<T>, epsilon: <T as AbsDiffEq>::Epsilon, max_ulps: u32, ) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of [UlpsEq::ulps_eq].

impl<T> Zero for Mat4<T>
where T: Zero + PartialEq,

fn zero() -> Mat4<T>

Returns the additive identity element of Self, 0. Read more

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

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

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

impl<T> StructuralPartialEq for Mat4<T>

Auto Trait Implementations§

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

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> CallHasher for T
where T: Hash,

fn get_hash<H>(&self, hasher: H) -> u64
where H: Hasher,

impl<T> CloneToUninit for T
where T: Clone,

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dst. Read more

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

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dst. Read more

impl<C, M> ConvertSaveload<M> for C
where C: Clone + Serialize + DeserializeOwned,

type Data = C

(De)Serializable data representation for data type

type Error = Infallible

Error may occur during serialization or deserialization of component

fn convert_into<F>( &self, _: F, ) -> Result<<C as ConvertSaveload<M>>::Data, <C as ConvertSaveload<M>>::Error>
where F: FnMut(Entity) -> Option<M>,

Convert this data type into serializable form (Data) using entity to marker mapping function

fn convert_from<F>( data: <C as ConvertSaveload<M>>::Data, _: F, ) -> Result<C, <C as ConvertSaveload<M>>::Error>
where F: FnMut(M) -> Option<Entity>,

Convert this data from a deserializable form (Data) using entity to marker mapping function

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> GetSetFdFlags for T

fn get_fd_flags(&self) -> Result<FdFlags, Error>
where T: AsFilelike,

Query the “status” flags for the self file descriptor.

fn new_set_fd_flags(&self, fd_flags: FdFlags) -> Result<SetFdFlags<T>, Error>
where T: AsFilelike,

Create a new SetFdFlags value for use with set_fd_flags. Read more

fn set_fd_flags(&mut self, set_fd_flags: SetFdFlags<T>) -> Result<(), Error>
where T: AsFilelike,

Set the “status” flags for the self file descriptor. Read more

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

impl<T> Pointable for T

const ALIGN: usize = _

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> Pointee for T

type Pointer = u32

fn debug( pointer: <T as Pointee>::Pointer, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl<T> Same for T

type Output = T

Should always be Self

impl<Context> SubContext<Context> for Context

fn sub_context(self) -> Context

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T> ToString for T
where T: Display + ?Sized,

default fn to_string(&self) -> String

Converts the given value to a String. Read more

impl<T> TryDefault for T
where T: Default,

fn try_default() -> Result<T, String>

Tries to create the default.

fn unwrap_default() -> Self

Calls try_default and panics on an error case.

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more

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

impl<T> Event for T
where T: Send + Sync + 'static,

impl<T, Rhs> NumAssignOps<Rhs> for T
where T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,

impl<T, Rhs, Output> NumOps<Rhs, Output> for T
where T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,

impl<T> Resource for T
where T: Any + Send + Sync,