tb_angle.hpp

#ifndef TurtleBrains_Angle_hpp
#define TurtleBrains_Angle_hpp

#include <turtle_brains/math/tb_constants.hpp>
#include <turtle_brains/math/tb_math.hpp>

namespace TurtleBrains
{
    namespace Math
    {

        enum class AngleUnit
        {
            Degrees, 
            Radians  
        };

        template<typename Type> class AngleType
        {
        public:
            inline static AngleType Degrees(const Type angleInDegrees)
            {
                return AngleType(angleInDegrees, AngleUnit::Degrees);
            }

            inline static AngleType Radians(const Type angleInRadians)
            {
                return AngleType(angleInRadians, AngleUnit::Radians);
            }


            inline AngleType(void) :
                mAngle(0)
            {
            }


            inline explicit AngleType(const Type& angle, const AngleUnit units) :
                mAngle((AngleUnit::Radians == units) ? angle : tbMath::Convert::DegreesToRadians(angle))
            {
            }

            inline Type AsRadians(void) const { return mAngle; }

            inline Type AsDegrees(void) const { return tbMath::Convert::RadiansToDegrees(mAngle); }

            bool operator==(const AngleType& other) const
            {
                return tbMath::IsEqual(mAngle, other.mAngle);
            }

            bool operator!=(const AngleType& other) const
            {
                return !tbMath::IsEqual(mAngle, other.mAngle);
            }

            bool operator<(const AngleType& other) const
            {
                return mAngle < other.mAngle;
            }

            bool operator<=(const AngleType& other) const
            {
                return mAngle <= other.mAngle;
            }

            bool operator>(const AngleType& other) const
            {
                return mAngle > other.mAngle;
            }

            bool operator>=(const AngleType& other) const
            {
                return mAngle >= other.mAngle;
            }

            AngleType operator-() const { return Radians(-mAngle); }


            AngleType operator+(const AngleType& other) const { return Radians(mAngle + other.mAngle); }
            AngleType& operator+=(const AngleType& other) { mAngle += other.mAngle; return *this; }
            AngleType operator-(const AngleType& other) const { return Radians(mAngle - other.mAngle); }
            AngleType& operator-=(const AngleType& other) { mAngle -= other.mAngle; return *this; }

            AngleType operator*(const Type& scalar) const { return Radians(mAngle * scalar); }
            friend AngleType operator*(const Type& scalar, const AngleType& rhs) { return Radians(scalar * rhs.mAngle); }
            AngleType& operator*=(const Type& scalar) { mAngle *= scalar; return *this; }

            AngleType operator/(const Type& scalar) const { return Radians(mAngle / scalar); }
            //Left out the scalar / Angle because it doesn't seem like a useful construct.  5 / 4radians ... ???
            AngleType& operator/=(const Type& scalar) { mAngle /= scalar; return *this; }

        private:
            Type mAngle; //Stored as radians.
        };

        typedef AngleType<float> Angle;

    }; /* namespace Math */
}; /* namespace TurtleBrains */

namespace tbMath = TurtleBrains::Math;

//
// @note Visual Studio 2015 (at least) requires the literal operator to be either a 'long double' or 'const char*', this defeats the ability
//   to use the templated versions above, and thus may lose some precision - but at least we get it working for floats?
//
//template<typename Type> tbMath::AngleType<Type> operator "" _radians (Type value) { return tbMath::AngleType<Type>(value, tbMath::AngleUnit::Radians); }
//template<typename Type> tbMath::AngleType<Type> operator "" _degrees (Type value) { return tbMath::AngleType<Type>(value, tbMath::AngleUnit::Degrees); }
//

inline tbMath::Angle operator ""_radians(long double value) { return tbMath::Angle(static_cast<float>(value), tbMath::AngleUnit::Radians); }

inline tbMath::Angle operator ""_degrees(long double value) { return tbMath::Angle(static_cast<float>(value), tbMath::AngleUnit::Degrees); }


#endif /* TurtleBrains_Angle_hpp */