NRE_Matrix4x4.hpp

    #pragma once

    #include <Utility/String/NRE_String.hpp>
    #include <Utility/Interfaces/Stringable/NRE_Stringable.hpp>
    #include <type_traits>

    #include "../../NRE_Math.hpp"
    #include "../../NRE_Unit.hpp"

    #include "../../Curve/Bezier/4D/NRE_BezierCurve4D.hpp"

    namespace NRE {
        namespace Math {

            template<class> class Vector2D;
            template<class> class Vector3D;
            template<class> class Vector4D;
            template<class> class Segment4D;
            template<class> class Plane;
            template<class> class Matrix3x3;
            template<class> class Quaternion;

            template <class T>
            class Matrix4x4 : public Utility::Stringable<Matrix4x4<T>> {
                private:    //Fields
                    Vector4D<T> data[4];   
                public:    // Methods
                    //## Constructor ##//
                        constexpr Matrix4x4() = default;
                        template <class A, class B, class C, class D,
                                  class E, class F, class G, class H,
                                  class I, class J, class K, class L,
                                  class M, class N, class O, class P>
                        constexpr Matrix4x4(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p);
                        template <class K>
                        constexpr Matrix4x4(K value);
                        template <class K, class L, class N, class M>
                        constexpr Matrix4x4(Vector4D<K> const& l1, Vector4D<L> const& l2, Vector4D<N> const& l3, Vector4D<M> const& l4);

                    //## Copy-Constructor ##//
                        constexpr Matrix4x4(Matrix4x4 const& m) = default;

                    //## Move-Constructor ##//
                        constexpr Matrix4x4(Matrix4x4 && m) = default;

                    //## Convertor ##//
                        template <class K>
                        constexpr Matrix4x4(Matrix3x3<K> const& m);
                        template <class K>
                        constexpr Matrix4x4(Matrix4x4<K> const& m);
                        template <class K>
                        constexpr Matrix4x4(Quaternion<K> const& q);

                    //## Deconstructor ##//
                        ~Matrix4x4() = default;

                    //## Getter ##//
                        constexpr Vector4D<T> const& getL1() const;
                        constexpr Vector4D<T> const& getL2() const;
                        constexpr Vector4D<T> const& getL3() const;
                        constexpr Vector4D<T> const& getL4() const;
                        constexpr Vector4D<T> getC1() const;
                        constexpr Vector4D<T> getC2() const;
                        constexpr Vector4D<T> getC3() const;
                        constexpr Vector4D<T> getC4() const;
                        constexpr long double getDeterminant() const;

                    //## Setter ##//
                        template <class K>
                        constexpr void setL1(Vector4D<K> const& l1);
                        template <class K>
                        constexpr void setL2(Vector4D<K> const& l2);
                        template <class K>
                        constexpr void setL3(Vector4D<K> const& l3);
                        template <class K>
                        constexpr void setL4(Vector4D<K> const& l4);
                        template <class K>
                        constexpr void setC1(Vector4D<K> const& c1);
                        template <class K>
                        constexpr void setC2(Vector4D<K> const& c2);
                        template <class K>
                        constexpr void setC3(Vector4D<K> const& c3);
                        template <class K>
                        constexpr void setC4(Vector4D<K> const& c4);
                        constexpr Matrix4x4& setIdentity();

                    //## Methods ##//
                        constexpr Matrix4x4& transpose();
                        constexpr Matrix4x4& inverse();
                        template <class K>
                        constexpr Matrix4x4& translate(Vector3D<K> const& u);
                        template <class K>
                        constexpr Matrix4x4& scale(Vector3D<K> const& u);
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Matrix4x4& stretchX(K u) {
                            Matrix4x4<T> tmp = IDENTITY;
                            tmp[0][0] = static_cast <T> (u);
                            return *this *= tmp;
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Matrix4x4& stretchY(K u) {
                            Matrix4x4<T> tmp = IDENTITY;
                            tmp[1][1] = static_cast <T> (u);
                            return *this *= tmp;
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Matrix4x4& stretchZ(K u) {
                            Matrix4x4<T> tmp = IDENTITY;
                            tmp[2][2] = static_cast <T> (u);
                            return *this *= tmp;
                        }
                        template <class K>
                        constexpr Matrix4x4& rotate(Angle angle, Vector3D<K> const& axis);
                        template <class K, class L, typename = UseIfArithmetic<K>>
                        constexpr Matrix4x4& perspective(Angle fov, K ratio, Vector2D<L> const& z) {
                            setIdentity();
    
                            T f = static_cast <T> (tan(fov / 2.0));
                            data[0][0] = static_cast <T> (1.0) / (static_cast <T> (ratio) * f);
                            data[1][1] = static_cast <T> (1.0) / f;
                            data[2][2] = static_cast <T> (-(z.getY() + z.getX()) / (z.getY() - z.getX()));
                            data[2][3] = static_cast <T> (-(static_cast <L> (2.0) * z.getY() * z.getX()) / (z.getY() - z.getX()));
                            data[3][2] = -1;
                            data[3][3] = 0;
                            
                            return *this;
                        }
                        template <class K, class L, class N>
                        constexpr Matrix4x4& ortho(Vector2D<K> const& h, Vector2D<L> const& v, Vector2D<N> const& z);
                        template <class K, class L>
                        constexpr Matrix4x4& ortho2D(Vector2D<K> const& h, Vector2D<L> const& v);
                        template <class K, class L, class N>
                        constexpr Matrix4x4& lookAt(Vector3D<K> const& eye, Vector3D<L> const& center, Vector3D<N> const& up);
                        constexpr const T* value() const;

                    //## Access Operator ##//
                        constexpr Vector4D<T>& operator [](std::size_t index);
                        constexpr Vector4D<T> const& operator [](std::size_t index) const;

                    //## Assignment Operator ##//
                        constexpr Matrix4x4& operator =(Matrix4x4 const& m) = default;
                        constexpr Matrix4x4& operator =(Matrix4x4 && m) = default;
                        template <class K>
                        constexpr Matrix4x4& operator =(Matrix4x4<K> const& m);
                        template <class K>
                        constexpr Matrix4x4& operator =(Matrix4x4<K> && m);

                    //## Shortcut Operator ##//
                        template <class K>
                        constexpr Matrix4x4& operator +=(Matrix4x4<K> const& m);
                        template <class K>
                        constexpr Matrix4x4& operator -=(Matrix4x4<K> const& m);
                        template <class K>
                        constexpr Matrix4x4& operator *=(K k);
                        template <class K>
                        constexpr Matrix4x4& operator *=(Matrix4x4<K> const& m);
                        template <class K>
                        constexpr Matrix4x4& operator /=(K k);
                        template <class K>
                        constexpr Matrix4x4& operator /=(Matrix4x4<K> const& m);

                    //## Arithmetic Operator ##//
                        template <class K>
                        constexpr Matrix4x4<std::common_type_t<T, K>> operator +(Matrix4x4<K> const& m) const;
                        template <class K>
                        constexpr Matrix4x4<std::common_type_t<T, K>> operator -(Matrix4x4<K> const& m) const;
                        template <class K>
                        constexpr Matrix4x4<std::common_type_t<T, K>> operator *(K k) const;
                        template <class K>
                        constexpr Matrix4x4<std::common_type_t<T, K>> operator *(Matrix4x4<K> const& m) const;
                        template <class K>
                        constexpr Vector4D<K> operator *(Vector4D<K> const& u) const;
                        template <class K>
                        constexpr Segment4D<K> operator *(Segment4D<K> const& s) const;
                        constexpr BezierCurve4D operator *(BezierCurve4D const& c) const;
                        template <class K>
                        constexpr Matrix4x4<std::common_type_t<T, K>> operator /(K k) const;
                        template <class K>
                        constexpr Matrix4x4<std::common_type_t<T, K>> operator /(Matrix4x4<K> const& m) const;

                    //## Comparison Operator ##//
                        template <class K>
                        constexpr bool operator ==(Matrix4x4<K> const& m) const;
                        template <class K>
                        constexpr bool operator !=(Matrix4x4<K> const& m) const;

                    //## Stream Operator ##//
                        Utility::String toString() const;

                public :
                    static constexpr Matrix4x4 IDENTITY = Matrix4x4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);     
            };
        }
    }

    #include "NRE_Matrix4x4.tpp"