NRE_Vector2D.hpp

Go to the documentation of this file.

    #pragma once

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

    #include <cassert>

    namespace NRE {
        namespace Math {

            template<class> class Vector3D;
            template<class> class Vector4D;

            template <class T>
            class Vector2D : public Utility::Stringable<Vector2D<T>> {
                static_assert(ArithmeticCheckerV<T>); 
                private :   // Fields
                    T x = 0;    
                    T y = 0;    
                public :    // Methods
                    //## Constructor ##//
                        constexpr Vector2D() = default;
                        template <class K, class L, typename = UseIfArithmetic<K, L>>
                        constexpr Vector2D(K nX, L nY) : x(static_cast <T> (nX)), y(static_cast <T> (nY)) {
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector2D(K value) : Vector2D(value, value) {
                        }
                        constexpr Vector2D(std::initializer_list<T> list);

                    //## Copy-Constructor ##//
                        constexpr Vector2D(Vector2D const& u) = default;

                    //## Move-Constructor ##//
                        constexpr Vector2D(Vector2D && u) = default;

                    //## Convertor ##//
                        template <class K>
                        constexpr Vector2D(Vector2D<K> const& u);
                        template <class K>
                        constexpr Vector2D(Vector3D<K> const& u);
                        template <class K>
                        constexpr Vector2D(Vector4D<K> const& u);

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

                    //## Getter ##//
                        constexpr T getX() const;
                        constexpr T getY() const;
                        constexpr T getW() const;
                        constexpr T getH() const;

                    //## Setter ##//
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr void setX(K nX) {
                            x = static_cast <T> (nX);
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr void setY(K nY) {
                            y = static_cast <T> (nY);
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr void setW(K w) {
                            setX(w);
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr void setH(K h) {
                            setY(h);
                        }
                        template <class K, class L, typename = UseIfArithmetic<K, L>>
                        constexpr void setCoord(K nX, L nY) {
                            setX(nX);
                            setY(nY);
                        }
                        template <class K, class L, typename = UseIfArithmetic<K, L>>
                        constexpr void setSize(K w, L h) {
                            setX(w);
                            setY(h);
                        }

                    //## Methods ##//
                        long double norm() const;
                        constexpr T normSquared() const;
                        template <class K>
                        long double distance(Vector2D<K> const& v) const;
                        template <class K>
                        constexpr std::common_type_t<T, K> distanceSquared(Vector2D<K> const& v) const;
                        Vector2D& normalize();
                        template <class K, typename = UseIfArithmetic<K>>
                        void limit(K max) {
                            auto n = norm();
                            if (n > max) {
                                normalize();
                            }
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        Vector2D& pow(K p) {
                            setX(std::pow(static_cast <std::common_type_t<T, K>> (x), static_cast <std::common_type_t<T, K>> (p)));
                            setY(std::pow(static_cast <std::common_type_t<T, K>> (y), static_cast <std::common_type_t<T, K>> (p)));
                            return *this;
                        }
                        template <class K>
                        Vector2D& pow(Vector2D<K> const& p);
                        constexpr const T* value() const;

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

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

                    //## Shortcut Operator ##//
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector2D& operator +=(K k) {
                            setX(static_cast <std::common_type_t<T, K>> (x) + static_cast <std::common_type_t<T, K>> (k));
                            setY(static_cast <std::common_type_t<T, K>> (y) + static_cast <std::common_type_t<T, K>> (k));
                            return *this;
                        }
                        template <class K>
                        constexpr Vector2D& operator +=(Vector2D<K> const& u);
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector2D& operator -=(K k) {
                            setX(static_cast <std::common_type_t<T, K>> (x) - static_cast <std::common_type_t<T, K>> (k));
                            setY(static_cast <std::common_type_t<T, K>> (y) - static_cast <std::common_type_t<T, K>> (k));
                            return *this;
                        }
                        template <class K>
                        constexpr Vector2D& operator -=(Vector2D<K> const& u);
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector2D& operator *=(K k) {
                            setX(static_cast <std::common_type_t<T, K>> (x) * static_cast <std::common_type_t<T, K>> (k));
                            setY(static_cast <std::common_type_t<T, K>> (y) * static_cast <std::common_type_t<T, K>> (k));
                            return *this;
                        }
                        template <class K>
                        constexpr Vector2D& operator *=(Vector2D<K> const& u);
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector2D& operator /=(K k) {
                            setX(static_cast <std::common_type_t<T, K>> (x) / static_cast <std::common_type_t<T, K>> (k));
                            setY(static_cast <std::common_type_t<T, K>> (y) / static_cast <std::common_type_t<T, K>> (k));
                            return *this;
                        }
                        template <class K>
                        constexpr Vector2D& operator /=(Vector2D<K> const& u);
                        template <class K>
                        constexpr std::common_type_t<T, K> operator |=(Vector2D<K> const& u) const;

                    //## Arithmetic Operator ##//
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector2D<std::common_type_t<T, K>> operator +(K k) const {
                            return Vector2D<std::common_type_t<T, K>>(*this) += k;
                        }
                        template <class K>
                        constexpr Vector2D<std::common_type_t<T, K>> operator +(Vector2D<K> const& u) const;
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector2D<std::common_type_t<T, K>> operator -(K k) const {
                            return Vector2D<std::common_type_t<T, K>>(*this) -= k;
                        }
                        template <class K>
                        constexpr Vector2D<std::common_type_t<T, K>> operator -(Vector2D<K> const& u) const;
                        constexpr Vector2D operator -() const;
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector2D<std::common_type_t<T, K>> operator *(K k) const {
                            return Vector2D<std::common_type_t<T, K>>(*this) *= k;
                        }
                        template <class K>
                        constexpr Vector2D<std::common_type_t<T, K>> operator *(Vector2D<K> const& u) const;
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector2D<std::common_type_t<T, K>> operator /(K k) const {
                            return Vector2D<std::common_type_t<T, K>>(*this) /= k;
                        }
                        template <class K>
                        constexpr Vector2D<std::common_type_t<T, K>> operator /(Vector2D<K> const& u) const;
                        template <class K>
                        constexpr std::common_type_t<T, K> operator |(Vector2D<K> const& u) const;

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

                    //## Stream Operator ##//
                        Utility::String toString() const;
            };
    
            template <class T, class K, typename = UseIfArithmetic<K>>
            constexpr Vector2D<std::common_type_t<T, K>> operator *(K k, Vector2D<T> const& u) {
                return u * k;
            }
            template <class T>
            Vector2D<T> normalize(Vector2D<T> const& u);
            template <class T, class K, typename = UseIfArithmetic<K>>
            Vector2D<std::common_type_t<T, K>> pow(Vector2D<T> const& u, K k) {
                return Vector2D<std::common_type_t<T, K>>(u).pow(k);
            }
            template <class T, class K>
            Vector2D<std::common_type_t<T, K>> pow(Vector2D<T> const& u, Vector2D<K> const& p);
            template <class T, class K>
            constexpr Vector2D<std::common_type_t<T, K>> reflect(Vector2D<T> const& u, Vector2D<K> const& n);

            template <class T>
            using Point2D = Vector2D<T>;
        }
    }

    namespace std {
        template <class T, class K>
        struct common_type<NRE::Math::Vector2D<T>, NRE::Math::Vector2D<K>> {
            using type = NRE::Math::Vector2D<common_type_t<T, K>>;
        };
    }

    #include "NRE_Vector2D.tpp"