NRE_Vector3D.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"

    namespace NRE {
        namespace Math {

            template<class> class Vector2D;
            template<class> class Vector4D;

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

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

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

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

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

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

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

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

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

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

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

            template <class T>
            using Point3D = Vector3D<T>;
        }
    }

    namespace std {
        template <class T, class K>
        struct common_type<NRE::Math::Vector3D<T>, NRE::Math::Vector3D<K>> {
            using type = NRE::Math::Vector3D<common_type_t<T, K>>;
        };
        template <>
        class hash<NRE::Math::Vector3D<float>> {
            public:
                size_t operator()(NRE::Math::Vector3D<float> const& p) const {
                    static constexpr size_t keep     = 21;
                    static constexpr size_t hashSize = sizeof(size_t) * 8;

                    float x = p.getX();
                    float y = p.getY();
                    float z = p.getZ();

                    size_t iX, iY, iZ;
                    memcpy(&iX, &x, sizeof(x));
                    iX <<= hashSize - keep;
                    iX &= 0xFFFFF80000000000;
                    memcpy(&iY, &y, sizeof(y));
                    iY <<= hashSize - (keep * 2);
                    iY &= 0x000007FFFFC00000;
                    memcpy(&iZ, &z, sizeof(z));
                    iZ <<= hashSize - (keep * 3);
                    iZ &= 0x00000000003FFFFE;
                    return iX + iY + iZ;
                }
        };
    }

    #include "NRE_Vector3D.tpp"