added more unit tests

Author: orange-cpp

include/omath/Angles.hpp

@@ -7,12 +7,39 @@
 
 namespace omath::angles
 {
-    [[nodiscard]] constexpr float RadiansToDegrees(const float radiands)
+    template<class type>
+    requires std::is_floating_point_v<type>
+    [[nodiscard]] constexpr float RadiansToDegrees(const type& radians)
     {
-        return radiands * (180.f / std::numbers::pi_v<float>);
+        return radians * (type(180) / std::numbers::pi_v<type>);
     }
-    [[nodiscard]] constexpr float DegreesToRadians(const float 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));
+    }
+
+    template<class type>
+    requires std::is_floating_point_v<type>
+    [[nodiscard]] type HorizontalFovToVertical(const type& horFov, const type& aspect)
     {
-        return degrees * (std::numbers::pi_v<float> / 180.f);
+        const auto fovRad = DegreesToRadians(horFov);
+
+        const auto vertFov = type(2) * std::atan(std::tan(fovRad / type(2)) / aspect);
+
+        return RadiansToDegrees(vertFov);
+    }
+
+    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);
+
+        return RadiansToDegrees(horFov);
     }
 }

include/omath/collision/LineTracer.hpp

@@ -26,6 +26,7 @@ namespace omath::collision
     public:
         LineTracer() = delete;
 
+
         [[nodiscard]]
         static bool CanTraceLine(const Ray& ray, const Triangle3d& triangle);
 

include/omath/engines/opengl.hpp

@@ -22,10 +22,10 @@ namespace omath::opengl
     {
         return
         {
-            {right.x,       up.x,                 -forward.x,                    0},
-            {right.y,       up.y,                 -forward.y,                    0},
-            {right.z,       up.z,                 -forward.z,                    0},
-            {-cam_origin.x, -cam_origin.y,        -cam_origin.z,                 1},
+            {right.x,       up.x,                 -forward.x,    0},
+            {right.y,       up.y,                 -forward.y,    0},
+            {right.z,       up.z,                 -forward.z,    0},
+            {-cam_origin.x, -cam_origin.y,        -cam_origin.z, 1},
         };
     }
 

include/omath/pathfinding/NavigationMesh.hpp

@@ -12,6 +12,12 @@
 
 namespace omath::pathfinding
 {
+
+    enum Error
+    {
+        
+    };
+
     class NavigationMesh final
     {
     public:

tests/CMakeLists.txt

@@ -15,10 +15,12 @@ add_executable(unit-tests
         general/UnitTestColor.cpp
         general/UnitTestVector4.cpp
         general/UnitTestLineTrace.cpp
+        general/UnitTestAngles.cpp
 
         engines/UnitTestOpenGL.cpp
         engines/UnitTestUnityEngine.cpp
         engines/UnitTestSourceEngine.cpp
+
 )
 
 target_link_libraries(unit-tests PRIVATE gtest gtest_main omath glm)

tests/engines/UnitTestOpenGL.cpp

@@ -5,8 +5,8 @@
 #include <gtest/gtest.h>
 #include <omath/Matrix.hpp>
 #include <print>
-#include <omath/engines/opengl.hpp>
-#include <omath/engines/source.hpp>
+#include <omath/engines/OpenGL.hpp>
+#include <omath/engines/Source.hpp>
 #include <glm/glm.hpp>
 
 #include "glm/ext/matrix_clip_space.hpp"

tests/general/UnitTestAngles.cpp

@@ -0,0 +1,38 @@
+//
+// Created by Orange on 11/30/2024.
+//
+#include <gtest/gtest.h>
+#include <omath/Angles.hpp>
+
+
+TEST(UnitTestAngles, RadiansToDeg)
+{
+    constexpr float rad = 67;
+
+    EXPECT_NEAR(omath::angles::RadiansToDegrees(rad), 3838.82f, 0.01f);
+}
+
+TEST(UnitTestAngles, DegreesToRadians)
+{
+    constexpr float degree = 90;
+
+    EXPECT_NEAR(omath::angles::DegreesToRadians(degree), 1.5708f, 0.01f);
+}
+
+TEST(UnitTestAngles, HorizontalFovToVerical)
+{
+    constexpr float hFov = 90;
+    constexpr float aspectRation = 16.0f / 9.0f;
+    const auto verticalFov = omath::angles::HorizontalFovToVertical(hFov, aspectRation);
+
+    EXPECT_NEAR(verticalFov, 58.71f, 0.01f);
+}
+
+TEST(UnitTestAngles, VerticalToHorizontal)
+{
+    constexpr float vFov = 58.71;
+    constexpr float aspectRation = 16.0f / 9.0f;
+    const auto horizontalFov = omath::angles::VerticalFovToHorizontal(vFov, aspectRation);
+
+    EXPECT_NEAR(horizontalFov, 89.99f, 0.01f);
+}