NRE_Plane.hpp

Go to the documentation of this file.

     #pragma once

    #include "../Vector/3D/NRE_Vector3D.hpp"
     #include "../Vector/4D/NRE_Vector4D.hpp"
    #include <Utility/Interfaces/Stringable/NRE_Stringable.hpp>

    namespace NRE {
        namespace Math {

            enum Face {
                TOP,        
                BOTTOM,     
                LEFT,       
                RIGHT,      
                NEAR,       
                FAR,        
                FACE_NUM    
            };

            template <class T>
            class Plane : public Utility::Stringable<Plane<T>> {
                private :   //Fields
                    Vector3D<T> normal; 
                    Point3D<T> point;   
                public :   // Methods
                    //## Constructor ##//
                        constexpr Plane() = default;
                        template <class K, class L>
                        constexpr Plane(Vector4D<K> const& n, Point4D<L> const& p);
                        template <class K, class L>
                        constexpr Plane(Vector3D<K> const& n, Point3D<L> const& p);
                        template <class K, class L, class N>
                        Plane(Point4D<K> const& p1, Point4D<L> const& p2, Point4D<N> const& p3);
                        template <class K, class L, class N>
                        Plane(Point3D<K> const& p1, Point3D<L> const& p2, Point3D<N> const& p3);

                    //## Copy-Constructor ##//
                        constexpr Plane(Plane const& p) = default;

                    //## Move-Constructor ##//
                        constexpr Plane(Plane && p) = default;

                    //## Convertor ##//
                        template <class K>
                        constexpr Plane(Plane<K> const& p);

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

                    //## Getter ##//
                        constexpr Vector3D<T> const& getNormal() const;
                        constexpr Point3D<T> const& getPoint() const;

                    //## Setter ##//
                        template <class K>
                        constexpr void setNormal(Vector4D<K> const& n);
                        template <class K>
                        constexpr void setNormal(Vector3D<K> const& n);
                        template <class K>
                        constexpr void setPoint(Point4D<K> const& p);
                        template <class K>
                        constexpr void setPoint(Point3D<K> const& p);
                        template <class K, class L>
                        constexpr void setNormalAndPoint(Vector4D<K> const& n, Point4D<L> const& p);
                        template <class K, class L>
                        constexpr void setNormalAndPoint(Vector3D<K> const& n, Point3D<L> const& p);

                    //## Methods ##//
                        template <class K>
                        constexpr std::common_type_t<T, K> distance(Point4D<K> const& p) const;
                        template <class K>
                        constexpr std::common_type_t<T, K> distance(Point3D<K> const& p) const;

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

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

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

                private:   // Methods
                    template <class K, class L, class N>
                    inline void computeNormalFrom3Points(Point3D<K> const& p1, Point3D<L> const& p2, Point3D<N> const& p3);
            };
        }
    }

    #include "NRE_Plane.tpp"