NRE_Matrix3x3.hpp

Go to the documentation of this file.

    #pragma once

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

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

    #include "../../Curve/Bezier/3D/NRE_BezierCurve3D.hpp"

    namespace NRE {
        namespace Math {

            template<class> class Vector2D;
            template<class> class Vector3D;
            template<class> class Segment3D;
            template<class> class Matrix4x4;

            template <class T>
            class Matrix3x3 : public Utility::Stringable<Matrix3x3<T>> {
                private:    //Fields
                    Vector3D<T> data[3];   
                public:    // Methods
                    //## Constructor ##//
                        constexpr Matrix3x3() = default;
                        template <class A, class B, class C,
                                  class D, class E, class F,
                                  class G, class H, class I>
                        constexpr Matrix3x3(A a, B b, C c, D d, E e, F f, G g, H h, I i);
                        template <class K>
                        constexpr Matrix3x3(K value);
                        template <class K, class L, class N>
                        constexpr Matrix3x3(Vector3D<K> const& l1, Vector3D<L> const& l2, Vector3D<N> const& l3);

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

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

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

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

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

                    //## Setter ##//
                        template <class K>
                        constexpr void setL1(Vector3D<K> const& l1);
                        template <class K>
                        constexpr void setL2(Vector3D<K> const& l2);
                        template <class K>
                        constexpr void setL3(Vector3D<K> const& l3);
                        template <class K>
                        constexpr void setC1(Vector3D<K> const& c1);
                        template <class K>
                        constexpr void setC2(Vector3D<K> const& c2);
                        template <class K>
                        constexpr void setC3(Vector3D<K> const& c3);
                        constexpr Matrix3x3& setIdentity();

                    //## Methods ##//
                        constexpr Matrix3x3& transpose();
                        constexpr Matrix3x3& inverse();
                        template <class K>
                        constexpr Matrix3x3& translate(Vector2D<K> const& u);
                        template <class K>
                        constexpr Matrix3x3& scale(Vector2D<K> const& u);
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Matrix3x3& stretchX(K u) {
                            Matrix3x3<T> tmp = IDENTITY;
                            tmp[0][0] = static_cast <T> (u);
                            return *this *= tmp;
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Matrix3x3& stretchY(K u) {
                            Matrix3x3<T> tmp = IDENTITY;
                            tmp[1][1] = static_cast <T> (u);
                            return *this *= tmp;
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Matrix3x3& squeezeX(K u) {
                            Matrix3x3<T> tmp = IDENTITY;
                            tmp[0][0] = static_cast <T> (1.0 / static_cast <long double> (u));
                            tmp[1][1] = static_cast <T> (u);
                            return *this *= tmp;
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Matrix3x3& squeezeY(K u) {
                            Matrix3x3<T> tmp = IDENTITY;
                            tmp[0][0] = static_cast <T> (u);
                            tmp[1][1] = static_cast <T> (1.0 / static_cast <long double> (u));
                            return *this *= tmp;
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Matrix3x3& shearX(K u) {
                            Matrix3x3<T> tmp = IDENTITY;
                            tmp[0][1] = static_cast <T> (u);
                            return *this *= tmp;
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Matrix3x3& shearY(K u) {
                            Matrix3x3<T> tmp = IDENTITY;
                            tmp[1][0] = static_cast <T> (u);
                            return *this *= tmp;
                        }
                        constexpr Matrix3x3& rotate(Angle angle);
                        constexpr const T* value() const;

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

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

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

                    //## Arithmetic Operator ##//
                        template <class K>
                        constexpr Matrix3x3<std::common_type_t<T, K>> operator +(Matrix3x3<K> const& m) const;
                        template <class K>
                        constexpr Matrix3x3<std::common_type_t<T, K>> operator -(Matrix3x3<K> const& m) const;
                        template <class K>
                        constexpr Matrix3x3<std::common_type_t<T, K>> operator *(K k) const;
                        template <class K>
                        constexpr Matrix3x3<std::common_type_t<T, K>> operator *(Matrix3x3<K> const& m) const;
                        template <class K>
                        constexpr Vector3D<K> operator *(Vector3D<K> const& u) const;
                        template <class K>
                        constexpr Segment3D<K> operator *(Segment3D<K> const& s) const;
                        constexpr BezierCurve3D operator *(BezierCurve3D const& c) const;
                        template <class K>
                        constexpr Matrix3x3<std::common_type_t<T, K>> operator /(K k) const;
                        template <class K>
                        constexpr Matrix3x3<std::common_type_t<T, K>> operator /(Matrix3x3<K> const& m) const;

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

                    //## Stream Operator ##//
                        Utility::String toString() const;
                        
                public :
                    static constexpr Matrix3x3 IDENTITY = Matrix3x3(1, 0, 0, 0, 1, 0, 0, 0, 1);     
            };
        }
    }

    #include "NRE_Matrix3x3.tpp"