shz_xmtrx.hpp

Go to the documentation of this file.

/*! \file
 *  \brief   C++ Active Matrix API
 *  \ingroup xmtrx
 *
 *  This file provides an API built around manipulating and performing
 *  calculations using the SH4's "current" 4x4 matrix, which is held within
 *  a secondary back-bank of 16 single-precision floating-point registers.
 *
 *  \todo
 *      - shz_rotate_quat()
 *
 *  \author    2025, 2026 Falco Girgis
 *  \copyright MIT License
 */
 
#ifndef SHZ_XMTRX_HPP
#define SHZ_XMTRX_HPP
 
#include <array>
 
#include "shz_xmtrx.h"
#include "shz_vector.hpp"
#include "shz_quat.hpp"
 
namespace shz {
 
/*! Static structure around the 4x4 XMTRX FP register back-bank.
 
    This structure provides the C++ bindings to the XMTRX API as a series
    of static member functions wrapping the C API.
 
    \sa xmtrx
*/
struct xmtrx {
 
    //! FP back-bank registers comprising XMTRX.
    enum reg {
        XF0  = SHZ_XMTRX_XF0,   //!< FP register XF0
        XF1  = SHZ_XMTRX_XF1,   //!< FP register XF1
        XF2  = SHZ_XMTRX_XF2,   //!< FP register XF2
        XF3  = SHZ_XMTRX_XF3,   //!< FP register XF3
        XF4  = SHZ_XMTRX_XF4,   //!< FP register XF4
        XF5  = SHZ_XMTRX_XF5,   //!< FP register XF5
        XF6  = SHZ_XMTRX_XF6,   //!< FP register XF6
        XF7  = SHZ_XMTRX_XF7,   //!< FP register XF7
        XF8  = SHZ_XMTRX_XF8,   //!< FP register XF8
        XF9  = SHZ_XMTRX_XF9,   //!< FP register XF9
        XF10 = SHZ_XMTRX_XF10,  //!< FP register XF10
        XF11 = SHZ_XMTRX_XF11,  //!< FP register XF11
        XF12 = SHZ_XMTRX_XF12,  //!< FP register XF12
        XF13 = SHZ_XMTRX_XF13,  //!< FP register XF13
        XF14 = SHZ_XMTRX_XF14,  //!< FP register XF14
        XF15 = SHZ_XMTRX_XF15   //!< FP register XF15
    };
 
    //! Non-POSIX style reg_t alias.
    using reg_t = reg;
 
/*! \name  Accessors
    \brief Setting and retrieving individual XMTRX register values.
    @{
*/
 
    //! C++ wrapper around shz_xmtrx_read().
    SHZ_FORCE_INLINE static float read(reg xf) noexcept {
        return shz_xmtrx_read(static_cast<shz_xmtrx_reg>(xf));
    }
 
    //! C++ wrapper around shz_xmtrx_write().
    SHZ_FORCE_INLINE static void write(reg xf, float value) noexcept {
        shz_xmtrx_write(static_cast<shz_xmtrx_reg>(xf), value);
    }
 
    //! C++ wrapper around shz_xmtrx_read_row().
    SHZ_FORCE_INLINE static vec4 read_row(unsigned int index) noexcept {
        return shz_xmtrx_read_row(index);
    }
 
    //! C++ wrapper around shz_xmtrx_read_col().
    SHZ_FORCE_INLINE static vec4 read_col(unsigned int index) noexcept {
        return shz_xmtrx_read_col(index);
    }
 
    //! C++ wrapper around shz_xmtrx_write_row().
    SHZ_FORCE_INLINE static void write_row(unsigned int index, const vec4& vector) noexcept {
        shz_xmtrx_write_row(index, vector);
    }
 
    //! C++ wrapper around shz_xmtrx_write_col().
    SHZ_FORCE_INLINE static void write_col(unsigned int index, const vec4& vector) noexcept {
        shz_xmtrx_write_col(index, vector);
    }
 
    //! C++ wrapper around shz_xmtrx_swap_rows().
    SHZ_FORCE_INLINE static void swap_rows(unsigned int index1, unsigned int index2) noexcept {
        shz_xmtrx_swap_rows(index1, index2);
    }
 
    //! C++ wrapper around shz_xmtrx_swap_cols().
    SHZ_FORCE_INLINE static void swap_cols(unsigned int index1, unsigned int index2) noexcept {
        shz_xmtrx_swap_cols(index1, index2);
    }
 
//! @}
 
/*! \name  Loading
    \brief Routines for loading XMTRX contents from memory.
    @{
*/
 
    //! C++ wrapper around shz_xmtrx_load_4x4().
    SHZ_FORCE_INLINE static void load(const shz_mat4x4_t& mat4) noexcept {
        shz_xmtrx_load_4x4(&mat4);
    }
 
    //! C++ wrapper around shz_xmtrx_load_unaligned_4x4().
    SHZ_FORCE_INLINE static void load(const float cArray[16]) noexcept {
        shz_xmtrx_load_unaligned_4x4(cArray);
    }
 
    //! C++ wrapper around shz_xmtrx_load_unaligned_4x4().
    SHZ_FORCE_INLINE static void load(const std::array<float, 16>& array) noexcept {
        load(array.data());
    }
 
    //! C++ wrapper around shz_xmtrx_load_transpose_4x4().
    SHZ_FORCE_INLINE static void load_transpose(const shz_mat4x4_t& mat4) noexcept {
        shz_xmtrx_load_transpose_4x4(&mat4);
    }
 
    //! C++ wrapper around shz_xmtrx_load_transpose_unaligned_4x4().
    SHZ_FORCE_INLINE static void load_transpose(const float cArray[16]) noexcept {
        shz_xmtrx_load_transpose_unaligned_4x4(cArray);
    }
 
    //! C++ wrapper around shz_xmtrx_load_transpose_unaligned_4x4().
    SHZ_FORCE_INLINE static void load_transpose(const std::array<float, 16>& array) noexcept {
        load_transpose(array.data());
    }
 
    //! C++ wrapper around shz_xmtrx_load_wxyz_4x4().
    SHZ_FORCE_INLINE static void load_wxyz(const shz_mat4x4_t& mat4) noexcept {
        shz_xmtrx_load_wxyz_4x4(&mat4);
    }
 
    //! C++ wrapper around shz_xmtrx_load_cols_4x4().
    SHZ_FORCE_INLINE static void load_cols(const shz_vec4_t& c1,
                                           const shz_vec4_t& c2,
                                           const shz_vec4_t& c3,
                                           const shz_vec4_t& c4) noexcept {
        shz_xmtrx_load_cols_4x4(&c1, &c2, &c3, &c4);
    }
 
    //! C++ wrapper around shz_xmtrx_load_rows_4x4().
    SHZ_FORCE_INLINE static void load_rows(const shz_vec4_t& r1,
                                           const shz_vec4_t& r2,
                                           const shz_vec4_t& r3,
                                           const shz_vec4_t& r4) noexcept {
        shz_xmtrx_load_rows_4x4(&r1, &r2, &r3, &r4);
    }
 
    //! C++ wrapper around shz_xmtrx_load_3x4().
    SHZ_FORCE_INLINE static void load(const shz_mat3x4_t& mat) noexcept {
        shz_xmtrx_load_3x4(&mat);
    }
 
//! @}
 
/*! \name  Storing
    \brief Routines for saving XMTRX contents to memory.
    @{
*/
 
    //! C++ wrapper around shz_xmtrx_store_4x4().
    SHZ_FORCE_INLINE static void store(shz_mat4x4_t* mat) noexcept {
        shz_xmtrx_store_4x4(mat);
    }
 
    //! C++ wrapper around shz_xmtrx_store_unaligned_4x4().
    SHZ_FORCE_INLINE static void store(float cArray[16]) noexcept {
        shz_xmtrx_store_unaligned_4x4(cArray);
    }
 
    //! C++ wrapper around shz_xmtrx_store_unaligned_4x4().
    SHZ_FORCE_INLINE static void store(std::array<float, 16>* array) noexcept {
        shz_xmtrx_store_unaligned_4x4(array->data());
    }
 
    //! C++ wrapper around shz_xmtrx_store_transpose_4x4().
    SHZ_FORCE_INLINE static void store_transpose(shz_mat4x4_t* mat) noexcept {
        shz_xmtrx_store_transpose_4x4(mat);
    }
 
    //! C++ wrapper around shz_xmtrx_store_transpose_unaligned_4x4().
    SHZ_FORCE_INLINE static void store_transpose(float cArray[16]) noexcept {
        shz_xmtrx_store_transpose_unaligned_4x4(cArray);
    }
 
    //! C++ wrapper around shz_xmtrx_store_transpose_unaligned_4x4().
    SHZ_FORCE_INLINE static void store_transpose(std::array<float, 16>* array) noexcept {
        store_transpose(array->data());
    }
 
    //! C++ wrapper around shz_xmtrx_store_3x4().
    SHZ_FORCE_INLINE static void store(shz_mat3x4_t* mat) noexcept {
        shz_xmtrx_store_3x4(mat);
    }
 
//! @}
 
/*! \name  Initialization
    \brief Routines used to initialize the entirety of XMTRX.
    @{
*/
 
    //! C++ wrapper around shz_xmtrx_init_identity().
    SHZ_FORCE_INLINE static void init_identity() noexcept {
        shz_xmtrx_init_identity();
    }
 
    //! C++ wrapper around shz_xmtrx_init_identity_safe().
    SHZ_DEPRECATED("Operation is always safe now. Use default version.")
    SHZ_FORCE_INLINE static void init_identity_safe() noexcept {
        shz_xmtrx_init_identity();
    }
 
    //! C++ wrapper around shz_xmtrx_init_zero().
    SHZ_FORCE_INLINE static void init_zero() noexcept {
        shz_xmtrx_init_zero();
    }
 
    //! C++ wrapper around shz_xmtrx_init_one().
    SHZ_FORCE_INLINE static void init_one() noexcept {
        shz_xmtrx_init_one();
    }
 
    //! C++ wrapper around shz_xmtrx_init_fill().
    SHZ_FORCE_INLINE static void init_fill(float value) noexcept {
        shz_xmtrx_init_fill(value);
    }
 
    //! C++ wrapper around shz_xmtrx_init_translation().
    SHZ_FORCE_INLINE static void init_translation(float x, float y, float z) noexcept {
        shz_xmtrx_init_translation(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_init_translation().
    SHZ_FORCE_INLINE static void init_translation(const vec3& v) noexcept {
        init_translation(v.x, v.y, v.z);
    }
 
    //! C++ wrapper around shz_xmtrx_init_scale().
    SHZ_FORCE_INLINE static void init_scale(float x, float y, float z) noexcept {
        shz_xmtrx_init_scale(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_init_scale().
    SHZ_FORCE_INLINE static void init_scale(const vec3& v) noexcept {
        init_scale(v.x, v.y, v.z);
    }
 
    //! C++ wrapper around shz_xmtrx_init_rotation_x().
    SHZ_FORCE_INLINE static void init_rotation_x(float x) noexcept {
        shz_xmtrx_init_rotation_x(x);
    }
 
    //! C++ wrapper around shz_xmtrx_init_rotation_y().
    SHZ_FORCE_INLINE static void init_rotation_y(float y) noexcept {
        shz_xmtrx_init_rotation_y(y);
    }
 
    //! C++ wrapper around shz_xmtrx_init_rotation_z().
    SHZ_FORCE_INLINE static void init_rotation_z(float z) noexcept {
        shz_xmtrx_init_rotation_z(z);
    }
 
    //! C++ wrapper around shz_xmtrx_init_rotation_xyz().
    SHZ_FORCE_INLINE static void init_rotation_xyz(float x, float y, float z) noexcept {
        shz_xmtrx_init_rotation_xyz(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_init_rotation_zyx().
    SHZ_FORCE_INLINE static void init_rotation_zyx(float z, float y, float x) noexcept {
        shz_xmtrx_init_rotation_zyx(z, y, x);
    }
 
    //! C++ wrapper around shz_xmtrx_init_rotation_zxy().
    SHZ_FORCE_INLINE static void init_rotation_zxy(float z, float x, float y) noexcept {
        shz_xmtrx_init_rotation_zxy(z, x, y);
    }
 
    //! C++ wrapper around shz_xmtrx_init_rotation_yxz().
    SHZ_FORCE_INLINE static void init_rotation_yxz(float y, float x, float z) noexcept {
        shz_xmtrx_init_rotation_yxz(y, x, z);
    }
 
    //! C++ wrapper around shz_xmtrx_init_rotation().
    SHZ_FORCE_INLINE static void init_rotation(float angle, float x, float y, float z) noexcept {
        shz_xmtrx_init_rotation(angle, x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_init_rotation().
    SHZ_FORCE_INLINE static void init_rotation(float angle, const vec3& axis) noexcept {
        init_rotation(angle, axis.x, axis.y, axis.z);
    }
 
    //! C++ wrapper around shz_xmtrx_init_rotation_axis_angle().
    SHZ_FORCE_INLINE static void init_rotation_dir(float angle, const vec3& dir) noexcept {
        shz_xmtrx_init_rotation_dir(angle, dir.x, dir.y, dir.z);
    }
 
    //! C++ wrapper around shz_xmtrx_init_diagonal().
    SHZ_FORCE_INLINE static void init_diagonal(float x, float y, float z, float w) noexcept {
        shz_xmtrx_init_diagonal(x, y, z, w);
    }
 
    //! C++ wrapper around shz_xmtrx_init_diagonal().
    SHZ_FORCE_INLINE static void init_diagonal(const vec4& v) noexcept {
        init_diagonal(v.x, v.y, v.z, v.w);
    }
 
    //! C++ wrapper around shz_xmtrx_init_upper_triangular().
    SHZ_FORCE_INLINE static void init_upper_triangular(float col1, const vec2& col2, const vec3& col3, const vec4& col4) noexcept {
        shz_xmtrx_init_upper_triangular(col1, col2, col3, col4);
    }
 
    //! C++ wrapper around shz_xmtrx_init_lower_diagonal().
    SHZ_FORCE_INLINE static void init_lower_triangular(const vec4& col1, const vec3& col2, const vec2& col3, float col4) noexcept {
        shz_xmtrx_init_lower_triangular(col1, col2, col3, col4);
    }
 
    //! C++ wrapper around shz_xmtrx_init_symmetric_skew().
    SHZ_FORCE_INLINE static void init_symmetric_skew(float x, float y, float z) noexcept {
        shz_xmtrx_init_symmetric_skew(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_init_outer_product().
    SHZ_FORCE_INLINE static void init_outer_product(const vec4& a, const vec4& b) noexcept {
        shz_xmtrx_init_outer_product(a, b);
    }
 
    //! C++ wrapper around shz_xmtrx_init_screen().
    SHZ_FORCE_INLINE static void init_screen(float width, float height) noexcept {
        shz_xmtrx_init_screen(width, height);
    }
 
    //! C++ wrapper around shz_xmtrx_init_lookat().
    SHZ_FORCE_INLINE static void init_lookat(const vec3& eye, const vec3& center, const vec3& up) noexcept {
        shz_xmtrx_init_lookat(eye, center, up);
    }
 
    //! C++ wrapper around shz_xmtrx_init_ortho().
    SHZ_FORCE_INLINE static void init_ortho(float left, float right, float bottom, float top, float znear, float zfar) noexcept {
        shz_xmtrx_init_ortho(left, right, bottom, top, znear, zfar);
    }
 
    //! C++ wrapper around shz_xmtrx_init_frustum().
    SHZ_FORCE_INLINE static void init_frustum(float left, float right, float bottom, float top, float znear, float zfar) noexcept {
        shz_xmtrx_init_frustum(left, right, bottom, top, znear, zfar);
    }
 
    //! C++ wrapper around shz_xmtrx_init_perspective().
    SHZ_FORCE_INLINE static void init_perspective(float fov, float aspect, float znear) noexcept {
        shz_xmtrx_init_perspective(fov, aspect, znear);
    }
 
    //! C++ wrapper around shz_xmtrx_init_rotation_quat().
    SHZ_FORCE_INLINE static void init_rotation_quat(const quat& q) noexcept {
        shz_xmtrx_init_rotation_quat(q);
    }
 
    //! C++ wrapper around shz_xmtrx_init_permutation_wxyz().
    SHZ_FORCE_INLINE static void init_permutation_wxyz() noexcept {
        shz_xmtrx_init_permutation_wxyz();
    }
 
    //! C++ wrapper around shz_xmtrx_init_permutation_yzwx().
    SHZ_FORCE_INLINE static void init_permutation_yzwx() noexcept {
        shz_xmtrx_init_permutation_yzwx();
    }
 
    //! C++ wrapper around shz_xmtrx_init_permutation_wzyx().
    SHZ_FORCE_INLINE static void init_permutation_wzyx() noexcept {
        shz_xmtrx_init_permutation_wzyx();
    }
 
//! @}
 
/*! \name  Apply Operation
    \brief Updates only relevant values of XMTRX based on the given transform.
    @{
*/
 
    //! C++ wrapper around shz_xmtrx_apply_4x4().
    SHZ_FORCE_INLINE static void apply(const shz_mat4x4_t& mat4) noexcept {
        shz_xmtrx_apply_4x4(&mat4);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_unaligned_4x4().
    SHZ_FORCE_INLINE static void apply(const float cArray[16]) noexcept {
        shz_xmtrx_apply_unaligned_4x4(cArray);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_unaligned_4x4().
    SHZ_FORCE_INLINE static void apply(const std::array<float, 16>& array) noexcept {
        shz_xmtrx_apply_unaligned_4x4(array.data());
    }
 
    //! C++ wrapper around shz_xmtrx_apply_transpose_4x4().
    SHZ_FORCE_INLINE static void apply_transpose(const shz_mat4x4_t& mat4) noexcept {
        shz_xmtrx_apply_transpose_4x4(&mat4);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_transpose_unaligned_4x4().
    SHZ_FORCE_INLINE static void apply_transpose(const float cArray[16]) noexcept {
        shz_xmtrx_apply_transpose_unaligned_4x4(cArray);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_transpose_unaligned_4x4().
    SHZ_FORCE_INLINE static void apply_transpose(const std::array<float, 16>& array) noexcept {
        shz_xmtrx_apply_transpose_unaligned_4x4(array.data());
    }
 
    //! C++ wrapper around shz_xmtrx_apply_reverse_4x4().
    SHZ_FORCE_INLINE static void apply_reverse(const shz_mat4x4_t& mat4) noexcept {
        shz_xmtrx_apply_reverse_4x4(&mat4);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_reverse_unaligned_4x4().
    SHZ_FORCE_INLINE static void apply_reverse(const float cArray[16]) noexcept {
        shz_xmtrx_apply_reverse_unaligned_4x4(cArray);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_reverse_unaligned_4x4().
    SHZ_FORCE_INLINE static void apply_reverse(const std::array<float, 16>& array) noexcept {
        shz_xmtrx_apply_reverse_unaligned_4x4(array.data());
    }
 
    //! C++ wrapper around shz_xmtrx_apply_reverse_transpose_4x4().
    SHZ_FORCE_INLINE static void apply_reverse_transpose(const shz_mat4x4_t& mat4) noexcept {
        shz_xmtrx_apply_reverse_transpose_4x4(&mat4);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_reverse_transpose_unaligned_4x4().
    SHZ_FORCE_INLINE static void apply_reverse_transpose(const float cArray[16]) noexcept {
        shz_xmtrx_apply_reverse_transpose_unaligned_4x4(cArray);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_reverse_transpose_unaligned_4x4().
    SHZ_FORCE_INLINE static void apply_reverse_transpose(const std::array<float, 16>& array) noexcept {
        shz_xmtrx_apply_reverse_transpose_unaligned_4x4(array.data());
    }
 
    //! C++ wrapper around shz_xmtrx_apply_3x4().
    SHZ_FORCE_INLINE static void apply(const shz_mat3x4_t& mat) noexcept {
        shz_xmtrx_apply_3x4(&mat);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_translation().
    SHZ_FORCE_INLINE static void apply_translation(float x, float y, float z) noexcept {
        shz_xmtrx_apply_translation(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_translation().
    SHZ_FORCE_INLINE static void apply_translation(const vec3& v) noexcept {
        apply_translation(v.x, v.y, v.z);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_scale().
    SHZ_FORCE_INLINE static void apply_scale(float x, float y, float z) noexcept {
        shz_xmtrx_apply_scale(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_scale().
    SHZ_FORCE_INLINE static void apply_scale(const vec3& v) noexcept {
        apply_scale(v.x, v.y, v.z);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_rotation_x().
    SHZ_FORCE_INLINE static void apply_rotation_x(float x) noexcept {
        shz_xmtrx_apply_rotation_x(x);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_rotation_y().
    SHZ_FORCE_INLINE static void apply_rotation_y(float y) noexcept {
        shz_xmtrx_apply_rotation_y(y);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_rotation_z().
    SHZ_FORCE_INLINE static void apply_rotation_z(float z) noexcept {
        shz_xmtrx_apply_rotation_z(z);
    }
 
    //! C++ wrapper around shz_xmtrx_init_rotation_xyz().
    SHZ_FORCE_INLINE static void apply_rotation_xyz(float x, float y, float z) noexcept {
        shz_xmtrx_apply_rotation_xyz(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_rotation_zyx().
    SHZ_FORCE_INLINE static void apply_rotation_zyx(float z, float y, float x) noexcept {
        shz_xmtrx_apply_rotation_zyx(z, y, x);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_rotation_zxy().
    SHZ_FORCE_INLINE static void apply_rotation_zxy(float z, float x, float y) noexcept {
        shz_xmtrx_apply_rotation_zxy(z, x, y);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_rotation_yxz().
    SHZ_FORCE_INLINE static void apply_rotation_yxz(float y, float x, float z) noexcept {
        shz_xmtrx_apply_rotation_yxz(y, x, z);
    }
 
    // C++ wrapper around shz_xmtrx_apply_rotation().
    SHZ_FORCE_INLINE static void apply_rotation(float angle, float x, float y, float z) noexcept {
        shz_xmtrx_apply_rotation(angle, x, y, z);
    }
 
    // C++ wrapper around shz_xmtrx_apply_rotation().
        SHZ_FORCE_INLINE static void apply_rotation(float angle, const vec3& axis) noexcept {
        apply_rotation(angle, axis.x, axis.y, axis.z);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_rotation_quat().
    SHZ_FORCE_INLINE static void apply_rotation_quat(const quat& q) noexcept {
        shz_xmtrx_apply_rotation_quat(q);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_lookat().
    SHZ_FORCE_INLINE static void apply_lookat(const vec3& eye, const vec3& center, const vec3& up) noexcept {
        shz_xmtrx_apply_lookat(eye, center, up);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_ortho().
    SHZ_FORCE_INLINE static void apply_ortho(float left, float right, float bottom, float top, float znear, float zfar) noexcept {
        shz_xmtrx_apply_ortho(left, right, bottom, top, znear, zfar);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_frustum().
    SHZ_FORCE_INLINE static void apply_frustum(float left, float right, float bottom, float top, float znear, float zfar) noexcept {
        shz_xmtrx_apply_frustum(left, right, bottom, top, znear, zfar);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_perspective().
    SHZ_FORCE_INLINE static void apply_perspective(float fov, float aspect, float znear) noexcept {
        shz_xmtrx_apply_perspective(fov, aspect, znear);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_symmetric_skew().
    SHZ_FORCE_INLINE static void apply_symmetric_skew(float x, float y, float z) noexcept {
        shz_xmtrx_apply_symmetric_skew(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_screen().
    SHZ_FORCE_INLINE static void apply_screen(float width, float height) noexcept {
        shz_xmtrx_apply_screen(width, height);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_permutation_wxyz().
    SHZ_FORCE_INLINE static void apply_permutation_wxyz() noexcept {
        shz_xmtrx_apply_permutation_wxyz();
    }
 
    //! C++ wrapper around shz_xmtrx_apply_permutation_yzwx().
    SHZ_FORCE_INLINE static void apply_permutation_yzwx() noexcept {
        shz_xmtrx_apply_permutation_yzwx();
    }
 
    //! C++ wrapper around shz_xmtrx_apply_permutation_wzyx().
    SHZ_FORCE_INLINE static void apply_permutation_wzyx() noexcept {
        shz_xmtrx_apply_permutation_wzyx();
    }
 
    //! C++ wrapper around shz_xmtrx_apply_self().
    SHZ_FORCE_INLINE static void apply_self() noexcept {
        shz_xmtrx_apply_self();
    }
 
//! @}
 
/*! \name  OpenGL Operations
    \brief OpenGL-style matrix transformation operations.
    @{
*/
 
    //! C++ wrapper around shz_xmtrx_translate().
    SHZ_FORCE_INLINE static void translate(float x, float y, float z) noexcept {
        shz_xmtrx_translate(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_translate().
    SHZ_FORCE_INLINE static void translate(vec3 v) noexcept {
        translate(v.x, v.y, v.z);
    }
 
    //! C++ wrapper around shz_xmtrx_scale().
    SHZ_FORCE_INLINE static void scale(float x, float y, float z) noexcept {
        shz_xmtrx_scale(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_scale().
    SHZ_FORCE_INLINE static void scale(vec3 v) noexcept {
        scale(v.x, v.y, v.z);
    }
 
    //! C++ wrapper around shz_xmtrx_rotate_x().
    SHZ_FORCE_INLINE static void rotate_x(float radians) noexcept {
        shz_xmtrx_rotate_x(radians);
    }
 
    //! C++ wrapper around shz_xmtrx_rotate_x().
    SHZ_FORCE_INLINE static void rotate_y(float radians) noexcept {
        shz_xmtrx_rotate_y(radians);
    }
 
    //! C++ wrapper around shz_xmtrx_rotate_x().
    SHZ_FORCE_INLINE static void rotate_z(float radians) noexcept {
        shz_xmtrx_rotate_z(radians);
    }
 
    //! C++ wrapper around shz_xmtrx_rotate_xyz().
    SHZ_FORCE_INLINE static void rotate_xyz(float x, float y, float z) noexcept {
        shz_xmtrx_rotate_xyz(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_rotate_zyx().
    SHZ_FORCE_INLINE static void rotate_zyx(float z, float y, float x) noexcept {
        shz_xmtrx_rotate_zyx(z, y, x);
    }
 
    //! C++ wrapper around shz_xmtrx_rotate_zxy().
    SHZ_FORCE_INLINE static void rotate_zxy(float z, float x, float y) noexcept {
        shz_xmtrx_rotate_zxy(z, x, y);
    }
 
    //! C++ wrapper around shz_xmtrx_rotate_yxz().
    SHZ_FORCE_INLINE static void rotate_yxz(float y, float x, float z) noexcept {
        shz_xmtrx_rotate_yxz(y, x, z);
    }
 
    //! C++ wrapper around shz_xmtrx_rotate().
    SHZ_FORCE_INLINE static void rotate(float radians, float x, float y, float z) noexcept {
        shz_xmtrx_rotate(radians, x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_rotate().
    SHZ_FORCE_INLINE static void rotate(float radians, const vec3& axis) noexcept {
        rotate(radians, axis.x, axis.y, axis.z);
    }
 
/*! \name  Reverse GL Transformations
    \brief Pre-multiplication variants of OpenGL-style 4x4 matrix transforms.
    @{
*/
    //! Pre-multiplies and accumulates XMTRX onto the 3D translation matrix with the given components.
    SHZ_FORCE_INLINE static void translate_reverse(float x, float y, float z) noexcept {
        shz_xmtrx_translate_reverse(x, y, z);
    }
 
    //! Pre-multiplies and accumulates XMTRX onto the 3D translation matrix with the given translation vector.
    SHZ_FORCE_INLINE static void translate_reverse(const shz::vec3& pos) noexcept {
        translate_reverse(pos.x, pos.y, pos.z);
    }
 
    //! Pre-multiplies and accumulatse XMTRX onto the 3D scaling matrix with the given components.
    SHZ_FORCE_INLINE static void scale_reverse(float x, float y, float z) noexcept {
        shz_xmtrx_scale_reverse(x, y, z);
    }
 
    //! Pre-multiplies and accumulatse XMTRX onto the 3D scaling matrix with the given size vector.
    SHZ_FORCE_INLINE static void scale_reverse(const shz::vec3& size) noexcept {
        scale_reverse(size.x, size.y, size.z);
    }
 
//! @}
 
/*! \name  Compound Operations
    \brief Multiple operations combined into one pipelined transaction.
    @{
*/
 
    //! C++ wrapper around shz_xmtrx_load_apply_4x4().
    SHZ_FORCE_INLINE static void load_apply(const shz_mat4x4_t& mat1, const shz_mat4x4_t& mat2) noexcept {
        shz_xmtrx_load_apply_4x4(&mat1, &mat2);
    }
 
    //! C++ wrapper around shz_xmtrx_load_apply_unaligned_4x4().
    SHZ_FORCE_INLINE static void load_apply(const float matrix1[16], const float matrix2[16]) noexcept {
        shz_xmtrx_load_apply_unaligned_4x4(matrix1, matrix2);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_store_4x4().
    SHZ_FORCE_INLINE static void apply_store(shz_mat4x4_t* out, const shz_mat4x4_t& in) noexcept {
        shz_xmtrx_apply_store_4x4(out, &in);
    }
 
    //! C++ wrapper around shz_xmtrx_apply_store_unaligned_4x4().
    SHZ_FORCE_INLINE static void apply_store(float out[16], const float in[16]) noexcept {
        shz_xmtrx_apply_store_unaligned_4x4(out, in);
    }
 
    //! C++ wrapper around shz_xmtrx_load_apply_store_4x4().
    SHZ_FORCE_INLINE static void load_apply_store(shz_mat4x4_t* dst, const shz_mat4x4_t& mat1, const shz_mat4x4_t& mat2) noexcept {
        shz_xmtrx_load_apply_store_4x4(dst, &mat1, &mat2);
    }
 
    //! C++ wrapper around shz_xmtrx_load_apply_store_unaligned_4x4().
    SHZ_FORCE_INLINE static void load_apply_store(float out[16], const float matrix1[16], const float matrix2[16]) noexcept {
        shz_xmtrx_load_apply_store_unaligned_4x4(out, matrix1, matrix2);
    }
 
    //! C++ wrapper around shz_xmtrx_load_apply_store_3x4().
    SHZ_FORCE_INLINE static void load_apply_store(shz_mat3x4_t* dst, const shz_mat3x4_t& mat1, const shz_mat3x4_t& mat2) noexcept {
        shz_xmtrx_load_apply_store_3x4(dst, &mat1, &mat2);
    }
 
    //! C++ wrapper around shz_xmtrx_load_apply_store_3x3().
    SHZ_FORCE_INLINE static void load_apply_store(shz_mat3x3_t* dst, const shz_mat3x3_t& mat1, const shz_mat3x3_t& mat2) noexcept {
        shz_xmtrx_load_apply_store_3x3(dst, &mat1, &mat2);
    }
 
//! @}
 
/*! \name  Transformations
    \brief Transforming vectors and points against XMTRX.
    @{
*/
 
    //! C++ wrapper around shz_xmtrx_transform_vec4().
    SHZ_FORCE_INLINE static vec4 transform(const vec4& in) noexcept {
        return shz_xmtrx_transform_vec4(in);
    }
 
    //! C++ wrapper around shz_xmtrx_transform_vec3().
    SHZ_FORCE_INLINE static vec3 transform(const vec3& in) noexcept {
        return shz_xmtrx_transform_vec3(in);
    }
 
    //! C++ wrapper around shz_xmtrx_transform_vec2().
    SHZ_FORCE_INLINE static vec2 transform(const vec2& in) noexcept {
        return shz_xmtrx_transform_vec2(in);
    }
 
    //! C++ wrapper around shz_xmtrx_transform_point3().
    SHZ_FORCE_INLINE static vec3 transform_point(const vec3& pt) noexcept {
        return shz_xmtrx_transform_point3(pt);
    }
 
    //! C++ wrapper around shz_xmtrx_transform_point2().
    SHZ_FORCE_INLINE static vec2 transform_point(const vec2& pt) noexcept {
        return shz_xmtrx_transform_point2(pt);
    }
 
//! @}
 
/*! \name  Setters
    \brief Sets the values of related XMTRX components.
    @{
*/
 
    //! C++ wrapper around shz_xmtrx_set_translation().
    SHZ_FORCE_INLINE static void set_translation(float x, float y, float z) noexcept {
        shz_xmtrx_set_translation(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_set_translation().
    SHZ_FORCE_INLINE static void set_translation(const vec3& v) noexcept {
        set_translation(v.x, v.y, v.z);
    }
 
    //! Sets only the inner 3x3 submatrix to be a 3D scale matrix with the given components.
    SHZ_FORCE_INLINE static void set_scale(float x, float y, float z) noexcept {
        shz_xmtrx_set_scale(x, y, z);
    }
 
    //! Sets only the inner 3x3 submatrix to be a 3D scale matrix with the given scale vector.
    SHZ_FORCE_INLINE static void set_scale(const shz::vec3& size) noexcept {
        set_scale(size.x, size.y, size.z);
    }
 
//! @}
 
/*! \name  Getters
    \brief Gets the values of related XMTRX components.
    @{
*/
 
    //! C++ wrapper around shz_xmtrx_set_translation().
    SHZ_FORCE_INLINE static vec3 get_translation() noexcept {
        return shz_xmtrx_get_translation();
    }
 
    /*! Returns the scaling components from the inner 3x3 matrix of XMTRX, as a 3D vector.
 
        \warning This routine assumes XMTRX is a standard TRS-style transform matrix,
                 without shearing or reflection.
    */
    SHZ_FORCE_INLINE static vec3 get_scale() noexcept {
        return shz_xmtrx_get_scale();
    }
 
//! @}
 
/*! \name  Miscellaneous
    \brief Random operations and conversions on XMTRX.
    @{
*/
 
    //! C++ wrapper around shz_xmtrx_add_4x4().
    SHZ_FORCE_INLINE static void add(const shz_mat4x4_t& mat) noexcept {
        shz_xmtrx_add_4x4(&mat);
    }
 
    //! C++ wrapper around shz_xmtrx_sub_4x4().
    SHZ_FORCE_INLINE static void sub(const shz_mat4x4_t& mat) noexcept {
        shz_xmtrx_sub_4x4(&mat);
    }
 
    //! C++ wrapper around shz_xmtrx_add_diagonal().
    SHZ_FORCE_INLINE static void add_diagonal(float x, float y, float z, float w) noexcept {
        shz_xmtrx_add_diagonal(x, y, z, w);
    }
 
    //! C++ wrapper around shz_xmtrx_add_diagonal().
    SHZ_FORCE_INLINE static void add_diagonal(const vec4& v) noexcept {
        add_diagonal(v.x, v.y, v.z, v.w);
    }
 
    //! C++ wrapper around shz_xmtrx_add_symmetric_skew().
    SHZ_FORCE_INLINE static void add_symmetric_skew(float x, float y, float z) noexcept {
        shz_xmtrx_add_symmetric_skew(x, y, z);
    }
 
    //! C++ wrapper around shz_xmtrx_add_symmetric_skew().
    SHZ_FORCE_INLINE static void add_symmetric_skew(const vec3& v) noexcept {
        add_symmetric_skew(v.x, v.y, v.z);
    }
 
    //! C++ wrapper around shz_xmtrx_transpose().
    SHZ_FORCE_INLINE static void transpose() noexcept {
        shz_xmtrx_transpose();
    }
 
    //! C++ wrapper around shz_xmtrx_negate().
    SHZ_FORCE_INLINE static void negate() noexcept {
        shz_xmtrx_negate();
    }
 
    //! C++ wrapper around shz_xmtrx_abs().
    SHZ_FORCE_INLINE static void abs() noexcept {
        shz_xmtrx_abs();
    }
 
    //! C++ wrapper around shz_xmtrx_to_quat().
    SHZ_FORCE_INLINE static quat to_quat() noexcept {
        return shz_xmtrx_to_quat();
    }
 
    //! C++ wrapper around shz_xmtrx_determinant().
    SHZ_FORCE_INLINE static float determinant() noexcept {
        return shz_xmtrx_determinant();
    }
 
    //! C++ wrapper around shz_xmtrx_invert().
    SHZ_FORCE_INLINE static void invert() noexcept {
        shz_xmtrx_invert();
    }
 
    /*! Adds and accumulates a scaled 4x4 matrix onto XMTRX.
 
    Each component of \p joint_matrix will be multiplied by \p weight, with the result
    being added to the existing value of that component of XMTRX.
 
    This is useful for accumulating weighted joint matrices onto an initially
    zeroed-out XMTRX. This allows for in-place construction of a skin matrix, which can
    then be directly used to transform the vertices of a mesh against for animation.
 
    \sa shz_xmtrx_init_zero()
    */
    SHZ_FORCE_INLINE static void blend(const shz_mat4x4_t& joint_matrix, float weight) noexcept {
        shz_xmtrx_blend(&joint_matrix, weight);
    }
 
//! @}
 
};
}
 
#endif