Angle.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
#include "Math.hpp"
 
#include "CeresEngine/Concepts.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
 
#include <iosfwd>
 
namespace CeresEngine::inline Math {
 
    template<CArithmetic T> struct TRadian;
 
    template<CArithmetic T> struct TDegree {
        T raw = 0.0;
 
    public:
        constexpr TDegree() = default;
 
        constexpr TDegree(const TDegree& d) = default;
        constexpr TDegree& operator=(const TDegree& d) = default;
 
        constexpr explicit TDegree(T d) : raw(d) {}
 
        constexpr TDegree(const TRadian<T>& r) : raw(degrees(r.raw)) {} // NOLINT
        constexpr TDegree& operator=(const TRadian<T>& r) {
            raw = degrees(r.raw);
            return *this;
        }
 
        template<CArithmetic U> constexpr explicit TDegree(const TDegree<U>& deg) : raw(T(deg.raw)) {}
 
        [[nodiscard]] constexpr TDegree wrap() const {
            T newRaw = mod(raw, 360.0);
            if(newRaw < 0) {
                newRaw += 360.0;
            }
            return TDegree(newRaw);
        }
 
        constexpr const TDegree& operator+() const { return *this; }
        constexpr TDegree operator+(const TDegree& d) const { return TDegree(raw + d.raw); }
        constexpr TDegree& operator+=(const TDegree& d) {
            raw += d.raw;
            return *this;
        }
        friend constexpr TDegree operator+(T lhs, const TDegree& rhs) { return TDegree(lhs + rhs.raw); }
 
        constexpr TDegree operator-() const { return TDegree(-raw); }
        constexpr TDegree operator-(const TDegree& d) const { return TDegree(raw - d.raw); }
        constexpr TDegree& operator-=(const TDegree& d) {
            raw -= d.raw;
            return *this;
        }
        friend constexpr TDegree operator-(T lhs, const TDegree& rhs) { return TDegree(lhs - rhs.raw); }
 
        constexpr TDegree operator*(T f) const { return TDegree(raw * f); }
        constexpr TDegree& operator*=(T f) {
            raw *= f;
            return *this;
        }
        friend constexpr TDegree operator*(T lhs, const TDegree& rhs) { return TDegree(lhs * rhs.raw); }
 
        constexpr TDegree operator/(T f) const { return TDegree(raw / f); }
        constexpr TDegree& operator/=(T f) {
            raw /= f;
            return *this;
        }
        friend constexpr TDegree operator/(T lhs, const TDegree& rhs) { return TDegree(lhs / rhs.raw); }
 
        constexpr bool operator<(const TDegree& d) const { return raw < d.raw; }
        constexpr bool operator<(T d) const { return raw < d; }
 
        constexpr bool operator<=(const TDegree& d) const { return raw <= d.raw; }
        constexpr bool operator<=(T d) const { return raw <= d; }
 
        constexpr bool operator==(const TDegree& d) const { return raw == d.raw; }
        constexpr bool operator==(T d) const { return raw == d; }
 
        constexpr bool operator!=(const TDegree& d) const { return raw != d.raw; }
        constexpr bool operator!=(T d) const { return raw != d; }
 
        constexpr bool operator>=(const TDegree& d) const { return raw >= d.raw; }
        constexpr bool operator>=(T d) const { return raw >= d; }
 
        constexpr bool operator>(const TDegree& d) const { return raw > d.raw; }
        constexpr bool operator>(T d) const { return raw > d; }
    };
 
    template<CArithmetic T> std::ostream& operator<<(std::ostream& os, const TDegree<T>& deg) { return os << deg.raw << "°"; }
 
    using Degree CE_SCRIPT_EXPORT(name = "Degree<double>", external = true, plain = true)
    = TDegree<double>;
 
    using Degreef CE_SCRIPT_EXPORT(name = "Quaternion<float>", external = true, plain = true)
    = TDegree<float>;
 
    constexpr Degree operator"" _deg(const long double degree) { return Degree(double(degree)); }
 
    constexpr Degreef operator"" _degf(const long double degree) { return Degreef(float(degree)); }
 
    template<CArithmetic T> struct TRadian {
        T raw = 0.0;
 
    public:
        constexpr TRadian() = default;
 
        constexpr TRadian(const TRadian&) = default;
        constexpr TRadian& operator=(const TRadian&) = default;
 
        constexpr explicit TRadian(T r) : raw(r) {}
 
        constexpr TRadian(const TDegree<T>& d) : raw(radians(d.raw)) {} // NOLINT
        constexpr TRadian& operator=(const TDegree<T>& d) {
            raw = radians(d.raw);
            return *this;
        }
 
        template<CArithmetic U> constexpr explicit TRadian(const TRadian<U>& rad) : raw(T(rad.raw)) {}
 
        [[nodiscard]] constexpr TRadian wrap() {
            const constexpr T twoPi = glm::two_pi<T>();
            T newRaw = mod(raw, twoPi);
            if(newRaw < 0) {
                newRaw += twoPi;
            }
            return TRadian(newRaw);
        }
 
        constexpr const TRadian& operator+() const { return *this; }
        constexpr TRadian operator+(const TRadian& r) const { return TRadian(raw + r.raw); }
        constexpr TRadian& operator+=(const TRadian& r) {
            raw += r.raw;
            return *this;
        }
        friend constexpr TRadian operator+(T lhs, const TRadian& rhs) { return TRadian(lhs + rhs.raw); }
 
        constexpr TRadian operator-() const { return TRadian(-raw); }
        constexpr TRadian operator-(const TRadian& r) const { return TRadian(raw - r.raw); }
        constexpr TRadian& operator-=(const TRadian& r) {
            raw -= r.raw;
            return *this;
        }
        friend constexpr TRadian operator-(T lhs, const TRadian& rhs) { return TRadian(lhs - rhs.raw); }
 
        constexpr TRadian operator*(T f) const { return TRadian(raw * f); }
        constexpr TRadian& operator*=(T f) {
            raw *= f;
            return *this;
        }
        friend constexpr TRadian operator*(T lhs, const TRadian& rhs) { return TRadian(lhs * rhs.raw); }
 
        constexpr TRadian operator/(T f) const { return TRadian(raw / f); }
        constexpr TRadian& operator/=(T f) {
            raw /= f;
            return *this;
        }
        friend constexpr TRadian operator/(T lhs, const TRadian& rhs) { return TRadian(lhs / rhs.raw); }
 
        [[nodiscard]] constexpr bool operator<(const TRadian& d) const { return raw < d.raw; }
        [[nodiscard]] constexpr bool operator<(T d) const { return raw < d; }
 
        [[nodiscard]] constexpr bool operator<=(const TRadian& d) const { return raw <= d.raw; }
        [[nodiscard]] constexpr bool operator<=(T d) const { return raw <= d; }
 
        [[nodiscard]] constexpr bool operator==(const TRadian& d) const { return raw == d.raw; }
        [[nodiscard]] constexpr bool operator==(T d) const { return raw == d; }
 
        [[nodiscard]] constexpr bool operator!=(const TRadian& d) const { return raw != d.raw; }
        [[nodiscard]] constexpr bool operator!=(T d) const { return raw != d; }
 
        [[nodiscard]] constexpr bool operator>=(const TRadian& d) const { return raw >= d.raw; }
        [[nodiscard]] constexpr bool operator>=(T d) const { return raw >= d; }
 
        [[nodiscard]] constexpr bool operator>(const TRadian& d) const { return raw > d.raw; }
        [[nodiscard]] constexpr bool operator>(T d) const { return raw > d; }
    };
 
    template<CArithmetic T> std::ostream& operator<<(std::ostream& os, const TRadian<T>& rad) { return os << rad.raw << " rad"; }
 
    using Radian CE_SCRIPT_EXPORT(name = "Radian", external = true, plain = true)
    = TRadian<double>;
 
    using Radianf CE_SCRIPT_EXPORT(name = "Radian", external = true, plain = true)
    = TRadian<float>;
 
    constexpr Radian operator"" _rad(const long double radian) { return Radian(double(radian)); }
 
    constexpr Radianf operator"" _radf(const long double radian) { return Radianf(float(radian)); }
 
} // namespace CeresEngine::inline Math
 
template<typename T> struct std::hash<CeresEngine::Math::TDegree<T>> {
    using Type = CeresEngine::Math::TDegree<T>;
    constexpr size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.raw); }
};
 
template<typename T> struct std::hash<CeresEngine::Math::TRadian<T>> {
    using Type = CeresEngine::Math::TRadian<T>;
    constexpr size_t operator()(const Type& obj) const { return CeresEngine::hash(obj.raw); }
};
 
#define REFL_DECLARE_CE_ANGLE(T)                 \
     \
 
REFL_DECLARE_CE_ANGLE(double);
REFL_DECLARE_CE_ANGLE(float);