Matrix.hpp

#ifndef RAYLIB_CPP_INCLUDE_MATRIX_HPP_
#define RAYLIB_CPP_INCLUDE_MATRIX_HPP_
 
#include "./raylib.hpp"
#include "./raylib-cpp-utils.hpp"
#include "./raymath.hpp"
#include "./RadiansDegrees.hpp"
#include "./Vector4.hpp"
 
#ifndef RAYLIB_CPP_NO_MATH
#include <cmath>
#endif
 
namespace raylib {
class Matrix : public ::Matrix {
 public:
    struct LocalSpace_t {};
    constexpr static LocalSpace_t LocalSpace{};
    struct GlobalSpace_t {};
    constexpr static GlobalSpace_t GlobalSpace{};
 
    Matrix(const ::Matrix& mat) : ::Matrix{
            mat.m0, mat.m4, mat.m8, mat.m12,
            mat.m1, mat.m5, mat.m9, mat.m13,
            mat.m2, mat.m6, mat.m10, mat.m14,
            mat.m3, mat.m7, mat.m11, mat.m15} {
        // Nothing.
    }
 
    Matrix(
            float m0 = 0, float m4 = 0, float m8 = 0, float m12 = 0,
            float m1 = 0, float m5 = 0, float m9 = 0, float m13 = 0,
            float m2 = 0, float m6 = 0, float m10 = 0, float m14 = 0,
            float m3 = 0, float m7 = 0, float m11 = 0, float m15 = 0) :
        ::Matrix{
            m0, m4, m8, m12,
            m1, m5, m9, m13,
            m2, m6, m10, m14,
            m3, m7, m11, m15} {
        // Nothing.
    }
 
    GETTERSETTER(float, M0, m0)
    GETTERSETTER(float, M1, m1)
    GETTERSETTER(float, M2, m2)
    GETTERSETTER(float, M3, m3)
    GETTERSETTER(float, M4, m4)
    GETTERSETTER(float, M5, m5)
    GETTERSETTER(float, M6, m6)
    GETTERSETTER(float, M7, m7)
    GETTERSETTER(float, M8, m8)
    GETTERSETTER(float, M9, m9)
    GETTERSETTER(float, M10, m10)
    GETTERSETTER(float, M11, m11)
    GETTERSETTER(float, M12, m12)
    GETTERSETTER(float, M13, m13)
    GETTERSETTER(float, M14, m14)
    GETTERSETTER(float, M15, m15)
 
    Matrix& operator=(const ::Matrix& matrix) {
        set(matrix);
        return *this;
    }
 
    Matrix& operator=(const Matrix& matrix) {
        set(matrix);
        return *this;
    }
 
    bool operator==(const ::Matrix& other) {
        return m0 == other.m0
            && m1 == other.m1
            && m2 == other.m2
            && m3 == other.m3
            && m4 == other.m4
            && m5 == other.m5
            && m6 == other.m6
            && m7 == other.m7
            && m8 == other.m8
            && m9 == other.m9
            && m10 == other.m10
            && m11 == other.m11
            && m12 == other.m12
            && m13 == other.m13
            && m14 == other.m14
            && m15 == other.m15;
    }
 
    bool operator!=(const ::Matrix& other) {
        return !(*this == other);
    }
 
#ifndef RAYLIB_CPP_NO_MATH
    inline float Trace() const {
        return ::MatrixTrace(*this);
    }
 
    inline Matrix Transpose() const {
        return ::MatrixTranspose(*this);
    }
 
    inline Matrix Invert() const {
        return ::MatrixInvert(*this);
    }
 
    static Matrix Identity() {
        return ::MatrixIdentity();
    }
 
    inline Matrix TranslateToOrigin() const {
        return CreateTranslate(-m12, -m13, -m14);
    }
 
    inline Matrix Add(const ::Matrix& right) const {
        return ::MatrixAdd(*this, right);
    }
 
    inline Matrix operator+(const ::Matrix& matrix) const {
        return ::MatrixAdd(*this, matrix);
    }
 
    inline Matrix Subtract(const ::Matrix& right) const {
        return ::MatrixSubtract(*this, right);
    }
 
    inline Matrix operator-(const ::Matrix& matrix) const {
        return ::MatrixSubtract(*this, matrix);
    }
 
    inline Matrix Multiply(const ::Matrix& right) const {
        return ::MatrixMultiply(*this, right);
    }
 
    inline Matrix operator*(const ::Matrix& matrix) const {
        return ::MatrixMultiply(*this, matrix);
    }
 
    static Matrix CreateTranslate(float x, float y, float z) {
        return ::MatrixTranslate(x, y, z);
    }
 
    inline Matrix Translate(GlobalSpace_t, float x, float y, float z) const {
        return (*this) * CreateTranslate(x, y, z);
    }
 
    inline Matrix Translate(LocalSpace_t, float x, float y, float z) const {
        return CreateTranslate(x, y, z) * (*this);
    }
 
    inline Matrix Translate(float x, float y, float z) const {
        return Translate(GlobalSpace, x, y, z);
    }
 
    static Matrix CreateTranslate(Vector3 translation) {
        return ::MatrixTranslate(translation.x, translation.y, translation.z);
    }
 
    Matrix Translate(GlobalSpace_t, Vector3 translation) const {
        return (*this) * CreateTranslate(translation.x, translation.y, translation.z);
    }
 
    Matrix Translate(LocalSpace_t, Vector3 translation) const {
        return CreateTranslate(translation.x, translation.y, translation.z) * (*this);
    }
 
    inline Matrix Translate(Vector3 translation) const {
        return Translate(GlobalSpace, translation.x, translation.y, translation.z);
    }
 
    static Matrix CreateRotate(Vector3 axis, Radian angle) {
        return ::MatrixRotate(axis, angle);
    }
 
    Matrix Rotate(GlobalSpace_t, Vector3 axis, Radian angle) const {
        return (*this) * CreateRotate(axis, angle);
    }
 
    Matrix Rotate(LocalSpace_t, Vector3 axis, Radian angle) const {
        auto toOrigin = TranslateToOrigin();
        return (*this) * toOrigin * CreateRotate(axis, angle) * toOrigin.Invert();
    }
 
    inline Matrix Rotate(Vector3 axis, Radian angle) const {
        return Rotate(LocalSpace, axis, angle);
    }
 
    static Matrix CreateRotate(Quaternion quat) {
        auto [axis, angle] = quat.ToAxisAngle();
        return CreateRotate(axis, angle);
    }
 
    Matrix Rotate(GlobalSpace_t, Quaternion quat) const {
        return (*this) * CreateRotate(quat);
    }
 
    Matrix Rotate(LocalSpace_t, Quaternion quat) const {
        auto toOrigin = TranslateToOrigin();
        return (*this) * toOrigin * CreateRotate(quat) * toOrigin.Invert();
    }
 
    inline Matrix Rotate(Quaternion quat) const {
        return Rotate(LocalSpace, quat);
    }
 
    static Matrix CreateRotateXYZ(Vector3 angle) {
        return ::MatrixRotateXYZ(angle);
    }
 
    Matrix RotateXYZ(GlobalSpace_t, Vector3 angle) const {
        return (*this) * CreateRotateXYZ(angle);
    }
 
    Matrix RotateXYZ(LocalSpace_t, Vector3 angle) const {
        auto toOrigin = TranslateToOrigin();
        return (*this) * toOrigin * CreateRotateXYZ(angle) * toOrigin.Invert();
    }
 
    inline Matrix RotateXYZ(Vector3 angle) const {
        return RotateXYZ(LocalSpace, angle);
    }
 
    static Matrix CreateRotateXYZ(Radian x, Radian y, Radian z) {
        return CreateRotateXYZ(Vector3{x, y, z});
    }
 
    Matrix RotateXYZ(GlobalSpace_t, Radian x, Radian y, Radian z) const {
        return (*this) * CreateRotateXYZ(x, y, z);
    }
 
    Matrix RotateXYZ(LocalSpace_t, Radian x, Radian y, Radian z) const {
        auto toOrigin = TranslateToOrigin();
        return (*this) * toOrigin * CreateRotateXYZ(x, y, z) * toOrigin.Invert();
    }
 
    inline Matrix RotateXYZ(Radian x, Radian y, Radian z) const {
        return RotateXYZ(LocalSpace, x, y, z);
    }
 
    static Matrix CreateRotateX(Radian angle) {
        return ::MatrixRotateX(angle);
    }
 
    Matrix RotateX(GlobalSpace_t, Radian angle) const {
        return (*this) * CreateRotateX(angle);
    }
 
    Matrix RotateX(LocalSpace_t, Radian angle) const {
        auto toOrigin = TranslateToOrigin();
        return (*this) * toOrigin * CreateRotateX(angle) * toOrigin.Invert();
    }
 
    inline Matrix RotateX(Radian angle) const {
        return RotateX(LocalSpace, angle);
    }
 
    static Matrix CreateRotateY(Radian angle) {
        return ::MatrixRotateY(angle);
    }
 
    Matrix RotateY(GlobalSpace_t, Radian angle) const {
        return (*this) * CreateRotateY(angle);
    }
 
    Matrix RotateY(LocalSpace_t, Radian angle) const {
        auto toOrigin = TranslateToOrigin();
        return (*this) * toOrigin * CreateRotateY(angle) * toOrigin.Invert();
    }
 
    inline Matrix RotateY(Radian angle) const {
        return RotateY(LocalSpace, angle);
    }
 
    static Matrix CreateRotateZ(Radian angle) {
        return ::MatrixRotateZ(angle);
    }
 
    Matrix RotateZ(GlobalSpace_t, Radian angle) const {
        return (*this) * CreateRotateZ(angle);
    }
 
    Matrix RotateZ(LocalSpace_t, Radian angle) const {
        auto toOrigin = TranslateToOrigin();
        return (*this) * toOrigin * CreateRotateZ(angle) * toOrigin.Invert();
    }
 
    inline Matrix RotateZ(Radian angle) const {
        return RotateZ(LocalSpace, angle);
    }
 
    static Matrix CreateScale(float x, float y, float z) {
        return ::MatrixScale(x, y, z);
    }
 
    Matrix Scale(GlobalSpace_t, float x, float y, float z) const {
        return (*this) * CreateScale(x, y, z);
    }
    inline Matrix Scale(GlobalSpace_t, float all) const {
        return Scale(GlobalSpace, all, all, all);
    }
 
    Matrix Scale(LocalSpace_t, float x, float y, float z) const {
        auto toOrigin = TranslateToOrigin();
        return (*this) * toOrigin * CreateScale(x, y, z) * toOrigin.Invert();
    }
    inline Matrix Scale(LocalSpace_t, float all) const {
        return Scale(LocalSpace, all, all, all);
    }
 
    inline Matrix Scale(float x, float y, float z) const {
        return Scale(LocalSpace, x, y, z);
    }
    inline Matrix Scale(float all) const {
        return Scale(LocalSpace, all);
    }
 
    static Matrix Frustum(double left, double right, double bottom, double top,
            double near, double far) {
        return ::MatrixFrustum(left, right, bottom, top, near, far);
    }
 
    static Matrix Perspective(double fovy, double aspect, double near, double far) {
        return ::MatrixPerspective(fovy, aspect, near, far);
    }
 
    static Matrix Ortho(double left, double right, double bottom, double top,
            double near, double far) {
        return ::MatrixOrtho(left, right, bottom, top, near, far);
    }
 
    static Matrix LookAt(Vector3 eye, Vector3 target, Vector3 up) {
        return ::MatrixLookAt(eye, target, up);
    }
 
    float16 ToFloatV() const {
        return ::MatrixToFloatV(*this);
    }
 
    operator float16() {
        return ToFloatV();
    }
 
    Matrix& SetShaderValue(const ::Shader& shader, int uniformLoc) {
        ::SetShaderValueMatrix(shader, uniformLoc, *this);
        return *this;
    }
 
    static Matrix GetCamera(const ::Camera& camera) {
        return ::GetCameraMatrix(camera);
    }
 
    static Matrix GetCamera(const ::Camera2D& camera) {
        return ::GetCameraMatrix2D(camera);
    }
 
#endif
 
 protected:
    void set(const ::Matrix& mat) {
        m0 = mat.m0;
        m1 = mat.m1;
        m2 = mat.m2;
        m3 = mat.m3;
        m4 = mat.m4;
        m5 = mat.m5;
        m6 = mat.m6;
        m7 = mat.m7;
        m8 = mat.m8;
        m9 = mat.m9;
        m10 = mat.m10;
        m11 = mat.m11;
        m12 = mat.m12;
        m13 = mat.m13;
        m14 = mat.m14;
        m15 = mat.m15;
    }
};
 
using Transform = Matrix; // raylib::Transform is also a matrix
}  // namespace raylib
 
using RMatrix = raylib::Matrix;
 
#endif  // RAYLIB_CPP_INCLUDE_MATRIX_HPP_