angle.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_MATH_ANGLE_1107121519_HPP
#define OGLPLUS_MATH_ANGLE_1107121519_HPP

#include <oglplus/config/compiler.hpp>
#include <oglplus/math/constants.hpp>

#include <cassert>
#include <type_traits>

namespace oglplus {


template <typename T>
class Angle
{
private:
    // the angle value in radians
    T _val_rad;

    struct Radians_ { };
    Angle(T val_rad, Radians_)
     : _val_rad(val_rad)
    { }

    struct Degrees_ { };
    Angle(T val_deg, Degrees_)
     : _val_rad(T(val_deg * (math::Pi() / T(180))))
    { }
public:
    Angle(void)
     : _val_rad(T(0))
    { }

#if !OGLPLUS_NO_DEFAULTED_FUNCTIONS || OGLPLUS_DOCUMENTATION_ONLY
    Angle(const Angle&) = default;

    Angle& operator = (const Angle&) = default;

    Angle(Angle&&) = default;
#endif

    template <typename U>
    Angle(const Angle<U>& other)
     : _val_rad(T(other.Value()))
    { }

    static inline Angle Radians(T val_rad)
    {
        return Angle(val_rad, Radians_());
    }

    static inline Angle Degrees(T val_deg)
    {
        return Angle(val_deg, Degrees_());
    }

    static inline Angle ArcSin(T x)
    {
        assert(-1.0f <= x && x <= 1.0f);
        return Angle(::std::asin(x), Radians_());
    }

    static inline Angle ArcCos(T x)
    {
        assert(-1.0f <= x && x <= 1.0f);
        return Angle(::std::acos(x), Radians_());
    }

    inline T Value(void) const
    {
        return _val_rad;
    }

    inline T ValueInDegrees(void) const
    {
        return _val_rad * T(180 / math::Pi());
    }

    inline T ValueInRightAngles(void) const
    {
        return _val_rad * T(2.0 / math::Pi());
    }

    inline T ValueInFullCircles(void) const
    {
        return _val_rad * T(0.5 / math::Pi());
    }

    friend bool operator == (const Angle& a, const Angle& b)
    {
        return a._val_rad == b._val_rad;
    }

    friend bool operator != (const Angle& a, const Angle& b)
    {
        return a._val_rad != b._val_rad;
    }

    friend bool operator <  (const Angle& a, const Angle& b)
    {
        return a._val_rad <  b._val_rad;
    }

    friend bool operator >  (const Angle& a, const Angle& b)
    {
        return a._val_rad >  b._val_rad;
    }

    friend bool operator <= (const Angle& a, const Angle& b)
    {
        return a._val_rad <= b._val_rad;
    }

    friend bool operator >= (const Angle& a, const Angle& b)
    {
        return a._val_rad >=  b._val_rad;
    }

#if OGLPLUS_DOCUMENTATION_ONLY
    friend Angle Negate(const Angle& angle);
#endif

    Angle Negated(void) const
    {
        return Angle(-this->_val_rad, Radians_());
    }

    friend Angle operator - (const Angle& angle)
    {
        return angle.Negated();
    }

#if OGLPLUS_DOCUMENTATION_ONLY
    friend Angle Add(const Angle& a, const Angle& b);
#endif

    static Angle Added(const Angle& a, const Angle& b)
    {
        return Angle(a._val_rad + b._val_rad, Radians_());
    }

    friend Angle operator + (const Angle& a, const Angle& b)
    {
        return Added(a, b);
    }

    Angle& operator += (const Angle& b)
    {
        *this = Add(*this, b);
        return *this;
    }

#if OGLPLUS_DOCUMENTATION_ONLY
    friend Angle Subtract(const Angle& a, const Angle& b);
#endif

    static Angle Subtracted(const Angle& a, const Angle& b)
    {
        return Angle(a._val_rad - b._val_rad, Radians_());
    }

    friend Angle operator - (const Angle& a, const Angle& b)
    {
        return Subtracted(a, b);
    }

    Angle& operator -= (const Angle& b)
    {
        *this = Subtracted(*this, b);
        return *this;
    }

#if OGLPLUS_DOCUMENTATION_ONLY
    friend Angle Multiply(const Angle& a, T mult);
#endif

    static Angle Multiplied(const Angle& a, T mult)
    {
        return Angle(a._val_rad * mult, Radians_());
    }

    friend Angle operator * (const Angle& a, T mult)
    {
        return Multiplied(a, mult);
    }

    friend Angle operator * (T mult, const Angle& a)
    {
        return Multiplied(a, mult);
    }

    Angle& operator *= (T mult)
    {
        *this = Multiplied(*this, mult);
        return *this;
    }

#if OGLPLUS_DOCUMENTATION_ONLY
    friend Angle Divide(const Angle& a, T div);
#endif

    static Angle Divided(const Angle& a, T div)
    {
        assert(div != T(0));
        return Angle(a._val_rad / div, Radians_());
    }

    friend Angle operator / (const Angle& a, T div)
    {
        return Divided(a, div);
    }

    Angle& operator /= (T div)
    {
        *this = Divided(*this, div);
        return *this;
    }

#if OGLPLUS_DOCUMENTATION_ONLY
    friend T Ratio(const Angle& a, const Angle& b);
#endif

    static T Ratio(const Angle& a, const Angle& b)
    {
        assert(b._val_rad != T(0));
        return a._val_rad / b._val_rad;
    }

    friend T operator / (const Angle& a, const Angle& b)
    {
        return Ratio(a, b);
    }

#if OGLPLUS_DOCUMENTATION_ONLY
    friend inline T Sin(const Angle& a);
#endif

    T Sin(void) const
    {
        return ::std::sin(this->_val_rad);
    }

#if OGLPLUS_DOCUMENTATION_ONLY
    friend inline T Cos(const Angle& a);
#endif

    T Cos(void) const
    {
        return ::std::cos(this->_val_rad);
    }

#if OGLPLUS_DOCUMENTATION_ONLY
    friend inline T Tan(const Angle& a);
#endif

    T Tan(void) const
    {
        return ::std::tan(this->_val_rad);
    }
};

template <typename T>
inline Angle<T> Negate(const Angle<T>& a)
{
    return a.Negated();
}

template <typename T>
inline Angle<T> Add(const Angle<T>& a, const Angle<T>& b)
{
    return Angle<T>::Added(a, b);
}

template <typename T>
inline Angle<T> Subtract(const Angle<T>& a, const Angle<T>& b)
{
    return Angle<T>::Subtracted(a, b);
}

template <typename T>
inline Angle<T> Multiply(const Angle<T>& a, T v)
{
    return Angle<T>::Multiplied(a, v);
}

template <typename T>
inline Angle<T> Divide(const Angle<T>& a, T v)
{
    return Angle<T>::Divided(a, v);
}

template <typename T>
inline T Ratio(const Angle<T>& a, const Angle<T>& b)
{
    return Angle<T>::Ratio(a, b);
}

template <typename T>
inline T Radians(const Angle<T>& a)
{
    return a.Value();
}

template <typename T>
inline T Degrees(const Angle<T>& a)
{
    return a.ValueInDegrees();
}

template <typename T>
inline T Sin(const Angle<T>& a)
{
    return a.Sin();
}

template <typename T>
inline T Cos(const Angle<T>& a)
{
    return a.Cos();
}

template <typename T>
inline T Tan(const Angle<T>& a)
{
    return a.Tan();
}

#if OGLPLUS_DOCUMENTATION_ONLY || defined(GL_FLOAT)
typedef Angle<GLfloat> Anglef;

typedef GLfloat AngleValueType;
#elif defined(AL_VERSION_1_1)
typedef ALfloat AngleValueType;
#else
typedef double AngleValueType;
#endif


inline Angle<AngleValueType> Radians(AngleValueType val_rad)
{
    return Angle<AngleValueType>::Radians(val_rad);
}


inline Angle<AngleValueType> Degrees(AngleValueType val_deg)
{
    return Angle<AngleValueType>::Degrees(val_deg);
}


inline Angle<AngleValueType> FullCircles(AngleValueType value)
{
    return Angle<AngleValueType>::Radians(
        AngleValueType(value * math::TwoPi())
    );
}

inline Angle<AngleValueType> FullCircle(void)
{
    return Angle<AngleValueType>::Radians(AngleValueType(math::TwoPi()));
}


inline Angle<AngleValueType> RightAngles(AngleValueType value)
{
    return Angle<AngleValueType>::Radians(
        AngleValueType(value * math::HalfPi())
    );
}

inline Angle<AngleValueType> RightAngle(void)
{
    return Angle<AngleValueType>::Radians(AngleValueType(math::HalfPi()));
}


inline Angle<AngleValueType> ArcSin(AngleValueType x)
{
    return Angle<AngleValueType>::ArcSin(x);
}


inline Angle<AngleValueType> ArcCos(AngleValueType x)
{
    return Angle<AngleValueType>::ArcCos(x);
}


inline Angle<AngleValueType> ArcTan(AngleValueType x)
{
    return Angle<AngleValueType>::Radians(::std::atan(x));
}


inline Angle<AngleValueType> ArcTan(AngleValueType y, AngleValueType x)
{
    return Angle<AngleValueType>::Radians(::std::atan2(y, x));
}


template <typename T>
inline T SineWave(T t)
{
    return ::std::sin(T(math::TwoPi() * t));
}


template <typename T>
inline T SineWave01(T t)
{
    return (SineWave(t)+T(1))/T(2);
}


template <typename T>
inline T CosineWave(T t)
{
    return ::std::cos(T(math::TwoPi() * t));
}


template <typename T>
inline T CosineWave01(T t)
{
    return (CosineWave(t)+T(1))/T(2);
}

} // namespace oglplus

#endif // include guard