NRE_Vector4D.hpp

Go to the documentation of this file.

     #pragma once

    #include <type_traits>
    #include <ostream>

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

    namespace NRE {
        namespace Math {

            template<class> class Vector2D;
            template<class> class Vector3D;

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

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

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

                    //## Convertor ##//
                        template <class K>
                        constexpr Vector4D(Vector4D<K> const& u);
                        template <class K>
                        constexpr Vector4D(Vector2D<K> const& u);
                        template <class K, class L, class N, typename = UseIfArithmetic<L, N>>
                        constexpr Vector4D(Vector2D<K> const& u, L nZ, N nW) : Vector4D(u.getX(), u.getY(), nZ, nW) {
                        }
                        template <class K>
                        constexpr Vector4D(Vector3D<K> const& u);
                        template <class K, class L, typename = UseIfArithmetic<L>>
                        constexpr Vector4D(Vector3D<K> const& u, L nW) : Vector4D(u.getX(), u.getY(), u.getZ(), nW) {
                        }

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

                    //## Getter ##//
                        constexpr T getX() const;
                        constexpr T getY() const;
                        constexpr T getZ() const;
                        constexpr T getW() const;
                        constexpr T getR() const;
                        constexpr T getG() const;
                        constexpr T getB() const;
                        constexpr T getA() 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 setZ(K nZ) {
                            z = static_cast <T> (nZ);
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr void setW(K nW) {
                            w = static_cast <T> (nW);
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr void setR(K r) {
                            setX(r);
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr void setG(K g) {
                            setY(g);
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr void setB(K b) {
                            setZ(b);
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr void setA(K a) {
                            setW(a);
                        }
                        template <class K, class L, class N, class M, typename = UseIfArithmetic<K, L, N, M>>
                        constexpr void setCoord(K nX, L nY, N nZ, M nW) {
                            setX(nX);
                            setY(nY);
                            setZ(nZ);
                            setW(nW);
                        }
                        template <class K, class L, class N, typename = UseIfArithmetic<L, N>>
                        constexpr void setCoord(Vector2D<K> const& u, L nZ, N nW) {
                            setX(u.getX());
                            setY(u.getY());
                            setZ(nZ);
                            setW(nW);
                        }
                        template <class K, class L, typename = UseIfArithmetic<L>>
                        constexpr void setCoord(Vector3D<K> const& u, L nW) {
                            setX(u.getX());
                            setY(u.getY());
                            setZ(u.getZ());
                            setW(nW);
                        }
                        template <class K, class L, class N, class M, typename = UseIfArithmetic<K, L, N, M>>
                        constexpr void setRGBA(K r, L g, N b, M a) {
                            setX(r);
                            setY(g);
                            setZ(b);
                            setW(a);
                        }
                        template <class K, class L, typename = UseIfArithmetic<L>>
                        constexpr void setRGBA(Vector3D<K> const& u, L a) {
                            setX(u.getX());
                            setY(u.getY());
                            setZ(u.getZ());
                            setW(a);
                        }

                    //## Methods ##//
                        long double norm() const;
                        constexpr T normSquared() const;
                        template <class K>
                        long double distance(Vector4D<K> const& v) const;
                        template <class K>
                        constexpr std::common_type_t<T, K> distanceSquared(Vector4D<K> const& v) const;
                        Vector4D& normalize();
                        template <class K, typename = UseIfArithmetic<K>>
                        void limit(K max) {
                            auto n = norm();
                            if (n > max) {
                                normalize();
                            }
                        }
                        template <class K, typename = UseIfArithmetic<K>>
                        Vector4D& 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)));
                            setZ(std::pow(static_cast <std::common_type_t<T, K>> (z), static_cast <std::common_type_t<T, K>> (p)));
                            setW(std::pow(static_cast <std::common_type_t<T, K>> (w), static_cast <std::common_type_t<T, K>> (p)));
                            return *this;
                        }
                        template <class K>
                        Vector4D& pow(Vector4D<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 Vector4D& operator =(Vector4D const& u) = default;
                        constexpr Vector4D& operator =(Vector4D && u) = default;
                        template <class K>
                        constexpr Vector4D& operator =(Vector4D<K> const& u);
                        template <class K>
                        constexpr Vector4D& operator =(Vector4D<K> && u);

                    //## Shortcut Operator ##//
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector4D& 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));
                            setZ(static_cast <std::common_type_t<T, K>> (z) + static_cast <std::common_type_t<T, K>> (k));
                            setW(static_cast <std::common_type_t<T, K>> (w) + static_cast <std::common_type_t<T, K>> (k));
                            return *this;
                        }
                        template <class K>
                        constexpr Vector4D& operator +=(Vector4D<K> const& u);
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector4D& 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));
                            setZ(static_cast <std::common_type_t<T, K>> (z) - static_cast <std::common_type_t<T, K>> (k));
                            setW(static_cast <std::common_type_t<T, K>> (w) - static_cast <std::common_type_t<T, K>> (k));
                            return *this;
                        }
                        template <class K>
                        constexpr Vector4D& operator -=(Vector4D<K> const& u);
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector4D& 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));
                            setZ(static_cast <std::common_type_t<T, K>> (z) * static_cast <std::common_type_t<T, K>> (k));
                            setW(static_cast <std::common_type_t<T, K>> (w) * static_cast <std::common_type_t<T, K>> (k));
                            return *this;
                        }
                        template <class K>
                        constexpr Vector4D& operator *=(Vector4D<K> const& u);
                        template <class K, typename = UseIfArithmetic<K>>
                        constexpr Vector4D& 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));
                            setZ(static_cast <std::common_type_t<T, K>> (z) / static_cast <std::common_type_t<T, K>> (k));
                            setW(static_cast <std::common_type_t<T, K>> (w) / static_cast <std::common_type_t<T, K>> (k));
                            return *this;
                        }
                        template <class K>
                        constexpr Vector4D& operator /=(Vector4D<K> const& u);
                        template <class K>
                        constexpr std::common_type_t<T, K> operator |=(Vector4D<K> const& u) const;
                        template <class K>
                        constexpr Vector4D& operator ^=(Vector4D<K> const& u);

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

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

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

            template <class T>
            using Point4D = Vector4D<T>;
        }
    }

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

    #include "NRE_Vector4D.tpp"