Matrix3.hpp

// INFINITY_API_PUBLIC
 
#pragma once
 
#include <Infinity/Types/Core/Value.hpp>
#include <Infinity/Types/Containers/Array.hpp>
#include <Infinity/Types/Math/Vector3.hpp>
 
#include <cmath>
 
namespace Infinity::Types::Math
{
 
    template<typename T>
    struct INFINITY_API_TEMPLATE t_Matrix3
    {
    public:
        t_Vector3<T> value[3];
 
        constexpr t_Matrix3() :
            value{{1, 0, 0},
                    {0, 1, 0},
                    {0, 0, 1}} {}
 
        constexpr explicit t_Matrix3(T v) :
            value{{v, 0, 0},
                    {0, v, 0},
                    {0, 0, v}} {}
 
        constexpr t_Matrix3(T v0, T v1, T v2,
                            T v3, T v4, T v5,
                            T v6, T v7, T v8) :
            value{{v0, v1, v2},
                    {v3, v4, v5},
                    {v6, v7, v8}}
        {
        }
 
        constexpr explicit t_Matrix3(T v[9]) :
            value{{v[0], v[1], v[2]},
                    {v[3], v[4], v[5]},
                    {v[6], v[7], v[8]}} {}
 
        constexpr t_Matrix3(const t_Vector3<T>& c0,
                            const t_Vector3<T>& c1,
                            const t_Vector3<T>& c2) :
            value{c0, c1, c2}
        {
        }
 
        template<typename R>
        explicit t_Matrix3(const t_Matrix3<R>& rhs)
        {
            value[0] = rhs[0];
            value[1] = rhs[1];
            value[2] = rhs[2];
        }
 
        constexpr size_t size() const { return 9; }
 
        constexpr size_t columns() const { return 3; }
 
        constexpr size_t rows() const { return 3; }
 
        t_Vector3<T>& operator[](size_t c) { return value[c]; }
 
        const t_Vector3<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_Matrix3& operator=(const t_Matrix3<R>& rhs)
        {
            value[0] = rhs[0];
            value[1] = rhs[1];
            value[2] = rhs[2];
            return *this;
        }
 
        void set(T v0, T v1, T v2,
                    T v3, T v4, T v5,
                    T v6, T v7, T v8)
        {
            value[0].set(v0, v1, v2);
            value[1].set(v3, v4, v5);
            value[2].set(v6, v7, v8);
        }
 
        template<typename R>
        void set(const t_Matrix3<R>& rhs)
        {
            value[0] = rhs[0];
            value[1] = rhs[1];
            value[2] = rhs[2];
        }
 
        T* data() { return value[0].data(); }
 
        const T* data() const { return value[0].data(); }
 
        t_Matrix3 operator*(const t_Matrix3& rhs) const
        {
            return t_Matrix3(
                value[0].x * rhs.value[0].x + value[0].y * rhs.value[1].x + value[0].z * rhs.value[2].x,
                value[0].x * rhs.value[0].y + value[0].y * rhs.value[1].y + value[0].z * rhs.value[2].y,
                value[0].x * rhs.value[0].z + value[0].y * rhs.value[1].z + value[0].z * rhs.value[2].z,
 
                value[1].x * rhs.value[0].x + value[1].y * rhs.value[1].x + value[1].z * rhs.value[2].x,
                value[1].x * rhs.value[0].y + value[1].y * rhs.value[1].y + value[1].z * rhs.value[2].y,
                value[1].x * rhs.value[0].z + value[1].y * rhs.value[1].z + value[1].z * rhs.value[2].z,
 
                value[2].x * rhs.value[0].x + value[2].y * rhs.value[1].x + value[2].z * rhs.value[2].x,
                value[2].x * rhs.value[0].y + value[2].y * rhs.value[1].y + value[2].z * rhs.value[2].y,
                value[2].x * rhs.value[0].z + value[2].y * rhs.value[1].z + value[2].z * rhs.value[2].z
            );
        }
 
        t_Matrix3& operator*=(const t_Matrix3& rhs)
        {
            *this = *this * rhs;
            return *this;
        }
 
        t_Matrix3 operator*(T scalar) const
        {
            return t_Matrix3(
                value[0].x * scalar, value[0].y * scalar, value[0].z * scalar,
                value[1].x * scalar, value[1].y * scalar, value[1].z * scalar,
                value[2].x * scalar, value[2].y * scalar, value[2].z * scalar
            );
        }
 
        t_Matrix3& operator*=(T scalar)
        {
            value[0] *= scalar;
            value[1] *= scalar;
            value[2] *= scalar;
            return *this;
        }
 
        t_Vector3<T> operator*(const t_Vector3<T>& v) const
        {
            return t_Vector3<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
            );
        }
 
        t_Matrix3 operator+(const t_Matrix3& rhs) const
        {
            return t_Matrix3(
                value[0].x + rhs.value[0].x, value[0].y + rhs.value[0].y, value[0].z + rhs.value[0].z,
                value[1].x + rhs.value[1].x, value[1].y + rhs.value[1].y, value[1].z + rhs.value[1].z,
                value[2].x + rhs.value[2].x, value[2].y + rhs.value[2].y, value[2].z + rhs.value[2].z
            );
        }
 
        t_Matrix3& operator+=(const t_Matrix3& rhs)
        {
            value[0] += rhs.value[0];
            value[1] += rhs.value[1];
            value[2] += rhs.value[2];
            return *this;
        }
 
        t_Matrix3 operator-(const t_Matrix3& rhs) const
        {
            return t_Matrix3(
                value[0].x - rhs.value[0].x, value[0].y - rhs.value[0].y, value[0].z - rhs.value[0].z,
                value[1].x - rhs.value[1].x, value[1].y - rhs.value[1].y, value[1].z - rhs.value[1].z,
                value[2].x - rhs.value[2].x, value[2].y - rhs.value[2].y, value[2].z - rhs.value[2].z
            );
        }
 
        t_Matrix3& operator-=(const t_Matrix3& rhs)
        {
            value[0] -= rhs.value[0];
            value[1] -= rhs.value[1];
            value[2] -= rhs.value[2];
            return *this;
        }
 
        t_Matrix3 operator/(T scalar) const
        {
            if constexpr (std::is_floating_point_v<T>)
            {
                T inv = static_cast<T>(1.0) / scalar;
                return t_Matrix3(
                    value[0].x * inv, value[0].y * inv, value[0].z * inv,
                    value[1].x * inv, value[1].y * inv, value[1].z * inv,
                    value[2].x * inv, value[2].y * inv, value[2].z * inv
                );
            }
            else
            {
                return t_Matrix3(
                    value[0].x / scalar, value[0].y / scalar, value[0].z / scalar,
                    value[1].x / scalar, value[1].y / scalar, value[1].z / scalar,
                    value[2].x / scalar, value[2].y / scalar, value[2].z / scalar
                );
            }
        }
 
        t_Matrix3& 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;
            }
            else
            {
                value[0] /= scalar;
                value[1] /= scalar;
                value[2] /= scalar;
            }
            return *this;
        }
 
        bool operator==(const t_Matrix3& rhs) const
        {
            return value[0] == rhs.value[0] &&
                   value[1] == rhs.value[1] &&
                   value[2] == rhs.value[2];
        }
 
        bool operator!=(const t_Matrix3& rhs) const
        {
            return !(*this == rhs);
        }
 
        bool operator<(const t_Matrix3& 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;
            return value[2] < rhs.value[2];
        }
 
        t_Matrix3 transpose() const
        {
            return t_Matrix3(
                value[0].x, value[1].x, value[2].x,
                value[0].y, value[1].y, value[2].y,
                value[0].z, value[1].z, value[2].z
            );
        }
 
        t_Matrix3 operator-() const
        {
            return t_Matrix3(
                -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
            );
        }
 
        explicit operator bool() const noexcept
        {
            return value[0] != t_Vector3<T>(0, 0, 0) ||
                   value[1] != t_Vector3<T>(0, 0, 0) ||
                   value[2] != t_Vector3<T>(0, 0, 0);
        }
    };
 
    using Matrix3 = t_Matrix3<float>;
 
    using Matrix3d = t_Matrix3<double>;
 
    template<typename T>
    inline std::ostream& operator<<(std::ostream& out, const t_Matrix3<T>& m)
    {
        out << m.value[0] << " " << m.value[1] << " " << m.value[2];
        return out;
    }
 
    template<typename T>
    inline std::istream& operator>>(std::istream& in, t_Matrix3<T>& m)
    {
        in >> m.value[0] >> m.value[1] >> m.value[2];
        return in;
    }
}
 
// Register Value<Matrix3> specializations in the type system
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Matrix3>)
INFINITY_TYPE(Infinity::Types::Core::Value<Infinity::Types::Math::Matrix3d>)
 
// Register Array<Matrix3> specializations in the type system
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Matrix3>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Math::Matrix3d>)