Matrix.hh

#pragma once
 
#include "egg/math/Quat.hh"
 
namespace EGG {
 
class Matrix34f {
public:
#ifdef BUILD_DEBUG
    constexpr Matrix34f() {
        a.fill(std::numeric_limits<f32>::signaling_NaN());
    }
#else
    constexpr Matrix34f() = default;
#endif
 
    constexpr Matrix34f(f32 _e00, f32 _e01, f32 _e02, f32 _e03, f32 _e10, f32 _e11, f32 _e12,
            f32 _e13, f32 _e20, f32 _e21, f32 _e22, f32 _e23)
        : mtx{{_e00, _e01, _e02, _e03, _e10, _e11, _e12, _e13, _e20, _e21, _e22, _e23}} {}
 
    ~Matrix34f() = default;
 
    bool operator==(const Matrix34f &rhs) const {
        return mtx == rhs.mtx;
    }
 
    [[nodiscard]] f32 &operator[](size_t row, size_t col) {
        return mtx[row][col];
    }
 
    [[nodiscard]] f32 operator[](size_t row, size_t col) const {
        return mtx[row][col];
    }
 
    void makeQT(const Quatf &q, const Vector3f &t);
    void makeQ(const Quatf &q);
    void makeRT(const Vector3f &r, const Vector3f &t);
    void makeR(const Vector3f &r);
    void makeS(const Vector3f &s);
    void makeT(const Vector3f &t);
 
    void makeZero() {
        *this = Matrix34f::zero;
    }
 
    void makeOrthonormalBasis(const Vector3f &v0, const Vector3f &v1);
    void setAxisRotation(f32 angle, const Vector3f &axis);
    void mulRow33(size_t rowIdx, const Vector3f &row);
    void setBase(size_t col, const Vector3f &base);
 
    [[nodiscard]] Matrix34f multiplyTo(const Matrix34f &rhs) const;
    [[nodiscard]] Vector3f multVector(const Vector3f &vec) const;
    [[nodiscard]] Vector3f ps_multVector(const Vector3f &vec) const;
    [[nodiscard]] Vector3f multVector33(const Vector3f &vec) const;
    [[nodiscard]] Vector3f ps_multVector33(const Vector3f &vec) const;
    void inverseTo33(Matrix34f &out) const;
    bool ps_inverse(Matrix34f &out) const;
    [[nodiscard]] Matrix34f transpose() const;
 
    [[nodiscard]] Vector3f translation() const {
        return Vector3f(mtx[0][3], mtx[1][3], mtx[2][3]);
    }
 
    [[nodiscard]] Vector3f base(size_t col) const {
        return Vector3f(mtx[0][col], mtx[1][col], mtx[2][col]);
    }
 
    static const Matrix34f ident;
    static const Matrix34f zero;
 
private:
    union {
        std::array<std::array<f32, 4>, 3> mtx;
        std::array<f32, 12> a;
    };
};
 
inline constexpr Matrix34f Matrix34f::ident(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f);
 
inline constexpr Matrix34f Matrix34f::zero(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 0.0f);
 
} // namespace EGG