Merge pull request #31 from orange-cpp/u/orange-cpp/IWEngine

Added Infinity Ward Engine Support

CMakeLists.txt

@@ -9,7 +9,7 @@ option(OMATH_BUILD_TESTS "Build unit tests" OFF)
 option(OMATH_THREAT_WARNING_AS_ERROR "Set highest level of warnings and force compiler to treat them as errors" ON)
 option(OMATH_BUILD_AS_SHARED_LIBRARY "Build Omath as .so or .dll" OFF)
 option(OMATH_USE_AVX2 "Omath will use AVX2 to boost performance" ON)
-
+option(OMATH_IMGUI_INTEGRATION "Omath will define method to convert omath types to imgui types" OFF)
 
 if (OMATH_BUILD_AS_SHARED_LIBRARY)
     add_library(omath SHARED source/Vector3.cpp)
@@ -17,6 +17,14 @@ else()
     add_library(omath STATIC source/Matrix.cpp)
 endif()
 
+if (OMATH_IMGUI_INTEGRATION)
+    target_compile_definitions(omath PUBLIC OMATH_IMGUI_INTEGRATION)
+endif()
+
+if (OMATH_USE_AVX2)
+    target_compile_definitions(omath PUBLIC OMATH_USE_AVX2)
+endif()
+
 set_target_properties(omath PROPERTIES
         ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
         LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
@@ -31,9 +39,6 @@ endif()
 
 target_compile_features(omath PUBLIC cxx_std_23)
 
-if (OMATH_USE_AVX2)
-    target_compile_definitions(omath PUBLIC OMATH_USE_AVX2)
-endif()
 
 add_subdirectory(source)
 

include/omath/Angle.hpp

@@ -96,7 +96,6 @@ namespace omath
             return Cos() / Sin();
         }
 
-        [[nodiscard]]
         constexpr Angle& operator+=(const Angle& other)
         {
             if constexpr (flags == AngleFlags::Normalized)
@@ -116,7 +115,6 @@ namespace omath
         [[nodiscard]]
         constexpr std::partial_ordering operator<=>(const Angle& other) const = default;
 
-        [[nodiscard]]
         constexpr Angle& operator-=(const Angle& other)
         {
             return operator+=(-other);

include/omath/Vector2.hpp

@@ -3,13 +3,19 @@
 //
 
 #pragma once
-#include <tuple>
 #include <cmath>
+#include <tuple>
+
+#ifdef OMATH_IMGUI_INTEGRATION
+#include <imgui.h>
+#endif
+
 
 namespace omath
 {
 
-    template<class Type> requires std::is_arithmetic_v<Type>
+    template<class Type>
+        requires std::is_arithmetic_v<Type>
     class Vector2
     {
     public:
@@ -19,7 +25,9 @@ namespace omath
         // Constructors
         constexpr Vector2() = default;
 
-        constexpr Vector2(const Type& x, const Type& y) : x(x), y(y) {}
+        constexpr Vector2(const Type& x, const Type& y) : x(x), y(y)
+        {
+        }
 
         // Equality operators
         [[nodiscard]]
@@ -145,23 +153,12 @@ namespace omath
 
         constexpr Vector2& Abs()
         {
-            //FIXME: Replace with std::abs, if it will become constexprable
+            // FIXME: Replace with std::abs, if it will become constexprable
             x = x < 0 ? -x : x;
             y = y < 0 ? -y : y;
             return *this;
         }
 
-        template<class type>
-        [[nodiscard]] constexpr const type& As() const
-        {
-            return *reinterpret_cast<const type*>(this);
-        }
-        template<class type>
-        [[nodiscard]] constexpr type& As()
-        {
-            return *reinterpret_cast<type*>(this);
-        }
-
         [[nodiscard]] constexpr Vector2 operator-() const
         {
             return {-x, -y};
@@ -199,5 +196,13 @@ namespace omath
         {
             return std::make_tuple(x, y);
         }
+
+#ifdef OMATH_IMGUI_INTEGRATION
+        [[nodiscard]]
+        ImVec2 ToImVec2() const
+        {
+            return {static_cast<float>(this->x), static_cast<float>(this->y)};
+        }
+#endif
     };
-}
+} // namespace omath

include/omath/Vector3.hpp

@@ -4,13 +4,12 @@
 
 #pragma once
 
+#include "Vector2.hpp"
 #include <cstdint>
-#include <functional>
-#include "omath/Vector2.hpp"
-#include "omath/Angle.hpp"
 #include <expected>
-#include <immintrin.h>
+#include <functional>
-
+#include "omath/Angle.hpp"
+#include "omath/Vector2.hpp"
 
 namespace omath
 {

include/omath/Vector4.hpp

@@ -6,6 +6,7 @@
 #include <omath/Vector3.hpp>
 #include <algorithm>
 
+
 namespace omath
 {
     template <class Type>
@@ -154,5 +155,19 @@ namespace omath
         {
             return Vector3<Type>::Sum() + w;
         }
+
+#ifdef OMATH_IMGUI_INTEGRATION
+        [[nodiscard]]
+        ImVec4 ToImVec4() const
+        {
+            return
+            {
+                static_cast<float>(this->x),
+                static_cast<float>(this->y),
+                static_cast<float>(this->z),
+                static_cast<float>(w),
+            };
+        }
+#endif
     };
 }

include/omath/engines/iw_engine/Camera.hpp

@@ -0,0 +1,21 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+
+#pragma once
+#include "Constants.hpp"
+#include "omath/projection/Camera.hpp"
+
+namespace omath::iw_engine
+{
+    class Camera final : public projection::Camera<Mat4x4, ViewAngles>
+    {
+    public:
+        Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+               const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
+        void LookAt(const Vector3<float>& target) override;
+    protected:
+        [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
+        [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
+    };
+}

include/omath/engines/iw_engine/Constants.hpp

@@ -0,0 +1,25 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+
+#pragma once
+#include <omath/Vector3.hpp>
+#include <omath/Mat.hpp>
+#include <omath/Angle.hpp>
+#include <omath/ViewAngles.hpp>
+
+namespace omath::iw_engine
+{
+    constexpr Vector3<float> kAbsUp = {0, 0, 1};
+    constexpr Vector3<float> kAbsRight = {0, -1, 0};
+    constexpr Vector3<float> kAbsForward = {1, 0, 0};
+
+    using Mat4x4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat3x3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat1x3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
+    using PitchAngle = Angle<float, -89.f, 89.f, AngleFlags::Clamped>;
+    using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+    using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+
+    using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
+}

include/omath/engines/iw_engine/Formulas.hpp

@@ -0,0 +1,56 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+
+#pragma once
+#include "Constants.hpp"
+
+namespace omath::iw_engine
+{
+    [[nodiscard]]
+    inline Vector3<float> ForwardVector(const ViewAngles& angles)
+    {
+        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsForward);
+
+        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
+    }
+
+    [[nodiscard]]
+    inline Vector3<float> RightVector(const ViewAngles& angles)
+    {
+        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsRight);
+
+        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
+    }
+
+    [[nodiscard]]
+    inline Vector3<float> UpVector(const ViewAngles& angles)
+    {
+        const auto vec = MatRotation(angles) * MatColumnFromVector(kAbsUp);
+
+        return {vec.At(0, 0), vec.At(1, 0), vec.At(2, 0)};
+    }
+
+    [[nodiscard]] inline Mat4x4 CalcViewMatrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
+    {
+        return MatCameraView(ForwardVector(angles), RightVector(angles), UpVector(angles), cam_origin);
+    }
+
+
+    [[nodiscard]]
+    inline Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
+                                                  const float far)
+    {
+        // NOTE: Need magic number to fix fov calculation, since source inherit Quake proj matrix calculation
+        constexpr auto kMultiplyFactor = 0.75f;
+        const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f) * kMultiplyFactor;
+
+        return
+        {
+            {1.f / (aspectRatio * fovHalfTan), 0, 0, 0},
+            {0, 1.f / fovHalfTan, 0, 0},
+            {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
+            {0, 0, 1, 0},
+        };
+    }
+} // namespace omath::source

include/omath/engines/opengl_engine/Camera.hpp

@@ -5,7 +5,7 @@
 #include "Constants.hpp"
 #include "omath/projection/Camera.hpp"
 
-namespace omath::opengl
+namespace omath::opengl_engine
 {
     class Camera final : public projection::Camera<Mat4x4, ViewAngles>
     {

include/omath/engines/opengl_engine/Constants.hpp

@@ -8,7 +8,7 @@
 #include <omath/Angle.hpp>
 #include <omath/ViewAngles.hpp>
 
-namespace omath::opengl
+namespace omath::opengl_engine
 {
     constexpr Vector3<float> kAbsUp = {0, 1, 0};
     constexpr Vector3<float> kAbsRight = {1, 0, 0};

include/omath/engines/opengl_engine/Formulas.hpp

@@ -5,7 +5,7 @@
 #include "Constants.hpp"
 
 
-namespace omath::opengl
+namespace omath::opengl_engine
 {
     [[nodiscard]]
     inline Vector3<float> ForwardVector(const ViewAngles& angles)

include/omath/engines/source_engine/Camera.hpp

@@ -5,7 +5,7 @@
 #include "Constants.hpp"
 #include "omath/projection/Camera.hpp"
 
-namespace omath::source
+namespace omath::source_engine
 {
     class Camera final : public projection::Camera<Mat4x4, ViewAngles>
     {
@@ -13,6 +13,7 @@ namespace omath::source
         Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
                const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
         void LookAt(const Vector3<float>& target) override;
+    protected:
         [[nodiscard]] Mat4x4 CalcViewMatrix() const override;
         [[nodiscard]] Mat4x4 CalcProjectionMatrix() const override;
     };

include/omath/engines/source_engine/Constants.hpp

@@ -7,7 +7,8 @@
 #include <omath/Mat.hpp>
 #include <omath/Angle.hpp>
 #include <omath/ViewAngles.hpp>
-namespace omath::source
+
+namespace omath::source_engine
 {
     constexpr Vector3<float> kAbsUp = {0, 0, 1};
     constexpr Vector3<float> kAbsRight = {0, -1, 0};

include/omath/engines/source_engine/Formulas.hpp

@@ -4,7 +4,7 @@
 #pragma once
 #include "Constants.hpp"
 
-namespace omath::source
+namespace omath::source_engine
 {
     [[nodiscard]]
     inline Vector3<float> ForwardVector(const ViewAngles& angles)
@@ -40,8 +40,7 @@ namespace omath::source
     inline Mat4x4 CalcPerspectiveProjectionMatrix(const float fieldOfView, const float aspectRatio, const float near,
                                                   const float far)
     {
-        // NOTE: Needed tp make thing draw normal, since source is wierd
+        // NOTE: Need magic number to fix fov calculation, since source inherit Quake proj matrix calculation
-        // and use tricky projection matrix formula.
         constexpr auto kMultiplyFactor = 0.75f;
 
         const float fovHalfTan = std::tan(angles::DegreesToRadians(fieldOfView) / 2.f) * kMultiplyFactor;

source/engines/CMakeLists.txt

@@ -1,2 +1,3 @@
-add_subdirectory(Source)
+add_subdirectory(source_engine)
-add_subdirectory(OpenGL)
+add_subdirectory(opengl_engine)
+add_subdirectory(iw_engine)

source/engines/iw_engine/Camera.cpp

@@ -0,0 +1,34 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+#include "omath/engines/iw_engine/Camera.hpp"
+#include "omath/engines/iw_engine/Formulas.hpp"
+
+namespace omath::iw_engine
+{
+
+    Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
+                   const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, const float near, const float far) :
+        projection::Camera<Mat4x4, ViewAngles>(position, viewAngles, viewPort, fov, near, far)
+    {
+    }
+    void Camera::LookAt([[maybe_unused]] const Vector3<float>& target)
+    {
+        const float distance = m_origin.DistTo(target);
+        const auto delta = target - m_origin;
+
+
+        m_viewAngles.pitch = PitchAngle::FromRadians(std::asin(delta.z / distance));
+        m_viewAngles.yaw = -YawAngle::FromRadians(std::atan2(delta.y, delta.x));
+        m_viewAngles.roll = RollAngle::FromRadians(0.f);
+    }
+    Mat4x4 Camera::CalcViewMatrix() const
+    {
+        return iw_engine::CalcViewMatrix(m_viewAngles, m_origin);
+    }
+    Mat4x4 Camera::CalcProjectionMatrix() const
+    {
+        return CalcPerspectiveProjectionMatrix(m_fieldOfView.AsDegrees(), m_viewPort.AspectRatio(), m_nearPlaneDistance,
+                                               m_farPlaneDistance);
+    }
+} // namespace omath::openg

source/engines/opengl_engine/Camera.cpp

@@ -1,11 +1,11 @@
 //
 // Created by Orange on 12/23/2024.
 //
-#include "omath/engines/OpenGL/Camera.hpp"
+#include "omath/engines/opengl_engine/Camera.hpp"
-#include "omath/engines/OpenGL/Formulas.hpp"
+#include "omath/engines/opengl_engine/Formulas.hpp"
 
 
-namespace omath::opengl
+namespace omath::opengl_engine
 {
 
     Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
@@ -25,7 +25,7 @@ namespace omath::opengl
     }
     Mat4x4 Camera::CalcViewMatrix() const
     {
-        return opengl::CalcViewMatrix(m_viewAngles, m_origin);
+        return opengl_engine::CalcViewMatrix(m_viewAngles, m_origin);
     }
     Mat4x4 Camera::CalcProjectionMatrix() const
     {

source/engines/source_engine/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(omath PRIVATE Camera.cpp)

source/engines/source_engine/Camera.cpp

@@ -1,11 +1,11 @@
 //
 // Created by Orange on 12/4/2024.
 //
-#include "omath/engines/Source/Camera.hpp"
+#include "omath/engines/source_engine/Camera.hpp"
-#include "omath/engines/Source/Formulas.hpp"
+#include "omath/engines/source_engine/Formulas.hpp"
 
 
-namespace omath::source
+namespace omath::source_engine
 {
 
     Camera::Camera(const Vector3<float>& position, const ViewAngles& viewAngles, const projection::ViewPort& viewPort,
@@ -26,7 +26,7 @@ namespace omath::source
 
     Mat4x4 Camera::CalcViewMatrix() const
     {
-        return source::CalcViewMatrix(m_viewAngles, m_origin);
+        return source_engine::CalcViewMatrix(m_viewAngles, m_origin);
     }
 
     Mat4x4 Camera::CalcProjectionMatrix() const

source/projectile_prediction/Projectile.cpp

@@ -4,15 +4,15 @@
 
 #include "omath/projectile_prediction/Projectile.hpp"
 
-#include <omath/engines/Source/Formulas.hpp>
+#include <omath/engines/source_engine/Formulas.hpp>
 
 namespace omath::projectile_prediction
 {
     Vector3<float> Projectile::PredictPosition(const float pitch, const float yaw, const float time, const float gravity) const
     {
-        auto currentPos = m_origin + source::ForwardVector({source::PitchAngle::FromDegrees(-pitch),
+        auto currentPos = m_origin + source_engine::ForwardVector({source_engine::PitchAngle::FromDegrees(-pitch),
-                                                            source::YawAngle::FromDegrees(yaw),
+                                                            source_engine::YawAngle::FromDegrees(yaw),
-                                                            source::RollAngle::FromDegrees(0)}) *
+                                                            source_engine::RollAngle::FromDegrees(0)}) *
                                              m_launchSpeed * time;
         currentPos.z -= (gravity * m_gravityScale) * (time * time) * 0.5f;
 

tests/CMakeLists.txt

@@ -22,6 +22,7 @@ add_executable(unit-tests
         engines/UnitTestOpenGL.cpp
         engines/UnitTestUnityEngine.cpp
         engines/UnitTestSourceEngine.cpp
+        engines/UnitTestIwEngine.cpp
 
 )
 

tests/engines/UnitTestIwEngine.cpp

@@ -0,0 +1,69 @@
+//
+// Created by Vlad on 3/17/2025.
+//
+#include <gtest/gtest.h>
+#include <omath/engines/iw_engine/Camera.hpp>
+#include <omath/engines/iw_engine/Constants.hpp>
+#include <omath/engines/iw_engine/Formulas.hpp>
+
+
+TEST(UnitTestEwEngine, ForwardVector)
+{
+    const auto forward = omath::source_engine::ForwardVector({});
+
+    EXPECT_EQ(forward, omath::source_engine::kAbsForward);
+}
+
+TEST(UnitTestEwEngine, RightVector)
+{
+    const auto right = omath::source_engine::RightVector({});
+
+    EXPECT_EQ(right, omath::source_engine::kAbsRight);
+}
+
+TEST(UnitTestEwEngine, UpVector)
+{
+    const auto up = omath::source_engine::UpVector({});
+    EXPECT_EQ(up, omath::source_engine::kAbsUp);
+}
+
+TEST(UnitTestEwEngine, ProjectTargetMovedFromCamera)
+{
+    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+
+    for (float distance = 0.02f; distance < 1000.f; distance += 0.01f)
+    {
+        const auto projected = cam.WorldToScreen({distance, 0, 0});
+
+        EXPECT_TRUE(projected.has_value());
+
+        if (!projected.has_value())
+            continue;
+
+        EXPECT_NEAR(projected->x, 960, 0.00001f);
+        EXPECT_NEAR(projected->y, 540, 0.00001f);
+    }
+}
+
+TEST(UnitTestEwEngine, CameraSetAndGetFov)
+{
+    constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
+    auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
+    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+
+    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+}
+
+TEST(UnitTestEwEngine, CameraSetAndGetOrigin)
+{
+    auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
+
+    EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
+    cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
+
+    EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 50.f);
+}

tests/engines/UnitTestOpenGL.cpp

@@ -2,35 +2,35 @@
 // Created by Orange on 11/23/2024.
 //
 #include <gtest/gtest.h>
-#include <omath/engines/OpenGL/Camera.hpp>
+#include <omath/engines/opengl_engine//Camera.hpp>
-#include <omath/engines/OpenGL/Constants.hpp>
+#include <omath/engines/opengl_engine/Constants.hpp>
-#include <omath/engines/OpenGL/Formulas.hpp>
+#include <omath/engines/opengl_engine/Formulas.hpp>
 
 
 TEST(UnitTestOpenGL, ForwardVector)
 {
-    const auto forward = omath::opengl::ForwardVector({});
+    const auto forward = omath::opengl_engine::ForwardVector({});
 
-    EXPECT_EQ(forward, omath::opengl::kAbsForward);
+    EXPECT_EQ(forward, omath::opengl_engine::kAbsForward);
 }
 
 TEST(UnitTestOpenGL, RightVector)
 {
-    const auto right = omath::opengl::RightVector({});
+    const auto right = omath::opengl_engine::RightVector({});
 
-    EXPECT_EQ(right, omath::opengl::kAbsRight);
+    EXPECT_EQ(right, omath::opengl_engine::kAbsRight);
 }
 
 TEST(UnitTestOpenGL, UpVector)
 {
-    const auto up = omath::opengl::UpVector({});
+    const auto up = omath::opengl_engine::UpVector({});
-    EXPECT_EQ(up, omath::opengl::kAbsUp);
+    EXPECT_EQ(up, omath::opengl_engine::kAbsUp);
 }
 
 TEST(UnitTestOpenGL, ProjectTargetMovedFromCamera)
 {
     constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
-    auto cam = omath::opengl::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+    const auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
 
     for (float distance = -10.f; distance > -1000.f; distance -= 0.01f)
@@ -50,7 +50,7 @@ TEST(UnitTestOpenGL, ProjectTargetMovedFromCamera)
 TEST(UnitTestOpenGL, CameraSetAndGetFov)
 {
     constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
-    auto cam = omath::opengl::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+    auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
     cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
@@ -60,7 +60,7 @@ TEST(UnitTestOpenGL, CameraSetAndGetFov)
 
 TEST(UnitTestOpenGL, CameraSetAndGetOrigin)
 {
-    auto cam = omath::opengl::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
+    auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 
     EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
     cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));

tests/engines/UnitTestSourceEngine.cpp

@@ -2,35 +2,35 @@
 // Created by Orange on 11/23/2024.
 //
 #include <gtest/gtest.h>
-#include <omath/engines/Source/Camera.hpp>
+#include <omath/engines/source_engine/Camera.hpp>
-#include <omath/engines/Source/Constants.hpp>
+#include <omath/engines/source_engine/Constants.hpp>
-#include <omath/engines/Source/Formulas.hpp>
+#include <omath/engines/source_engine/Formulas.hpp>
 
 
 TEST(UnitTestSourceEngine, ForwardVector)
 {
-    const auto forward = omath::source::ForwardVector({});
+    const auto forward = omath::source_engine::ForwardVector({});
 
-    EXPECT_EQ(forward, omath::source::kAbsForward);
+    EXPECT_EQ(forward, omath::source_engine::kAbsForward);
 }
 
 TEST(UnitTestSourceEngine, RightVector)
 {
-    const auto right = omath::source::RightVector({});
+    const auto right = omath::source_engine::RightVector({});
 
-    EXPECT_EQ(right, omath::source::kAbsRight);
+    EXPECT_EQ(right, omath::source_engine::kAbsRight);
 }
 
 TEST(UnitTestSourceEngine, UpVector)
 {
-    const auto up = omath::source::UpVector({});
+    const auto up = omath::source_engine::UpVector({});
-    EXPECT_EQ(up, omath::source::kAbsUp);
+    EXPECT_EQ(up, omath::source_engine::kAbsUp);
 }
 
 TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
 {
     constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
-    auto cam = omath::source::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
 
     for (float distance = 0.02f; distance < 1000.f; distance += 0.01f)
@@ -50,7 +50,7 @@ TEST(UnitTestSourceEngine, ProjectTargetMovedFromCamera)
 TEST(UnitTestSourceEngine, CameraSetAndGetFov)
 {
     constexpr auto fov = omath::projection::FieldOfView::FromDegrees(90.f);
-    auto cam = omath::source::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+    auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     EXPECT_EQ(cam.GetFieldOfView().AsDegrees(), 90.f);
     cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));
@@ -60,7 +60,7 @@ TEST(UnitTestSourceEngine, CameraSetAndGetFov)
 
 TEST(UnitTestSourceEngine, CameraSetAndGetOrigin)
 {
-    auto cam = omath::source::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
+    auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 
     EXPECT_EQ(cam.GetOrigin(), omath::Vector3<float>{});
     cam.SetFieldOfView(omath::projection::FieldOfView::FromDegrees(50.f));

tests/general/UnitTestProjection.cpp

@@ -3,15 +3,14 @@
 //
 #include <complex>
 #include <gtest/gtest.h>
-#include <omath/Matrix.hpp>
+#include <omath/engines/source_engine/Camera.hpp>
-#include <omath/engines/Source/Camera.hpp>
 #include <omath/projection/Camera.hpp>
 #include <print>
 
 TEST(UnitTestProjection, Projection)
 {
     const auto x = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>::FromDegrees(90.f);
-    auto cam = omath::source::Camera({0, 0, 0}, omath::source::ViewAngles{}, {1920.f, 1080.f}, x, 0.01f, 1000.f);
+    auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, x, 0.01f, 1000.f);
 
     const auto projected = cam.WorldToScreen({1000, 0, 50});
     std::print("{} {} {}", projected->x, projected->y, projected->z);