Matrix4.hpp

// INFINITY_API_PUBLIC
 
#pragma once
 
#include <Infinity/Types/Core/Value.hpp>
#include <Infinity/Types/Containers/Array.hpp>
#include <Infinity/Types/Math/Vector4.hpp>
 
#include <cmath>
 
namespace Infinity::Types::Math
{
 
    template<typename T>
    struct INFINITY_API_TEMPLATE t_Matrix4
    {
    public:
        t_Vector4<T> value[4];
 
        constexpr t_Matrix4() :
            value{{1, 0, 0, 0},
                    {0, 1, 0, 0},
                    {0, 0, 1, 0},
                    {0, 0, 0, 1}} {}
 
        constexpr explicit t_Matrix4(T v) :
            value{{v, 0, 0, 0},
                    {0, v, 0, 0},
                    {0, 0, v, 0},
                    {0, 0, 0, v}} {}
 
        constexpr t_Matrix4(T v0, T v1, T v2, T v3,
                            T v4, T v5, T v6, T v7,
                            T v8, T v9, T v10, T v11,
                            T v12, T v13, T v14, T v15) :
            value{{v0, v1, v2, v3},
                    {v4, v5, v6, v7},
                    {v8, v9, v10, v11},
                    {v12, v13, v14, v15}}
        {
        }
 
        constexpr explicit t_Matrix4(T v[16]) :
            value{{v[0], v[1], v[2], v[3]},
                    {v[4], v[5], v[6], v[7]},
                    {v[8], v[9], v[10], v[11]},
                    {v[12], v[13], v[14], v[15]}} {}
 
        constexpr t_Matrix4(const t_Vector4<T>& c0,
                            const t_Vector4<T>& c1,
                            const t_Vector4<T>& c2,
                            const t_Vector4<T>& c3) :
            value{c0, c1, c2, c3}
        {
        }
 
        template<typename R>
        explicit t_Matrix4(const t_Matrix4<R>& rhs)
        {
            value[0] = rhs[0];
            value[1] = rhs[1];
            value[2] = rhs[2];
            value[3] = rhs[3];
        }
 
        constexpr size_t size() const { return 16; }
 
        constexpr size_t columns() const { return 4; }
 
        constexpr size_t rows() const { return 4; }
 
        t_Vector4<T>& operator[](size_t c) { return value[c]; }
 
        const t_Vector4<T>& operator[](size_t c) const { return value[c]; }
 
        T& operator()(size_t c, size_t r) { return value[c][r]; }
 
        T operator()(size_t c, size_t r) const { return value[c][r]; }
 
        template<typename R>
        t_Matrix4& operator=(const t_Matrix4<R>& rhs)
        {
            value[0] = rhs[0];
            value[1] = rhs[1];
            value[2] = rhs[2];
            value[3] = rhs[3];
            return *this;
        }
 
        void set(T v0, T v1, T v2, T v3,
                    T v4, T v5, T v6, T v7,
                    T v8, T v9, T v10, T v11,
                    T v12, T v13, T v14, T v15)
        {
            value[0].set(v0, v1, v2, v3);
            value[1].set(v4, v5, v6, v7);
            value[2].set(v8, v9, v10, v11);
            value[3].set(v12, v13, v14, v15);
        }
 
        template<typename R>
        void set(const t_Matrix4<R>& rhs)
        {
            value[0] = rhs[0];
            value[1] = rhs[1];
            value[2] = rhs[2];
            value[3] = rhs[3];
        }
 
        T* data() { return value[0].data(); }
 
        const T* data() const { return value[0].data(); }
 
        t_Matrix4 operator*(T scalar) const
        {
            return t_Matrix4(
                value[0].x * scalar, value[0].y * scalar, value[0].z * scalar, value[0].w * scalar,
                value[1].x * scalar, value[1].y * scalar, value[1].z * scalar, value[1].w * scalar,
                value[2].x * scalar, value[2].y * scalar, value[2].z * scalar, value[2].w * scalar,
                value[3].x * scalar, value[3].y * scalar, value[3].z * scalar, value[3].w * scalar
            );
        }
 
        t_Matrix4& operator*=(T scalar)
        {
            value[0] *= scalar;
            value[1] *= scalar;
            value[2] *= scalar;
            value[3] *= scalar;
            return *this;
        }
 
        t_Matrix4 operator*(const t_Matrix4& rhs) const
        {
            return t_Matrix4(
                value[0].x * rhs.value[0].x + value[0].y * rhs.value[1].x + value[0].z * rhs.value[2].x + value[0].w * rhs.value[3].x,
                value[0].x * rhs.value[0].y + value[0].y * rhs.value[1].y + value[0].z * rhs.value[2].y + value[0].w * rhs.value[3].y,
                value[0].x * rhs.value[0].z + value[0].y * rhs.value[1].z + value[0].z * rhs.value[2].z + value[0].w * rhs.value[3].z,
                value[0].x * rhs.value[0].w + value[0].y * rhs.value[1].w + value[0].z * rhs.value[2].w + value[0].w * rhs.value[3].w,
 
                value[1].x * rhs.value[0].x + value[1].y * rhs.value[1].x + value[1].z * rhs.value[2].x + value[1].w * rhs.value[3].x,
                value[1].x * rhs.value[0].y + value[1].y * rhs.value[1].y + value[1].z * rhs.value[2].y + value[1].w * rhs.value[3].y,
                value[1].x * rhs.value[0].z + value[1].y * rhs.value[1].z + value[1].z * rhs.value[2].z + value[1].w * rhs.value[3].z,
                value[1].x * rhs.value[0].w + value[1].y * rhs.value[1].w + value[1].z * rhs.value[2].w + value[1].w * rhs.value[3].w,
 
                value[2].x * rhs.value[0].x + value[2].y * rhs.value[1].x + value[2].z * rhs.value[2].x + value[2].w * rhs.value[3].x,
                value[2].x * rhs.value[0].y + value[2].y * rhs.value[1].y + value[2].z * rhs.value[2].y + value[2].w * rhs.value[3].y,
                value[2].x * rhs.value[0].z + value[2].y * rhs.value[1].z + value[2].z * rhs.value[2].z + value[2].w * rhs.value[3].z,
                value[2].x * rhs.value[0].w + value[2].y * rhs.value[1].w + value[2].z * rhs.value[2].w + value[2].w * rhs.value[3].w,
 
                value[3].x * rhs.value[0].x + value[3].y * rhs.value[1].x + value[3].z * rhs.value[2].x + value[3].w * rhs.value[3].x,
                value[3].x * rhs.value[0].y + value[3].y * rhs.value[1].y + value[3].z * rhs.value[2].y + value[3].w * rhs.value[3].y,
                value[3].x * rhs.value[0].z + value[3].y * rhs.value[1].z + value[3].z * rhs.value[2].z + value[3].w * rhs.value[3].z,
                value[3].x * rhs.value[0].w + value[3].y * rhs.value[1].w + value[3].z * rhs.value[2].w + value[3].w * rhs.value[3].w
            );
        }
 
        t_Matrix4& operator*=(const t_Matrix4& rhs)
        {
            *this = *this * rhs;
            return *this;
        }
 
        t_Vector4<T> operator*(const t_Vector4<T>& v) const
        {
            return t_Vector4<T>(
                value[0].x * v.x + value[0].y * v.y + value[0].z * v.z,
                value[1].x * v.x + value[1].y * v.y + value[1].z * v.z,
                value[2].x * v.x + value[2].y * v.y + value[2].z * v.z,
                value[3].x * v.x + value[3].y * v.y + value[3].z * v.z
            );
        }
 
        t_Matrix4 operator+(const t_Matrix4& rhs) const
        {
            return t_Matrix4(
                value[0].x + rhs.value[0].x, value[0].y + rhs.value[0].y, value[0].z + rhs.value[0].z, value[0].w + rhs.value[0].w,
                value[1].x + rhs.value[1].x, value[1].y + rhs.value[1].y, value[1].z + rhs.value[1].z, value[1].w + rhs.value[1].w,
                value[2].x + rhs.value[2].x, value[2].y + rhs.value[2].y, value[2].z + rhs.value[2].z, value[2].w + rhs.value[2].w,
                value[3].x + rhs.value[3].x, value[3].y + rhs.value[3].y, value[3].z + rhs.value[3].z, value[3].w + rhs.value[3].w
            );
        }
        
        t_Matrix4& operator+=(const t_Matrix4& rhs)
        {
            value[0] += rhs.value[0];
            value[1] += rhs.value[1];
            value[2] += rhs.value[2];
            value[3] += rhs.value[3];
            return *this;
        }
 
        t_Matrix4 operator-(const t_Matrix4& rhs) const
        {
            return t_Matrix4(
                value[0].x - rhs.value[0].x, value[0].y - rhs.value[0].y, value[0].z - rhs.value[0].z, value[0].w - rhs.value[0].w,
                value[1].x - rhs.value[1].x, value[1].y - rhs.value[1].y, value[1].z - rhs.value[1].z, value[1].w - rhs.value[1].w,
                value[2].x - rhs.value[2].x, value[2].y - rhs.value[2].y, value[2].z - rhs.value[2].z, value[2].w - rhs.value[2].w,
                value[3].x - rhs.value[3].x, value[3].y - rhs.value[3].y, value[3].z - rhs.value[3].z, value[3].w - rhs.value[3].w
            );
        }
 
        t_Matrix4& operator-=(const t_Matrix4& rhs)
        {
            value[0] -= rhs.value[0];
            value[1] -= rhs.value[1];
            value[2] -= rhs.value[2];
            value[3] -= rhs.value[3];
            return *this;
        }
 
        t_Matrix4 operator/(T scalar) const
        {
            if constexpr (std::is_floating_point_v<T>)
            {
                T inv = static_cast<T>(1.0) / scalar;
                return t_Matrix4(
                    value[0].x * inv, value[0].y * inv, value[0].z * inv, value[0].w * inv,
                    value[1].x * inv, value[1].y * inv, value[1].z * inv, value[1].w * inv,
                    value[2].x * inv, value[2].y * inv, value[2].z * inv, value[2].w * inv,
                    value[3].x * inv, value[3].y * inv, value[3].z * inv, value[3].w * inv
                );
            }
            else
            {
                return t_Matrix4(
                    value[0].x / scalar, value[0].y / scalar, value[0].z / scalar, value[0].w / scalar,
                    value[1].x / scalar, value[1].y / scalar, value[1].z / scalar, value[1].w / scalar,
                    value[2].x / scalar, value[2].y / scalar, value[2].z / scalar, value[2].w / scalar,
                    value[3].x / scalar, value[3].y / scalar, value[3].z / scalar, value[3].w / scalar
                );
            }
        }
 
        t_Matrix4& operator/=(T scalar)
        {
            if constexpr (std::is_floating_point_v<T>)
            {
                T inv = static_cast<T>(1.0) / scalar;
                value[0] *= inv;
                value[1] *= inv;
                value[2] *= inv;
                value[3] *= inv;
            }
            else
            {
                value[0] /= scalar;
                value[1] /= scalar;
                value[2] /= scalar;
                value[3] /= scalar;
            }
            return *this;
        }
 
        bool operator==(const t_Matrix4& rhs) const
        {
            return value[0] == rhs.value[0] &&
                   value[1] == rhs.value[1] &&
                   value[2] == rhs.value[2] &&
                   value[3] == rhs.value[3];
        }
 
        bool operator!=(const t_Matrix4& rhs) const
        {
            return !(*this == rhs);
        }
 
        bool operator<(const t_Matrix4& rhs) const
        {
            if (value[0] < rhs.value[0]) return true;
            if (value[0] > rhs.value[0]) return false;
            if (value[1] < rhs.value[1]) return true;
            if (value[1] > rhs.value[1]) return false;
            if (value[2] < rhs.value[2]) return true;
            if (value[2] > rhs.value[2]) return false;
            return value[3] < rhs.value[3];
        }
 
        t_Matrix4 transpose() const
        {
            return t_Matrix4(
            value[0].x, value[1].x, value[2].x, value[3].x,
            value[0].y, value[1].y, value[2].y, value[3].y,
            value[0].z, value[1].z, value[2].z, value[3].z,
            value[0].w, value[1].w, value[2].w, value[3].w
            );
        }
 
        t_Matrix4 operator-() const
        {
            return t_Matrix4(
                -value[0].x, -value[0].y, -value[0].z,
                -value[1].x, -value[1].y, -value[1].z,
                -value[2].x, -value[2].y, -value[2].z,
                -value[3].x, -value[3].y, -value[3].z
            );
        }
 
        explicit operator bool() const noexcept
        {
            return value[0] != t_Vector4<T>(0, 0, 0, 0) ||
                value[1] != t_Vector4<T>(0, 0, 0, 0) ||
                value[2] != t_Vector4<T>(0, 0, 0, 0) ||
                value[3] != t_Vector4<T>(0, 0, 0, 0);
        }
    };
 
    using Matrix4 = t_Matrix4<float>;
 
    using Matrix4d = t_Matrix4<double>;
 
    template<typename T>
    inline std::ostream& operator<<(std::ostream& out, const t_Matrix4<T>& m)
    {
        out << m.value[0] << " " << m.value[1] << " " << m.value[2] << " " << m.value[3];
        return out;
    }
 
    template<typename T>
    inline std::istream& operator>>(std::istream& in, t_Matrix4<T>& m)
    {
        in >> m.value[0] >> m.value[1] >> m.value[2] >> m.value[3];
        return in;
    }
 
}
 
// Register Value<Matrix4> specializations in the type system
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Matrix4>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Matrix4d>)
 
// Register Array<Matrix4> specializations in the type system
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Matrix4>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Matrix4d>)