matrix.hpp

#pragma once
 
#include <cassert>
#include <algorithm>
#include <utility>
#include <span>
#include <array>
#include <vector>
#include <ranges>
#include <initializer_list>
 
#ifdef __cpp_lib_mdspan
#include <mdspan>
#endif
 
#ifdef LITEFX_BUILD_WITH_GLM
#include <glm/matrix.hpp>
#endif
 
#ifdef LITEFX_BUILD_WITH_DIRECTX_MATH
#include <DirectXMath.h>
#endif
 
namespace LiteFX::Math {

    template <typename T, unsigned ROWS, unsigned COLS> requires 
        (ROWS >= 2 && COLS >= 2) && std::is_standard_layout_v<T> && std::is_trivially_copyable_v<T>
    struct Matrix final {
    public:
        static constexpr size_t mat_rows = ROWS;

        static constexpr size_t mat_cols = COLS;

        using scalar_type = T;

        using mat_type = Matrix<scalar_type, mat_rows, mat_cols>;

        template <unsigned rows, unsigned cols>
        using generic_mat_type = Matrix<scalar_type, rows, cols>;
 
    protected:
        using array_type = std::array<scalar_type, mat_rows * mat_cols>;
        array_type m_elements = { }; // NOLINT
 
    public:
        constexpr Matrix() noexcept = default;

        constexpr Matrix(T val) noexcept {
            std::fill(std::begin(m_elements), std::end(m_elements), val);
        }

        constexpr Matrix(array_type&& array) noexcept :
            m_elements(std::move(array)) 
        {
        }

        constexpr Matrix(std::initializer_list<scalar_type> elements) noexcept {
            std::ranges::move(elements, std::begin(m_elements));
        }

        template <unsigned rows, unsigned cols>
        constexpr Matrix(const Matrix<scalar_type, rows, cols>& _other) {
            for (size_t r { 0 }; r < rows && r < mat_rows; ++r)
                std::ranges::copy(_other.row(r), std::begin(m_elements) + r * mat_cols);
        }

        constexpr Matrix(Matrix&& _other) noexcept = default;

        constexpr Matrix(const Matrix& _other) = default;

        constexpr Matrix& operator=(Matrix&& _other) noexcept = default;

        constexpr Matrix& operator=(const Matrix& _other) = default;

        constexpr ~Matrix() noexcept = default;

        constexpr static mat_type identity() noexcept {
            std::array<scalar_type, mat_rows * mat_cols> data { };
 
            for (size_t i = 0; i < mat_rows && i < mat_cols; ++i)
                data[i * mat_cols + i] = 1.0f; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
 
            return mat_type(std::move(data));
        }
 
    public:
        constexpr const scalar_type* elements() const noexcept {
            return m_elements.data();
        }

        constexpr scalar_type* elements() noexcept {
            return m_elements.data();
        }

        consteval size_t size() const noexcept {
            return mat_rows * mat_cols;
        }

        constexpr auto begin() noexcept {
            return m_elements.begin();
        }

        constexpr auto end() noexcept {
            return m_elements.end();
        }

        constexpr auto cbegin() const noexcept {
            return m_elements.cbegin();
        }

        constexpr auto cend() const noexcept {
            return m_elements.cend();
        }

        constexpr scalar_type at(size_t row, size_t col) const noexcept {
            assert(row < mat_rows && col < mat_cols);
 
            return m_elements[row * mat_cols + col];
        };

        constexpr scalar_type& at(size_t row, size_t col) noexcept {
            assert(row < mat_rows && col < mat_cols);
 
            return m_elements[row * mat_cols + col];
        };

        constexpr std::span<const scalar_type> row(size_t row) const noexcept {
            assert(row < mat_rows);
 
            return std::span(m_elements.begin() + row * mat_cols, mat_cols);
        }

        constexpr std::span<scalar_type> row(size_t row) noexcept {
            assert(row < mat_rows);
 
            return std::span(m_elements.begin() + row * mat_cols, mat_cols);
        }

        constexpr std::array<scalar_type, mat_cols> column(size_t col) const noexcept {
            assert(col <= mat_cols);
 
            return m_elements | std::views::drop(col) | std::views::stride(mat_cols) | std::ranges::to<std::array<scalar_type, mat_cols>>();
        }
 
#ifdef __cpp_multidimensional_subscript
        constexpr scalar_type operator[](size_t row, size_t col) const noexcept {
            return this->at(row, col);
        }

        constexpr scalar_type& operator[](size_t row, size_t col) noexcept {
            return this->at(row, col);
        }
#endif

        constexpr scalar_type operator[](std::pair<size_t, size_t> position) const noexcept {
            return this->at(position.first, position.second);
        }

        constexpr scalar_type& operator[](std::pair<size_t, size_t> position) noexcept {
            return this->at(position.first, position.second);
        }
 
#ifdef __cpp_lib_mdspan
        constexpr operator std::mdspan<const scalar_type, std::extents<std::size_t, mat_rows, mat_cols>>() const noexcept {
            return std::mdspan<const scalar_type, std::extents<std::size_t, mat_rows, mat_cols>>(m_elements.data());
        }

        constexpr operator std::mdspan<scalar_type, std::extents<std::size_t, mat_rows, mat_cols>>() noexcept {
            return std::mdspan<scalar_type, std::extents<std::size_t, mat_rows, mat_cols>>(m_elements.data());
        }
#endif

        constexpr operator std::array<T, mat_rows * mat_cols>() const noexcept {
            return m_elements;
        }

        constexpr operator std::vector<T>() const noexcept {
            return std::vector<T>(std::begin(m_elements), std::end(m_elements));
        }

        constexpr operator std::span<const scalar_type>() const noexcept {
            return std::span(m_elements.data(), m_elements.size());
        }

        constexpr operator std::span<scalar_type>() noexcept {
            return std::span(m_elements.data(), m_elements.size());
        }

        constexpr generic_mat_type<mat_cols, mat_rows> transpose() const noexcept {
            std::array<scalar_type, mat_cols * mat_rows> data { };
 
            for (int r{ 0 }; r < mat_rows; ++r)
            {
                auto row = this->row(r);
 
                for (int c{ 0 }; c < mat_cols; ++c)
                    data[c * mat_rows + r] = row[c];
            }
 
            return generic_mat_type<mat_cols, mat_rows>(std::move(data));
        }

        consteval bool symmetric() const noexcept {
            return ROWS == COLS;
        }
 
#ifdef LITEFX_BUILD_WITH_GLM
        // NOTE: glm stores matrices in column-major order and also initializes them this way.
    public:
        constexpr Matrix(const glm::mat<mat_cols, mat_rows, scalar_type>& mat) noexcept {
            for (int r { 0 }; r < mat_rows; ++r)
                for (int c { 0 }; c < mat_cols; ++c)
                    m_elements[r * mat_cols + c] = mat[c][r]; // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        constexpr Matrix(glm::mat<mat_cols, mat_rows, scalar_type>&& mat) noexcept {
            for (size_t r { 0 }; r < mat_rows; ++r)
                for (size_t c { 0 }; c < mat_cols; ++c)
                    m_elements[r * mat_cols + c] = std::move(mat[c][r]); // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
        }

        template <unsigned rows, unsigned cols>
        constexpr operator glm::mat<cols, rows, scalar_type>() const noexcept requires (mat_rows >= rows && mat_cols >= cols) {
            std::array<scalar_type, static_cast<size_t>(cols * rows)> data;
            glm::mat<cols, rows, scalar_type> mat;
 
            for (size_t c { 0 }; c < cols; ++c)
                for (size_t r { 0 }; r < rows; ++r)
                    data[c * mat_rows + r] = this->at(r, c);
 
            std::memcpy(&mat, data.data(), data.size() * sizeof(scalar_type));
            return mat;
        }

        constexpr operator glm::mat<2, 2, scalar_type>() const noexcept requires (mat_rows >= 2 && mat_cols >= 2) {
            return glm::mat<2, 2, scalar_type>(at(0, 0), at(1, 0), at(0, 1), at(1, 1));
        }

        constexpr operator glm::mat<2, 3, scalar_type>() const noexcept requires (mat_rows >= 3 && mat_cols >= 2) {
            return glm::mat<2, 3, scalar_type>(at(0, 0), at(1, 0), at(2, 0), at(0, 1), at(1, 1), at(2, 1));
        }

        constexpr operator glm::mat<2, 4, scalar_type>() const noexcept requires (mat_rows >= 4 && mat_cols >= 2) {
            return glm::mat<2, 4, scalar_type>(at(0, 0), at(1, 0), at(2, 0), at(3, 0), at(0, 1), at(1, 1), at(2, 1), at(3, 1));
        }

        constexpr operator glm::mat<3, 2, scalar_type>() const noexcept requires (mat_rows >= 2 && mat_cols >= 3) {
            return glm::mat<3, 2, scalar_type>(at(0, 0), at(1, 0), at(0, 1), at(1, 1), at(0, 2), at(1, 2));
        }

        constexpr operator glm::mat<4, 2, scalar_type>() const noexcept requires (mat_rows >= 2 && mat_cols >= 4) {
            return glm::mat<4, 2, scalar_type>(at(0, 0), at(1, 0), at(0, 1), at(1, 1), at(0, 2), at(1, 2), at(0, 3), at(1, 3));
        }

        constexpr operator glm::mat<3, 3, scalar_type>() const noexcept requires (mat_rows >= 3 && mat_cols >= 3) {
            return glm::mat<3, 3, scalar_type>(at(0, 0), at(1, 0), at(2, 0), at(0, 1), at(1, 1), at(2, 1), at(0, 2), at(1, 2), at(2, 2));
        }

        constexpr operator glm::mat<3, 4, scalar_type>() const noexcept requires (mat_rows >= 4 && mat_cols >= 3) {
            return glm::mat<3, 4, scalar_type>(at(0, 0), at(1, 0), at(2, 0), at(3, 0), at(0, 1), at(1, 1), at(2, 1), at(3, 1), at(0, 2), at(1, 2), at(2, 2), at(3, 2));
        }

        constexpr operator glm::mat<4, 3, scalar_type>() const noexcept requires (mat_rows >= 3 && mat_cols >= 4) {
            return glm::mat<4, 3, scalar_type>(at(0, 0), at(1, 0), at(2, 0), at(0, 1), at(1, 1), at(2, 1), at(0, 2), at(1, 2), at(2, 2), at(0, 3), at(1, 3), at(2, 3));
        }

        constexpr operator glm::mat<4, 4, scalar_type>() const noexcept requires (mat_rows >= 4 && mat_cols >= 4) {
            return glm::mat<4, 4, scalar_type>(at(0, 0), at(1, 0), at(2, 0), at(3, 0), at(0, 1), at(1, 1), at(2, 1), at(3, 1), at(0, 2), at(1, 2), at(2, 2), at(3, 2), at(0, 3), at(1, 3), at(2, 3), at(3, 3));
        }
#endif // LITEFX_BUILD_WITH_GLM
 
#ifdef LITEFX_BUILD_WITH_DIRECTX_MATH
    public:
        constexpr Matrix(const DirectX::XMFLOAT3X3& mat) noexcept {
            for (int r { 0 }; r < 3; ++r)
                for (int c { 0 }; c < 3; ++c)
                    at(r, c) = mat(r, c);
        }

        constexpr Matrix(const DirectX::XMFLOAT4X3& mat) noexcept {
            for (int r { 0 }; r < 4; ++r)
                for (int c { 0 }; c < 3; ++c)
                    at(r, c) = mat(r, c);
        }

        constexpr Matrix(const DirectX::XMFLOAT3X4& mat) noexcept {
            for (int r { 0 }; r < 3; ++r)
                for (int c { 0 }; c < 4; ++c)
                    at(r, c) = mat(r, c);
        }

        constexpr Matrix(const DirectX::XMFLOAT4X4& mat) noexcept {
            for (int r { 0 }; r < 4; ++r)
                for (int c { 0 }; c < 4; ++c)
                    at(r, c) = mat(r, c);
        }

        constexpr operator DirectX::XMMATRIX() const noexcept requires ((mat_rows == 3 || mat_rows == 4) && (mat_cols == 3 || mat_cols == 4) && std::convertible_to<scalar_type, float>) {
            if constexpr (mat_rows == 3 && mat_cols == 3)
            {
                DirectX::XMFLOAT3X3 mat = static_cast<DirectX::XMFLOAT3X3>(*this);
                return DirectX::XMLoadFloat3x3(&mat);
            }
            else if constexpr (mat_rows == 3 && mat_cols == 4)
            {
                DirectX::XMFLOAT3X4 mat = static_cast<DirectX::XMFLOAT3X4>(*this);
                return DirectX::XMLoadFloat3x4(&mat);
            }
            else if constexpr (mat_rows == 4 && mat_cols == 3)
            {
                DirectX::XMFLOAT4X3 mat = static_cast<DirectX::XMFLOAT4X3>(*this);
                return DirectX::XMLoadFloat4x3(&mat);
            }
            if constexpr (mat_rows == 4 && mat_cols == 4)
            {
                DirectX::XMFLOAT4X4 mat = static_cast<DirectX::XMFLOAT4X4>(*this);
                return DirectX::XMLoadFloat4x4(&mat);
            }
 
            std::unreachable();
        }

        constexpr operator DirectX::XMFLOAT3X3() const noexcept requires (mat_rows >= 3 && mat_cols >= 3 && std::convertible_to<scalar_type, float>) {
            return DirectX::XMFLOAT3X3(at(0, 0), at(0, 1), at(0, 2), at(1, 0), at(1, 2), at(2, 0), at(2, 1), at(2, 2));
        }

        constexpr operator DirectX::XMFLOAT4X3() const noexcept requires (mat_rows >= 4 && mat_cols >= 3 && std::convertible_to<scalar_type, float>) {
            return DirectX::XMFLOAT4X3(at(0, 0), at(0, 1), at(0, 2), at(1, 0), at(1, 2), at(2, 0), at(2, 1), at(2, 2), at(3, 0), at(3, 1), at(3, 2));
        }

        constexpr operator DirectX::XMFLOAT3X4() const noexcept requires (mat_rows >= 3 && mat_cols >= 4 && std::convertible_to<scalar_type, float>) {
            return DirectX::XMFLOAT3X4(at(0, 0), at(0, 1), at(0, 2), at(0, 3), at(1, 0), at(1, 2), at(1, 3), at(2, 0), at(2, 1), at(2, 2), at(2, 3));
        }

        constexpr operator DirectX::XMFLOAT4X4() const noexcept requires (mat_rows >= 4 && mat_cols >= 4 && std::convertible_to<scalar_type, float>) {
            return DirectX::XMFLOAT4X4(at(0, 0), at(0, 1), at(0, 2), at(0, 3), at(1, 0), at(1, 2), at(1, 3), at(2, 0), at(2, 1), at(2, 2), at(2, 3), at(3, 0), at(3, 1), at(3, 2), at(3, 3));
        }
#endif // LITEFX_BUILD_WITH_DIRECTX_MATH
    };

    template<typename T> using TMatrix2   = Matrix<T, 2, 2>;

    template<typename T> using TMatrix3   = Matrix<T, 3, 3>;

    template<typename T> using TMatrix4   = Matrix<T, 4, 4>;

    template<typename T> using TMatrix3x4 = Matrix<T, 3, 4>;
 
}