# shz::mat4x4

Source: https://sh4zam.com/api/cpp/mat4x4/

> C++ class shz::mat4x4

C++ type `shz::mat4x4`.

- **Header:** `#include <sh4zam/shz_matrix.hpp>` ([source](https://github.com/gyrovorbis/sh4zam/blob/ba1e30c88d49df0311870b229e1dd860ef26c477/include/sh4zam/shz_matrix.hpp#L27))
- **C type:** [`shz_mat4x4_t`](https://sh4zam.com/api/matrix/shz_mat4x4_t/) (layout-compatible; the C API accepts it directly)
- **Bases:** `shz_mat4x4_t`

## Static functions

### copy

```cpp
static void copy(shz_mat4x4_t *lhs, const shz_mat4x4_t &rhs) noexcept
static void copy(shz_mat4x4_t *lhs, const float rhs[16]) noexcept
```

Calls: [`shz_mat4x4_copy()`](https://sh4zam.com/api/matrix/shz_mat4x4_copy/), [`shz_mat4x4_copy_unaligned()`](https://sh4zam.com/api/matrix/shz_mat4x4_copy_unaligned/)

### mult

```cpp
static void mult(shz_mat4x4_t *dst, const shz_mat4x4_t &lhs, const shz_mat4x4_t &rhs) noexcept
static void mult(shz_mat4x4_t *dst, const shz_mat4x4_t &lhs, const float rhs[16]) noexcept
```

Calls: [`shz_mat4x4_mult()`](https://sh4zam.com/api/matrix/shz_mat4x4_mult/), [`shz_mat4x4_mult_unaligned()`](https://sh4zam.com/api/matrix/shz_mat4x4_mult_unaligned/)

### mult_transpose

```cpp
static void mult_transpose(shz_mat4x4_t *dst, const shz_mat4x4_t &lhs, const shz_mat4x4_t &rhs) noexcept
static void mult_transpose(shz_mat4x4_t *dst, const shz_mat4x4_t &lhs, const float rhs[16]) noexcept
```

Calls: [`shz_mat4x4_mult_transpose()`](https://sh4zam.com/api/matrix/shz_mat4x4_mult_transpose/), [`shz_mat4x4_mult_transpose_unaligned()`](https://sh4zam.com/api/matrix/shz_mat4x4_mult_transpose_unaligned/)

## Members

### init_identity

```cpp
void init_identity() noexcept
```

Calls: [`shz_mat4x4_init_identity()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_identity/)

### init_identity_safe

```cpp
void init_identity_safe() noexcept
```

Calls: [`shz_mat4x4_init_identity()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_identity/)

### init_zero

```cpp
void init_zero() noexcept
```

Calls: [`shz_mat4x4_init_zero()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_zero/)

### init_one

```cpp
void init_one() noexcept
```

Calls: [`shz_mat4x4_init_one()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_one/)

### init_fill

```cpp
void init_fill(float value) noexcept
```

Calls: [`shz_mat4x4_init_fill()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_fill/)

### init_translation

```cpp
void init_translation(float x, float y, float z) noexcept
void init_translation(const vec3 &v) noexcept
```

Calls: [`shz_mat4x4_init_translation()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_translation/)

### init_scale

```cpp
void init_scale(float x, float y, float z) noexcept
void init_scale(const vec3 &v) noexcept
```

Calls: [`shz_mat4x4_init_scale()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_scale/)

### init_rotation_x

```cpp
void init_rotation_x(float angle) noexcept
```

Calls: [`shz_mat4x4_init_rotation_x()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_rotation_x/)

### init_rotation_y

```cpp
void init_rotation_y(float angle) noexcept
```

Calls: [`shz_mat4x4_init_rotation_y()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_rotation_y/)

### init_rotation_z

```cpp
void init_rotation_z(float angle) noexcept
```

Calls: [`shz_mat4x4_init_rotation_z()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_rotation_z/)

### init_rotation_xyz

```cpp
void init_rotation_xyz(float xAngle, float yAngle, float zAngle) noexcept
```

Calls: [`shz_mat4x4_init_rotation_xyz()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_rotation_xyz/)

### init_rotation_zyx

```cpp
void init_rotation_zyx(float zAngle, float yAngle, float xAngle) noexcept
```

Calls: [`shz_mat4x4_init_rotation_zyx()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_rotation_zyx/)

### init_rotation_zxy

```cpp
void init_rotation_zxy(float zAngle, float xAngle, float yAngle) noexcept
```

Calls: [`shz_mat4x4_init_rotation_zxy()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_rotation_zxy/)

### init_rotation_yxz

```cpp
void init_rotation_yxz(float yAngle, float xAngle, float zAngle) noexcept
```

Calls: [`shz_mat4x4_init_rotation_yxz()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_rotation_yxz/)

### init_rotation

```cpp
void init_rotation(float angle, float x, float y, float z) noexcept
void init_rotation(float angle, const vec3 &axis) noexcept
void init_rotation(const quat &q) noexcept
```

Calls: [`shz_mat4x4_init_rotation()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_rotation/), [`shz_mat4x4_init_rotation_quat()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_rotation_quat/)

### init_rotation_dir

```cpp
void init_rotation_dir(float angle, float x, float y, float z) noexcept
void init_rotation_dir(float angle, const vec3 &dir) noexcept
```

Calls: [`shz_mat4x4_init_rotation_dir()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_rotation_dir/)

### init_diagonal

```cpp
void init_diagonal(float x, float y, float z, float w) noexcept
void init_diagonal(const vec4 &v) noexcept
```

Calls: [`shz_mat4x4_init_diagonal()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_diagonal/)

### init_upper_triangular

```cpp
void init_upper_triangular(float col1, const vec2 &col2, const vec3 &col3, const vec4 &col4) noexcept
```

Calls: [`shz_mat4x4_init_upper_triangular()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_upper_triangular/)

### init_lower_triangular

```cpp
void init_lower_triangular(const vec4 &col1, const vec3 &col2, const vec2 &col3, float col4) noexcept
```

Calls: [`shz_mat4x4_init_lower_triangular()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_lower_triangular/)

### init_symmetric_skew

```cpp
void init_symmetric_skew(float x, float y, float z) noexcept
void init_symmetric_skew(const vec3 &v) noexcept
```

Calls: [`shz_mat4x4_init_symmetric_skew()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_symmetric_skew/)

### init_outer_product

```cpp
void init_outer_product(const vec4 &v1, const vec4 &v2) noexcept
```

Calls: [`shz_mat4x4_init_outer_product()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_outer_product/)

### init_permutation_wxyz

```cpp
void init_permutation_wxyz() noexcept
```

Calls: [`shz_mat4x4_init_permutation_wxyz()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_permutation_wxyz/)

### init_permutation_yzwx

```cpp
void init_permutation_yzwx() noexcept
```

Calls: [`shz_mat4x4_init_permutation_yzwx()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_permutation_yzwx/)

### init_screen

```cpp
void init_screen(float width, float height) noexcept
```

Calls: [`shz_mat4x4_init_screen()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_screen/)

### init_lookat

```cpp
void init_lookat(const vec3 &eye, const vec3 &center, const vec3 &up) noexcept
```

Calls: [`shz_mat4x4_init_lookat()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_lookat/)

### init_ortho

```cpp
void init_ortho(float left, float right, float bottom, float top, float znear, float zfar) noexcept
```

Calls: [`shz_mat4x4_init_ortho()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_ortho/)

### init_frustum

```cpp
void init_frustum(float left, float right, float bottom, float top, float znear, float zfar) noexcept
```

Calls: [`shz_mat4x4_init_frustum()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_frustum/)

### init_perspective

```cpp
void init_perspective(float fov, float aspect, float znear) noexcept
```

Calls: [`shz_mat4x4_init_perspective()`](https://sh4zam.com/api/matrix/shz_mat4x4_init_perspective/)

### row

```cpp
vec4 row(size_t index) const noexcept
```

C++ wrapper for `shz_mat4x4_row()`.

Calls: [`shz_mat4x4_row()`](https://sh4zam.com/api/matrix/shz_mat4x4_row/)

### col

```cpp
vec4 col(size_t index) const noexcept
```

C++ wrapper for `shz_mat4x4_col()`.

Calls: [`shz_mat4x4_col()`](https://sh4zam.com/api/matrix/shz_mat4x4_col/)

### get_translation

```cpp
vec3 get_translation() const noexcept
```

Calls: [`shz_mat4x4_get_translation()`](https://sh4zam.com/api/matrix/shz_mat4x4_get_translation/)

### get_scale

```cpp
vec3 get_scale() const noexcept
```

Returns the scaling components from the inner 3x3 matrix of XMTRX, as a 3D vector.

Calls: [`shz_mat4x4_get_scale()`](https://sh4zam.com/api/matrix/shz_mat4x4_get_scale/)

### set_row

```cpp
void set_row(size_t index, vec4 values) noexcept
```

Calls: [`shz_mat4x4_set_row()`](https://sh4zam.com/api/matrix/shz_mat4x4_set_row/)

### set_col

```cpp
void set_col(size_t index, vec4 values) noexcept
```

Calls: [`shz_mat4x4_set_col()`](https://sh4zam.com/api/matrix/shz_mat4x4_set_col/)

### swap_rows

```cpp
void swap_rows(size_t row1, size_t row2) noexcept
```

Calls: [`shz_mat4x4_swap_rows()`](https://sh4zam.com/api/matrix/shz_mat4x4_swap_rows/)

### swap_cols

```cpp
void swap_cols(size_t col1, size_t col2) noexcept
```

Calls: [`shz_mat4x4_swap_cols()`](https://sh4zam.com/api/matrix/shz_mat4x4_swap_cols/)

### set_translation

```cpp
void set_translation(float x, float y, float z) noexcept
void set_translation(const vec3 &v) noexcept
```

Calls: [`shz_mat4x4_set_translation()`](https://sh4zam.com/api/matrix/shz_mat4x4_set_translation/)

### set_scale

```cpp
void set_scale(float x, float y, float z) noexcept
void set_scale(const vec3 &v) noexcept
```

Calls: [`shz_mat4x4_set_scale()`](https://sh4zam.com/api/matrix/shz_mat4x4_set_scale/)

### set_rotation

```cpp
void set_rotation(const quat &rot) noexcept
```

Calls: [`shz_mat4x4_set_rotation_quat()`](https://sh4zam.com/api/matrix/shz_mat4x4_set_rotation_quat/)

### set_diagonal

```cpp
void set_diagonal(float x, float y, float z, float w) noexcept
void set_diagonal(const vec4 &v) noexcept
```

Calls: [`shz_mat4x4_set_diagonal()`](https://sh4zam.com/api/matrix/shz_mat4x4_set_diagonal/)

### apply

```cpp
void apply(const shz_mat4x4_t &mat) noexcept
void apply(const float mat[16]) noexcept
```

Calls: [`shz_mat4x4_apply()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply/), [`shz_mat4x4_apply_unaligned()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_unaligned/)

### apply_transpose

```cpp
void apply_transpose(const shz_mat4x4_t &mat) noexcept
void apply_transpose(const float mat[16]) noexcept
```

Calls: [`shz_mat4x4_apply_transpose()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_transpose/), [`shz_mat4x4_apply_transpose_unaligned()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_transpose_unaligned/)

### apply_scale

```cpp
void apply_scale(float x, float y, float z) noexcept
void apply_scale(const vec3 &v) noexcept
```

Calls: [`shz_mat4x4_apply_scale()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_scale/)

### apply_translation

```cpp
void apply_translation(float x, float y, float z) noexcept
void apply_translation(const vec3 &v) noexcept
```

Calls: [`shz_mat4x4_apply_translation()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_translation/)

### apply_rotation_x

```cpp
void apply_rotation_x(float angle) noexcept
```

Calls: [`shz_mat4x4_apply_rotation_x()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_rotation_x/)

### apply_rotation_y

```cpp
void apply_rotation_y(float angle) noexcept
```

Calls: [`shz_mat4x4_apply_rotation_y()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_rotation_y/)

### apply_rotation_z

```cpp
void apply_rotation_z(float angle) noexcept
```

Calls: [`shz_mat4x4_apply_rotation_z()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_rotation_z/)

### apply_rotation_xyz

```cpp
void apply_rotation_xyz(float xAngle, float yAngle, float zAngle) noexcept
```

Calls: [`shz_mat4x4_apply_rotation_xyz()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_rotation_xyz/)

### apply_rotation_zyx

```cpp
void apply_rotation_zyx(float zAngle, float yAngle, float xAngle) noexcept
```

Calls: [`shz_mat4x4_apply_rotation_zyx()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_rotation_zyx/)

### apply_rotation_zxy

```cpp
void apply_rotation_zxy(float zAngle, float xAngle, float yAngle) noexcept
```

Calls: [`shz_mat4x4_apply_rotation_zxy()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_rotation_zxy/)

### apply_rotation_yxz

```cpp
void apply_rotation_yxz(float yAngle, float xAngle, float zAngle) noexcept
```

Calls: [`shz_mat4x4_apply_rotation_yxz()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_rotation_yxz/)

### apply_rotation

```cpp
void apply_rotation(float angle, float x, float y, float z) noexcept
void apply_rotation(float angle, vec3 axis) noexcept
void apply_rotation(const quat &q) noexcept
```

Calls: [`shz_mat4x4_apply_rotation()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_rotation/), [`shz_mat4x4_apply_rotation_quat()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_rotation_quat/)

### apply_lookat

```cpp
void apply_lookat(vec3 pos, vec3 target, vec3 up) noexcept
```

Calls: [`shz_mat4x4_apply_lookat()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_lookat/)

### apply_ortho

```cpp
void apply_ortho(float left, float right, float bottom, float top, float znear, float zfar) noexcept
```

Calls: [`shz_mat4x4_apply_ortho()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_ortho/)

### apply_frustum

```cpp
void apply_frustum(float left, float right, float bottom, float top, float znear, float zfar) noexcept
```

Calls: [`shz_mat4x4_apply_frustum()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_frustum/)

### apply_perspective

```cpp
void apply_perspective(float fov, float aspect, float znear) noexcept
```

Calls: [`shz_mat4x4_apply_perspective()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_perspective/)

### apply_screen

```cpp
void apply_screen(float width, float height) noexcept
```

Calls: [`shz_mat4x4_apply_screen()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_screen/)

### apply_symmetric_skew

```cpp
void apply_symmetric_skew(float x, float y, float z) noexcept
```

Calls: [`shz_mat4x4_apply_symmetric_skew()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_symmetric_skew/)

### apply_permutation_wxyz

```cpp
void apply_permutation_wxyz() noexcept
```

Calls: [`shz_mat4x4_apply_permutation_wxyz()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_permutation_wxyz/)

### apply_permutation_yzwx

```cpp
void apply_permutation_yzwx() noexcept
```

Calls: [`shz_mat4x4_apply_permutation_yzwx()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_permutation_yzwx/)

### apply_self

```cpp
void apply_self() noexcept
```

Calls: [`shz_mat4x4_apply_self()`](https://sh4zam.com/api/matrix/shz_mat4x4_apply_self/)

### translate

```cpp
void translate(float x, float y, float z) noexcept
void translate(vec3 v) noexcept
```

Calls: [`shz_mat4x4_translate()`](https://sh4zam.com/api/matrix/shz_mat4x4_translate/)

### scale

```cpp
void scale(float x, float y, float z) noexcept
void scale(vec3 v) noexcept
```

Calls: [`shz_mat4x4_scale()`](https://sh4zam.com/api/matrix/shz_mat4x4_scale/)

### rotate_x

```cpp
void rotate_x(float radians) noexcept
```

Calls: [`shz_mat4x4_rotate_x()`](https://sh4zam.com/api/matrix/shz_mat4x4_rotate_x/)

### rotate_y

```cpp
void rotate_y(float radians) noexcept
```

Calls: [`shz_mat4x4_rotate_y()`](https://sh4zam.com/api/matrix/shz_mat4x4_rotate_y/)

### rotate_z

```cpp
void rotate_z(float radians) noexcept
```

Calls: [`shz_mat4x4_rotate_z()`](https://sh4zam.com/api/matrix/shz_mat4x4_rotate_z/)

### rotate_xyz

```cpp
void rotate_xyz(float xRadians, float yRadians, float zRadians) noexcept
```

Calls: [`shz_mat4x4_rotate_xyz()`](https://sh4zam.com/api/matrix/shz_mat4x4_rotate_xyz/)

### rotate_zyx

```cpp
void rotate_zyx(float zRadians, float yRadians, float xRadians) noexcept
```

Calls: [`shz_mat4x4_rotate_zyx()`](https://sh4zam.com/api/matrix/shz_mat4x4_rotate_zyx/)

### rotate_zxy

```cpp
void rotate_zxy(float zRadians, float xRadians, float yRadians) noexcept
```

Calls: [`shz_mat4x4_rotate_zxy()`](https://sh4zam.com/api/matrix/shz_mat4x4_rotate_zxy/)

### rotate_yxz

```cpp
void rotate_yxz(float yRadians, float xRadians, float zRadians) noexcept
```

Calls: [`shz_mat4x4_rotate_yxz()`](https://sh4zam.com/api/matrix/shz_mat4x4_rotate_yxz/)

### rotate

```cpp
void rotate(float radians, float xAxis, float yAxis, float zAxis) noexcept
void rotate(float radians, vec3 axis) noexcept
```

Calls: [`shz_mat4x4_rotate()`](https://sh4zam.com/api/matrix/shz_mat4x4_rotate/)

### translate_reverse

```cpp
void translate_reverse(float x, float y, float z) noexcept
void translate_reverse(const shz::vec3 &pos) noexcept
```

Pre-multiplies and accumulates the given matrix onto the 3D translation matrix with the given components.

Calls: [`shz_mat4x4_translate_reverse()`](https://sh4zam.com/api/matrix/shz_mat4x4_translate_reverse/)

### scale_reverse

```cpp
void scale_reverse(float x, float y, float z) noexcept
void scale_reverse(const shz::vec3 &size) noexcept
```

Pre-multiplies and accumulates the given matrix onto the 3D scaling matrix with the given components.

Calls: [`shz_mat4x4_scale_reverse()`](https://sh4zam.com/api/matrix/shz_mat4x4_scale_reverse/)

### transform

```cpp
vec2 transform(const vec2 &in) const noexcept
vec3 transform(const vec3 &in) const noexcept
vec4 transform(const vec4 &in) const noexcept
```

Calls: [`shz_mat4x4_transform_vec2()`](https://sh4zam.com/api/matrix/shz_mat4x4_transform_vec2/), [`shz_mat4x4_transform_vec3()`](https://sh4zam.com/api/matrix/shz_mat4x4_transform_vec3/), [`shz_mat4x4_transform_vec4()`](https://sh4zam.com/api/matrix/shz_mat4x4_transform_vec4/)

### transform_point

```cpp
vec2 transform_point(const vec2 &pt) const noexcept
vec3 transform_point(const vec3 &pt) const noexcept
```

Calls: [`shz_mat4x4_transform_point2()`](https://sh4zam.com/api/matrix/shz_mat4x4_transform_point2/), [`shz_mat4x4_transform_point3()`](https://sh4zam.com/api/matrix/shz_mat4x4_transform_point3/)

### transform_transpose

```cpp
vec2 transform_transpose(const vec2 &in) const noexcept
vec3 transform_transpose(const vec3 &in) const noexcept
vec4 transform_transpose(const vec4 &in) const noexcept
```

Calls: [`shz_mat4x4_transform_vec2_transpose()`](https://sh4zam.com/api/matrix/shz_mat4x4_transform_vec2_transpose/), [`shz_mat4x4_transform_vec3_transpose()`](https://sh4zam.com/api/matrix/shz_mat4x4_transform_vec3_transpose/), [`shz_mat4x4_transform_vec4_transpose()`](https://sh4zam.com/api/matrix/shz_mat4x4_transform_vec4_transpose/)

### transform_point_transpose

```cpp
vec2 transform_point_transpose(const vec2 &pt) const noexcept
vec3 transform_point_transpose(const vec3 &pt) const noexcept
```

Calls: [`shz_mat4x4_transform_point2_transpose()`](https://sh4zam.com/api/matrix/shz_mat4x4_transform_point2_transpose/), [`shz_mat4x4_transform_point3_transpose()`](https://sh4zam.com/api/matrix/shz_mat4x4_transform_point3_transpose/)

### to_quat

```cpp
quat to_quat() const noexcept
```

Calls: [`shz_mat4x4_to_quat()`](https://sh4zam.com/api/matrix/shz_mat4x4_to_quat/)

### determinant

```cpp
float determinant() const noexcept
```

Calls: [`shz_mat4x4_determinant()`](https://sh4zam.com/api/matrix/shz_mat4x4_determinant/)

### trace

```cpp
float trace() const noexcept
```

Calls: [`shz_mat4x4_trace()`](https://sh4zam.com/api/matrix/shz_mat4x4_trace/)

### inverse

```cpp
void inverse(mat4x4 *out) const noexcept
```

Calls: [`shz_mat4x4_inverse()`](https://sh4zam.com/api/matrix/shz_mat4x4_inverse/)

### inverse_block_triangular

```cpp
void inverse_block_triangular(mat4x4 *out) const noexcept
```

Calls: [`shz_mat4x4_inverse_block_triangular()`](https://sh4zam.com/api/matrix/shz_mat4x4_inverse_block_triangular/)

### decompose

```cpp
void decompose(vec3 *translation, quat *rotation, vec3 *scale) const noexcept
```

Calls: [`shz_mat4x4_decompose()`](https://sh4zam.com/api/matrix/shz_mat4x4_decompose/)

### blend

```cpp
void blend(const shz_mat4x4_t &matrix, float weight) noexcept
```

Adds and accumulates a scaled 4x4 matrix into the given matrix.

Calls: [`shz_mat4x4_blend()`](https://sh4zam.com/api/matrix/shz_mat4x4_blend/)

### swap

```cpp
void swap(shz_mat4x4_t &matA, shz_mat4x4_t &matB) noexcept
```

### mat4x4

```cpp
mat4x4() noexcept=default
mat4x4(const mat4x4 &other) noexcept
mat4x4(const shz_mat4x4_t &other) noexcept
```

Calls: [`shz_mat4x4_copy()`](https://sh4zam.com/api/matrix/shz_mat4x4_copy/)

### operator=

```cpp
mat4x4 & operator=(const shz_mat4x4_t &other) noexcept
```

Calls: [`shz_mat4x4_copy()`](https://sh4zam.com/api/matrix/shz_mat4x4_copy/)

### operator==

```cpp
bool operator==(const mat4x4 &lhs, const mat4x4 &rhs) noexcept
```

Overloaded equality operator, for comparing vectors.