added new class

Author: orange-cpp

SECURITY.md

@@ -2,4 +2,4 @@
 
 ## Reporting a Vulnerability
 
-Please report security issues to `orange-cpp@yandex.com`
+Please report security issues to `orange-cpp@yandex.ru`

include/omath/Angle.hpp

@@ -0,0 +1,156 @@
+//
+// Created by Orange on 11/30/2024.
+//
+
+#pragma once
+#include "omath/Angles.hpp"
+
+
+namespace omath
+{
+    enum class AngleFlags
+    {
+        Normalized = 0,
+        Clamped = 1,
+    };
+
+    template<class Type, Type min = 0, Type max = 360, AngleFlags flags = AngleFlags::Normalized>
+    requires std::is_arithmetic_v<Type>
+    class Angle
+    {
+        Type m_angle;
+    public:
+
+        constexpr explicit Angle(const Type& degrees)
+        {
+            if constexpr (flags == AngleFlags::Normalized)
+                m_angle = angles::WrapAngle(degrees, min, max);
+
+            else if constexpr (flags == AngleFlags::Clamped)
+                m_angle = std::clamp(degrees, min, max);
+            else
+            {
+                static_assert(false);
+                std::unreachable();
+            }
+        }
+
+        [[nodiscard]]
+        constexpr static Angle FromDegrees(const Type& degrees)
+        {
+            return {degrees};
+        }
+
+        [[nodiscard]]
+        constexpr static Angle FromRadians(const Type& degrees)
+        {
+            return {angles::RadiansToDegrees(degrees)};
+        }
+
+        [[nodiscard]]
+        constexpr const Type& operator*() const
+        {
+            return m_angle;
+        }
+
+        [[nodiscard]]
+        constexpr Type& operator*()
+        {
+            return m_angle;
+        }
+
+        [[nodiscard]]
+        constexpr const Type& Value() const
+        {
+            return **std::as_const(this);
+        }
+
+        [[nodiscard]]
+        constexpr Type& Value()
+        {
+            return **this;
+        }
+
+        [[nodiscard]]
+        constexpr Type AsRadians() const
+        {
+            return angles::RadiansToDegrees(m_angle);
+        }
+
+        [[nodiscard]]
+        Type Sin() const
+        {
+            return std::sin(AsRadians());
+        }
+
+        [[nodiscard]]
+        Type Cos() const
+        {
+            return std::sin(AsRadians());
+        }
+
+        [[nodiscard]]
+        Type Tan() const
+        {
+            return std::tan(AsRadians());
+        }
+
+        [[nodiscard]]
+        Type Atan() const
+        {
+            return std::atan(AsRadians());
+        }
+
+        [[nodiscard]]
+        Type Cot() const
+        {
+            return Cos() / Sin();
+        }
+
+        [[nodiscard]]
+        constexpr Angle& operator+=(const Type& other)
+        {
+            if constexpr (flags == AngleFlags::Normalized)
+                m_angle = angles::WrapAngle(m_angle + other, min, max);
+
+            else if constexpr (flags == AngleFlags::Clamped)
+                m_angle = std::clamp(m_angle + other, min, max);
+            else
+            {
+                static_assert(false);
+                std::unreachable();
+            }
+
+            return *this;
+        }
+
+        [[nodiscard]]
+        constexpr Angle& operator-=(const Type& other)
+        {
+            return operator+=(-other);
+        }
+
+        [[nodiscard]]
+        constexpr Angle& operator+(const Type& other)
+        {
+            if constexpr (flags == AngleFlags::Normalized)
+                return {angles::WrapAngle(m_angle + other, min, max)};
+
+            else if constexpr (flags == AngleFlags::Clamped)
+                return {std::clamp(m_angle + other, min, max)};
+
+            else
+                static_assert(false);
+
+            std::unreachable();
+        }
+
+        [[nodiscard]]
+        constexpr Angle& operator-(const Type& other)
+        {
+            return operator+(-other);
+        }
+
+
+    };
+}

include/omath/Angles.hpp

@@ -4,21 +4,23 @@
 
 #pragma once
 #include <numbers>
+#include <cmath>
+
 
 namespace omath::angles
 {
-    template<class type>
-    requires std::is_floating_point_v<type>
-    [[nodiscard]] constexpr float RadiansToDegrees(const type& radians)
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] constexpr float RadiansToDegrees(const Type& radians)
     {
-        return radians * (type(180) / std::numbers::pi_v<type>);
+        return radians * (Type(180) / std::numbers::pi_v<Type>);
     }
 
-    template<class type>
-    requires std::is_floating_point_v<type>
-    [[nodiscard]] constexpr float DegreesToRadians(const type& degrees)
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] constexpr float DegreesToRadians(const Type& degrees)
     {
-        return degrees * (std::numbers::pi_v<type> / type(180));
+        return degrees * (std::numbers::pi_v<Type> / Type(180));
     }
 
     template<class type>
@@ -32,14 +34,31 @@ namespace omath::angles
         return RadiansToDegrees(vertFov);
     }
 
-    template<class type>
-    requires std::is_floating_point_v<type>
-    [[nodiscard]] type VerticalFovToHorizontal(const type& vertFov, const type& aspect)
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] Type VerticalFovToHorizontal(const Type& vertFov, const Type& aspect)
     {
         const auto fovRad = DegreesToRadians(vertFov);
 
-        const auto horFov = type(2) * std::atan(std::tan(fovRad / type(2)) * aspect);
+        const auto horFov = Type(2) * std::atan(std::tan(fovRad / Type(2)) * aspect);
 
         return RadiansToDegrees(horFov);
     }
+
+    template<class Type>
+    requires std::is_arithmetic_v<Type>
+    [[nodiscard]] Type WrapAngle(const Type& angle, const Type& min, const Type& max)
+    {
+        if (angle <= max && angle >= min)
+            return angle;
+
+        const Type range = max - min;
+
+        Type wrappedAngle = std::fmod(angle - min, range);
+
+        if (wrappedAngle < 0)
+            wrappedAngle += range;
+
+        return wrappedAngle + min;
+    }
 }