Angle.h

#pragma once
 
#include <Foundation/Math/Declarations.h>
 
class PL_FOUNDATION_DLL plAngle
{
public:
  PL_DECLARE_POD_TYPE();
 
  template <typename Type>
  constexpr static PL_ALWAYS_INLINE Type DegToRadMultiplier(); // [tested]
 
  template <typename Type>
  constexpr static PL_ALWAYS_INLINE Type RadToDegMultiplier(); // [tested]
 
  template <typename Type>
  constexpr static Type DegToRad(Type f); // [tested]
 
  template <typename Type>
  constexpr static Type RadToDeg(Type f); // [tested]
 
  [[nodiscard]] constexpr static plAngle MakeZero() { return plAngle(); }
 
  [[nodiscard]] constexpr static plAngle MakeFromDegree(float fDegree); // [tested]
 
  [[nodiscard]] constexpr static plAngle MakeFromRadian(float fRadian); // [tested]
 
  constexpr plAngle()
    : m_fRadian(0.0f)
  {
  } // [tested]
 
  constexpr float GetDegree() const; // [tested]
 
  constexpr float GetRadian() const; // [tested]
 
  PL_ALWAYS_INLINE void SetRadian(float fRad) { m_fRadian = fRad; };
 
  void NormalizeRange(); // [tested]
 
  plAngle GetNormalizedRange() const; // [tested]
 
  constexpr static plAngle AngleBetween(plAngle a, plAngle b); // [tested]
 
  bool IsEqualSimple(plAngle rhs, plAngle epsilon) const; // [tested]
 
  bool IsEqualNormalized(plAngle rhs, plAngle epsilon) const; // [tested]
 
  // unary operators
  constexpr plAngle operator-() const; // [tested]
 
  // arithmetic operators
  constexpr plAngle operator+(plAngle r) const; // [tested]
  constexpr plAngle operator-(plAngle r) const; // [tested]
 
  // compound assignment operators
  void operator+=(plAngle r); // [tested]
  void operator-=(plAngle r); // [tested]
 
  // comparison
  constexpr bool operator==(const plAngle& r) const; // [tested]
  constexpr bool operator!=(const plAngle& r) const; // [tested]
 
  // At least the < operator is implement to make clamping etc. work
  constexpr bool operator<(const plAngle& r) const;
  constexpr bool operator>(const plAngle& r) const;
  constexpr bool operator<=(const plAngle& r) const;
  constexpr bool operator>=(const plAngle& r) const;
 
  // Note: relational operators on angles are not really possible - is 0 degree smaller or bigger than 359 degree?
 
private:
  constexpr explicit plAngle(float fRadian)
    : m_fRadian(fRadian)
  {
  }
 
  float m_fRadian;
 
  template <typename Type>
  constexpr static Type Pi();
};
 
// Mathematical operators with float
 
constexpr plAngle operator*(plAngle a, float f); // [tested]
constexpr plAngle operator*(float f, plAngle a); // [tested]
 
constexpr plAngle operator/(plAngle a, float f); // [tested]
constexpr float operator/(plAngle a, plAngle b); // [tested]
 
#include <Foundation/Math/Implementation/Angle_inl.h>