added typecasting for vectors

Feauture/camera numeric template

.claude/settings.local.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(ls:*)"
-    ]
-  }
-}

.idea/editor.xml

@@ -17,7 +17,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppBoostFormatTooManyArgs/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppCStyleCast/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppCVQualifierCanNotBeAppliedToReference/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassCanBeFinal/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassCanBeFinal/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassIsIncomplete/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassNeedsConstructorBecauseOfUninitializedMember/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassNeverUsed/@EntryIndexedValue" value="WARNING" type="string" />
@@ -103,14 +103,14 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppImplicitDefaultConstructorNotAvailable/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppIncompatiblePointerConversion/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppIncompleteSwitchStatement/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppInconsistentNaming/@EntryIndexedValue" value="HINT" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppInconsistentNaming/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppIntegralToPointerConversion/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppInvalidLineContinuation/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppJoinDeclarationAndAssignment/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLambdaCaptureNeverUsed/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableMayBeConst/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableMightNotBeInitialized/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableWithNonTrivialDtorIsNeverUsed/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableWithNonTrivialDtorIsNeverUsed/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLongFloat/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppMemberFunctionMayBeConst/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppMemberFunctionMayBeStatic/@EntryIndexedValue" value="SUGGESTION" type="string" />
@@ -202,7 +202,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticDataMemberInUnnamedStruct/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticSpecifierOnAnonymousNamespaceMember/@EntryIndexedValue" value="SUGGESTION" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStringLiteralToCharPointerConversion/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateArgumentsCanBeDeduced/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterNeverUsed/@EntryIndexedValue" value="HINT" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterShadowing/@EntryIndexedValue" value="WARNING" type="string" />
@@ -216,7 +216,7 @@
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaEndRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnamedNamespaceInHeaderFile/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnsignedZeroComparison/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnusedIncludeDirective/@EntryIndexedValue" value="WARNING" type="string" />
     <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUseAlgorithmWithCount/@EntryIndexedValue" value="SUGGESTION" type="string" />

CONTRIBUTING.md

@@ -1,32 +1,36 @@
-## 🤝 Contributing to OMath or other Orange's Projects
+# Contributing
 
-### ❕ Prerequisites
+## Prerequisites
 
-- A working up-to-date OMath installation
+- C++ compiler with C++23 support (Clang 18+, GCC 14+, MSVC 19.38+)
-- C++ knowledge
+- CMake 3.25+
-- Git knowledge
+- Git
-- Ability to ask for help (Feel free to create empty pull-request or PM a maintainer
+- Familiarity with the codebase (see `INSTALL.md` for setup)
-  in [Telegram](https://t.me/orange_cpp))
 
-### ⏬ Setting up OMath
+For questions, create a draft PR or reach out via [Telegram](https://t.me/orange_cpp).
 
-Please read INSTALL.md file in repository
+## Workflow
 
-### 🔀 Pull requests and Branches
+1. [Fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo) the repository.
+2. Create a feature branch from `main`.
+3. Make your changes, ensuring tests pass.
+4. Open a [pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork) against `main`.
 
-In order to send code back to the official OMath repository, you must first create a copy of OMath on your github
+## Code Style
-account ([fork](https://help.github.com/articles/creating-a-pull-request-from-a-fork/)) and
-then [create a pull request](https://help.github.com/articles/creating-a-pull-request-from-a-fork/) back to OMath.
 
-OMath development is performed on multiple branches. Changes are then pull requested into master. By default, changes
+Follow the project `.clang-format`. Run `clang-format` before committing.
-merged into master will not roll out to stable build users unless the `stable` tag is updated.
 
-### 📜 Code-Style
+## Building
 
-The orange code-style can be found in `.clang-format`.
+Use one of the CMake presets defined in `CMakePresets.json`:
 
-### 📦 Building
+```bash
+cmake --preset <preset-name> -DOMATH_BUILD_TESTS=ON
+cmake --build --preset <preset-name>
+```
 
-OMath has already created the  `cmake-build` and `out` directories where cmake/bin files are located. By default, you
+Run `cmake --list-presets` to see available configurations.
-can build OMath by running `cmake --build cmake-build/build/windows-release --target omath -j 6` in the source
+
-directory.
+## Tests
+
+All new functionality must include unit tests. Run the test binary after building to verify nothing is broken.

benchmark/benchmark_projectile_pred.cpp

@@ -12,11 +12,11 @@ constexpr float hit_distance_tolerance = 5.f;
 
 void source_engine_projectile_prediction(benchmark::State& state)
 {
-    constexpr Target target{.m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
+    constexpr Target<float> target{.m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    constexpr Projectile projectile = {.m_origin = {3, 2, 1}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+    constexpr Projectile<float> projectile = {.m_origin = {3, 2, 1}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
 
     for ([[maybe_unused]] const auto _: state)
-        std::ignore = ProjPredEngineLegacy(400, simulation_time_step, 50, hit_distance_tolerance)
+        std::ignore = ProjPredEngineLegacy<>(400.f, simulation_time_step, 50.f, hit_distance_tolerance)
                               .maybe_calculate_aim_point(projectile, target);
 }
 

examples/example_barycentric/example_barycentric.cpp

@@ -71,18 +71,18 @@ void drawChar(char c, float x, float y, float scale, const Color& color, std::ve
         lines.push_back(x + x1 * w);
         lines.push_back(y + y1 * h);
         lines.push_back(0.0f);
-        lines.push_back(color.x);
+        lines.push_back(color.value().x);
-        lines.push_back(color.y);
+        lines.push_back(color.value().y);
-        lines.push_back(color.z);
+        lines.push_back(color.value().z);
         lines.push_back(1.0f); // size
         lines.push_back(1.0f); // isLine
 
         lines.push_back(x + x2 * w);
         lines.push_back(y + y2 * h);
         lines.push_back(0.0f);
-        lines.push_back(color.x);
+        lines.push_back(color.value().x);
-        lines.push_back(color.y);
+        lines.push_back(color.value().y);
-        lines.push_back(color.z);
+        lines.push_back(color.value().z);
         lines.push_back(1.0f); // size
         lines.push_back(1.0f); // isLine
     };

examples/example_glfw3/example_glfw3.cpp

@@ -318,22 +318,22 @@ int main()
         glfwPollEvents();
         omath::Vector3<float> move_dir;
         if (glfwGetKey(window, GLFW_KEY_W))
-            move_dir += camera.get_forward();
+            move_dir += camera.get_abs_forward();
 
         if (glfwGetKey(window, GLFW_KEY_A))
-            move_dir -= camera.get_right();
+            move_dir -= camera.get_abs_right();
 
         if (glfwGetKey(window, GLFW_KEY_S))
-            move_dir -= camera.get_forward();
+            move_dir -= camera.get_abs_forward();
 
         if (glfwGetKey(window, GLFW_KEY_D))
-            move_dir += camera.get_right();
+            move_dir += camera.get_abs_right();
 
         if (glfwGetKey(window, GLFW_KEY_SPACE))
-            move_dir += camera.get_up();
+            move_dir += camera.get_abs_up();
 
         if (glfwGetKey(window, GLFW_KEY_LEFT_CONTROL))
-            move_dir -= camera.get_up();
+            move_dir -= camera.get_abs_up();
 
 
         auto delta = glfwGetTime() - old_mouse_time;

include/omath/3d_primitives/aabb.hpp

@@ -0,0 +1,67 @@
+//
+// Created by Vladislav on 24.03.2026.
+//
+
+#pragma once
+#include "omath/linear_algebra/vector3.hpp"
+
+namespace omath::primitives
+{
+    enum class UpAxis { X, Y, Z };
+
+    template<class Type>
+    struct Aabb final
+    {
+        Vector3<Type> min;
+        Vector3<Type> max;
+
+        [[nodiscard]]
+        constexpr Vector3<Type> center() const noexcept
+        {
+            return (min + max) / static_cast<Type>(2);
+        }
+
+        [[nodiscard]]
+        constexpr Vector3<Type> extents() const noexcept
+        {
+            return (max - min) / static_cast<Type>(2);
+        }
+
+        template<UpAxis Up = UpAxis::Y>
+        [[nodiscard]]
+        constexpr Vector3<Type> top() const noexcept
+        {
+            const auto aabb_center = center();
+            if constexpr (Up == UpAxis::Z)
+                return {aabb_center.x, aabb_center.y, max.z};
+            else if constexpr (Up == UpAxis::X)
+                return {max.x, aabb_center.y, aabb_center.z};
+            else if constexpr (Up == UpAxis::Y)
+                return {aabb_center.x, max.y, aabb_center.z};
+            else
+                std::unreachable();
+        }
+
+        template<UpAxis Up = UpAxis::Y>
+        [[nodiscard]]
+        constexpr Vector3<Type> bottom() const noexcept
+        {
+            const auto aabb_center = center();
+            if constexpr (Up == UpAxis::Z)
+                return {aabb_center.x, aabb_center.y, min.z};
+            else if constexpr (Up == UpAxis::X)
+                return {min.x, aabb_center.y, aabb_center.z};
+            else if constexpr (Up == UpAxis::Y)
+                return {aabb_center.x, min.y, aabb_center.z};
+            else
+                std::unreachable();
+        }
+
+        [[nodiscard]]
+        constexpr bool is_collide(const Aabb& other) const noexcept
+        {
+            return min.x <= other.max.x && max.x >= other.min.x &&
+                min.y <= other.max.y && max.y >= other.min.y &&min.z <= other.max.z && max.z >= other.min.z;
+        }
+    };
+} // namespace omath::primitives

include/omath/algorithm/targeting.hpp

@@ -35,13 +35,8 @@ namespace omath::algorithm
             const auto current_target_angles = camera.calc_look_at_angles(get_position(*current));
             const auto best_target_angles = camera.calc_look_at_angles(get_position(*best_target));
 
-            const Vector2<float> current_angles_vec = {current_target_angles.pitch.as_degrees(),
+            const auto current_target_distance = camera_angles_vec.distance_to(current_target_angles.as_vector3());
-                                                       current_target_angles.yaw.as_degrees()};
+            const auto best_target_distance = camera_angles.as_vector3().distance_to(best_target_angles.as_vector3());
-            const Vector2<float> best_angles_vec = {best_target_angles.pitch.as_degrees(),
-                                                    best_target_angles.yaw.as_degrees()};
-
-            const auto current_target_distance = camera_angles_vec.distance_to(current_angles_vec);
-            const auto best_target_distance = camera_angles_vec.distance_to(best_angles_vec);
             if (current_target_distance < best_target_distance)
                 best_target = current;
         }

include/omath/collision/line_tracer.hpp

@@ -3,6 +3,7 @@
 //
 #pragma once
 
+#include "omath/3d_primitives/aabb.hpp"
 #include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
 
@@ -34,6 +35,7 @@ namespace omath::collision
     class LineTracer final
     {
         using TriangleType = Triangle<typename RayType::VectorType>;
+        using AABBType = primitives::Aabb<typename RayType::VectorType::ContainedType>;
 
     public:
         LineTracer() = delete;
@@ -87,6 +89,54 @@ namespace omath::collision
             return ray.start + ray_dir * t_hit;
         }
 
+        // Slab method ray-AABB intersection
+        // Returns the hit point on the AABB surface, or ray.end if no intersection
+        [[nodiscard]]
+        constexpr static auto get_ray_hit_point(const RayType& ray, const AABBType& aabb) noexcept
+        {
+            using T = typename RayType::VectorType::ContainedType;
+            const auto dir = ray.direction_vector();
+
+            auto t_min = -std::numeric_limits<T>::infinity();
+            auto t_max = std::numeric_limits<T>::infinity();
+
+            const auto process_axis = [&](const T& d, const T& origin, const T& box_min,
+                                          const T& box_max) -> bool
+            {
+                constexpr T k_epsilon = std::numeric_limits<T>::epsilon();
+                if (std::abs(d) < k_epsilon)
+                    return origin >= box_min && origin <= box_max;
+
+                const T inv = T(1) / d;
+                T t0 = (box_min - origin) * inv;
+                T t1 = (box_max - origin) * inv;
+                if (t0 > t1)
+                    std::swap(t0, t1);
+
+                t_min = std::max(t_min, t0);
+                t_max = std::min(t_max, t1);
+                return t_min <= t_max;
+            };
+
+            if (!process_axis(dir.x, ray.start.x, aabb.min.x, aabb.max.x))
+                return ray.end;
+            if (!process_axis(dir.y, ray.start.y, aabb.min.y, aabb.max.y))
+                return ray.end;
+            if (!process_axis(dir.z, ray.start.z, aabb.min.z, aabb.max.z))
+                return ray.end;
+
+            // t_hit: use entry point if in front of origin, otherwise 0 (started inside)
+            const T t_hit = std::max(T(0), t_min);
+
+            if (t_max < T(0))
+                return ray.end; // box entirely behind origin
+
+            if (!ray.infinite_length && t_hit > T(1))
+                return ray.end; // box beyond ray endpoint
+
+            return ray.start + dir * t_hit;
+        }
+
         template<class MeshType>
         [[nodiscard]]
         constexpr static auto get_ray_hit_point(const RayType& ray, const MeshType& mesh) noexcept

include/omath/engines/cry_engine/camera.hpp

@@ -9,5 +9,5 @@
 
 namespace omath::cry_engine
 {
-    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait, NDCDepthRange::ZERO_TO_ONE>;
 } // namespace omath::cry_engine

include/omath/engines/cry_engine/formulas.hpp

@@ -22,7 +22,8 @@ namespace omath::cry_engine
     Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
     [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>

include/omath/engines/cry_engine/traits/camera_trait.hpp

@@ -18,7 +18,7 @@ namespace omath::cry_engine
         static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
         [[nodiscard]]
         static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
     };
 
 } // namespace omath::cry_engine

include/omath/engines/cry_engine/traits/pred_engine_trait.hpp

@@ -12,7 +12,7 @@ namespace omath::cry_engine
     class PredEngineTrait final
     {
     public:
-        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile& projectile,
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
@@ -26,7 +26,7 @@ namespace omath::cry_engine
             return current_pos;
         }
         [[nodiscard]]
-        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target& target,
+        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
             auto predicted = target.m_origin + target.m_velocity * time;
@@ -49,7 +49,7 @@ namespace omath::cry_engine
         }
 
         [[nodiscard]]
-        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile& projectile,
+        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
         {

include/omath/engines/frostbite_engine/camera.hpp

@@ -9,5 +9,5 @@
 
 namespace omath::frostbite_engine
 {
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait, NDCDepthRange::ZERO_TO_ONE>;
-} // namespace omath::unity_engine
+} // namespace omath::frostbite_engine

include/omath/engines/frostbite_engine/formulas.hpp

@@ -22,7 +22,8 @@ namespace omath::frostbite_engine
     Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
     [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>

include/omath/engines/frostbite_engine/traits/camera_trait.hpp

@@ -18,7 +18,7 @@ namespace omath::frostbite_engine
         static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
         [[nodiscard]]
         static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
     };
 
 } // namespace omath::unreal_engine

include/omath/engines/frostbite_engine/traits/pred_engine_trait.hpp

@@ -12,7 +12,7 @@ namespace omath::frostbite_engine
     class PredEngineTrait final
     {
     public:
-        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile& projectile,
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
@@ -26,7 +26,7 @@ namespace omath::frostbite_engine
             return current_pos;
         }
         [[nodiscard]]
-        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target& target,
+        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
             auto predicted = target.m_origin + target.m_velocity * time;
@@ -49,7 +49,7 @@ namespace omath::frostbite_engine
         }
 
         [[nodiscard]]
-        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile& projectile,
+        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
         {

include/omath/engines/iw_engine/camera.hpp

@@ -9,5 +9,5 @@
 
 namespace omath::iw_engine
 {
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait, NDCDepthRange::ZERO_TO_ONE>;
 } // namespace omath::iw_engine

include/omath/engines/iw_engine/formulas.hpp

@@ -22,7 +22,8 @@ namespace omath::iw_engine
     [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
 
     [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>

include/omath/engines/iw_engine/traits/camera_trait.hpp

@@ -18,7 +18,7 @@ namespace omath::iw_engine
         static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
         [[nodiscard]]
         static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
     };
 
 } // namespace omath::iw_engine

include/omath/engines/iw_engine/traits/pred_engine_trait.hpp

@@ -13,7 +13,7 @@ namespace omath::iw_engine
     class PredEngineTrait final
     {
     public:
-        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile& projectile,
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
@@ -27,7 +27,7 @@ namespace omath::iw_engine
             return current_pos;
         }
         [[nodiscard]]
-        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target& target,
+        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
             auto predicted = target.m_origin + target.m_velocity * time;
@@ -50,7 +50,7 @@ namespace omath::iw_engine
         }
 
         [[nodiscard]]
-        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile& projectile,
+        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
         {

include/omath/engines/opengl_engine/camera.hpp

@@ -8,5 +8,5 @@
 
 namespace omath::opengl_engine
 {
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait, true>;
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait, NDCDepthRange::NEGATIVE_ONE_TO_ONE, {.inverted_forward = true}>;
 } // namespace omath::opengl_engine

include/omath/engines/opengl_engine/formulas.hpp

@@ -21,7 +21,8 @@ namespace omath::opengl_engine
     Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
     [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>

include/omath/engines/opengl_engine/traits/camera_trait.hpp

@@ -18,7 +18,7 @@ namespace omath::opengl_engine
         static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
         [[nodiscard]]
         static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
     };
 
 } // namespace omath::opengl_engine

include/omath/engines/opengl_engine/traits/pred_engine_trait.hpp

@@ -12,7 +12,7 @@ namespace omath::opengl_engine
     class PredEngineTrait final
     {
     public:
-        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile& projectile,
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
@@ -26,7 +26,7 @@ namespace omath::opengl_engine
             return current_pos;
         }
         [[nodiscard]]
-        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target& target,
+        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
             auto predicted = target.m_origin + target.m_velocity * time;
@@ -49,7 +49,7 @@ namespace omath::opengl_engine
         }
 
         [[nodiscard]]
-        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile& projectile,
+        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
         {

include/omath/engines/source_engine/camera.hpp

@@ -7,5 +7,5 @@
 #include "traits/camera_trait.hpp"
 namespace omath::source_engine
 {
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait, NDCDepthRange::ZERO_TO_ONE>;
 } // namespace omath::source_engine

include/omath/engines/source_engine/formulas.hpp

@@ -21,7 +21,8 @@ namespace omath::source_engine
     [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
 
     [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>

include/omath/engines/source_engine/traits/camera_trait.hpp

@@ -18,7 +18,7 @@ namespace omath::source_engine
         static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
         [[nodiscard]]
         static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
     };
 
 } // namespace omath::source_engine

include/omath/engines/source_engine/traits/pred_engine_trait.hpp

@@ -13,7 +13,7 @@ namespace omath::source_engine
     class PredEngineTrait final
     {
     public:
-        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile& projectile,
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
@@ -27,7 +27,7 @@ namespace omath::source_engine
             return current_pos;
         }
         [[nodiscard]]
-        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target& target,
+        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
             auto predicted = target.m_origin + target.m_velocity * time;
@@ -50,7 +50,7 @@ namespace omath::source_engine
         }
 
         [[nodiscard]]
-        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile& projectile,
+        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
         {

include/omath/engines/unity_engine/camera.hpp

@@ -9,5 +9,5 @@
 
 namespace omath::unity_engine
 {
-    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait, NDCDepthRange::ZERO_TO_ONE, {.inverted_forward = true}>;
 } // namespace omath::unity_engine

include/omath/engines/unity_engine/formulas.hpp

@@ -22,7 +22,8 @@ namespace omath::unity_engine
     Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
     [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>

include/omath/engines/unity_engine/traits/camera_trait.hpp

@@ -18,7 +18,7 @@ namespace omath::unity_engine
         static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
         [[nodiscard]]
         static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
     };
 
 } // namespace omath::unity_engine

include/omath/engines/unity_engine/traits/pred_engine_trait.hpp

@@ -12,7 +12,7 @@ namespace omath::unity_engine
     class PredEngineTrait final
     {
     public:
-        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile& projectile,
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
@@ -26,7 +26,7 @@ namespace omath::unity_engine
             return current_pos;
         }
         [[nodiscard]]
-        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target& target,
+        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
             auto predicted = target.m_origin + target.m_velocity * time;
@@ -49,7 +49,7 @@ namespace omath::unity_engine
         }
 
         [[nodiscard]]
-        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile& projectile,
+        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
         {

include/omath/engines/unreal_engine/camera.hpp

@@ -9,5 +9,5 @@
 
 namespace omath::unreal_engine
 {
-    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait, NDCDepthRange::ZERO_TO_ONE, {}, double>;
 } // namespace omath::unreal_engine

include/omath/engines/unreal_engine/constants.hpp

@@ -11,16 +11,16 @@
 
 namespace omath::unreal_engine
 {
-    constexpr Vector3<float> k_abs_up = {0, 0, 1};
+    constexpr Vector3<double> k_abs_up = {0, 0, 1};
-    constexpr Vector3<float> k_abs_right = {0, 1, 0};
+    constexpr Vector3<double> k_abs_right = {0, 1, 0};
-    constexpr Vector3<float> k_abs_forward = {1, 0, 0};
+    constexpr Vector3<double> k_abs_forward = {1, 0, 0};
 
-    using Mat4X4 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat4X4 = Mat<4, 4, double, MatStoreType::ROW_MAJOR>;
-    using Mat3X3 = Mat<4, 4, float, MatStoreType::ROW_MAJOR>;
+    using Mat3X3 = Mat<4, 4, double, MatStoreType::ROW_MAJOR>;
-    using Mat1X3 = Mat<1, 3, float, MatStoreType::ROW_MAJOR>;
+    using Mat1X3 = Mat<1, 3, double, MatStoreType::ROW_MAJOR>;
-    using PitchAngle = Angle<float, -90.f, 90.f, AngleFlags::Clamped>;
+    using PitchAngle = Angle<double, -90., 90., AngleFlags::Clamped>;
-    using YawAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+    using YawAngle = Angle<double, -180., 180., AngleFlags::Normalized>;
-    using RollAngle = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+    using RollAngle = Angle<double, -180., 180., AngleFlags::Normalized>;
 
     using ViewAngles = omath::ViewAngles<PitchAngle, YawAngle, RollAngle>;
 } // namespace omath::unreal_engine

include/omath/engines/unreal_engine/formulas.hpp

@@ -8,21 +8,22 @@
 namespace omath::unreal_engine
 {
     [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    Vector3<double> forward_vector(const ViewAngles& angles) noexcept;
 
     [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    Vector3<double> right_vector(const ViewAngles& angles) noexcept;
 
     [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+    Vector3<double> up_vector(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept;
 
     [[nodiscard]]
     Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
     [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(double field_of_view, double aspect_ratio, double near, double far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>

include/omath/engines/unreal_engine/traits/camera_trait.hpp

@@ -12,13 +12,13 @@ namespace omath::unreal_engine
     {
     public:
         [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        static ViewAngles calc_look_at_angle(const Vector3<double>& cam_origin, const Vector3<double>& look_at) noexcept;
 
         [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept;
         [[nodiscard]]
         static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             double near, double far, NDCDepthRange ndc_depth_range) noexcept;
     };
 
 } // namespace omath::unreal_engine

include/omath/engines/unreal_engine/traits/pred_engine_trait.hpp

@@ -12,67 +12,72 @@ namespace omath::unreal_engine
     class PredEngineTrait final
     {
     public:
-        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile& projectile,
+        static Vector3<double> predict_projectile_position(const projectile_prediction::Projectile<double>& projectile,
-                                                                    const float pitch, const float yaw,
+                                                           const double pitch, const double yaw,
-                                                                    const float time, const float gravity) noexcept
+                                                           const double time, const double gravity) noexcept
         {
             const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            const auto fwd_d = forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
+                                               RollAngle::from_degrees(0)});
             auto current_pos = launch_pos
-                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
+                               + Vector3<double>{fwd_d.x, fwd_d.y, fwd_d.z}
-                                                 RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;
-            current_pos.y -= (gravity * projectile.m_gravity_scale) * (time * time) * 0.5f;
+            current_pos.y -= (gravity * projectile.m_gravity_scale) * (time * time) * 0.5;
 
             return current_pos;
         }
+
         [[nodiscard]]
-        static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target& target,
+        static Vector3<double> predict_target_position(const projectile_prediction::Target<double>& target,
-                                                                const float time, const float gravity) noexcept
+                                                       const double time, const double gravity) noexcept
         {
             auto predicted = target.m_origin + target.m_velocity * time;
 
             if (target.m_is_airborne)
-                predicted.y -= gravity * (time * time) * 0.5f;
+                predicted.y -= gravity * (time * time) * 0.5;
 
             return predicted;
         }
+
         [[nodiscard]]
-        static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
+        static double calc_vector_2d_distance(const Vector3<double>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.z * delta.z);
         }
 
         [[nodiscard]]
-        constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
+        static double get_vector_height_coordinate(const Vector3<double>& vec) noexcept
         {
             return vec.y;
         }
 
         [[nodiscard]]
-        static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile& projectile,
+        static Vector3<double> calc_viewpoint_from_angles(const projectile_prediction::Projectile<double>& projectile,
-                                                         Vector3<float> predicted_target_position,
+                                                          Vector3<double> predicted_target_position,
-                                                         const std::optional<float> projectile_pitch) noexcept
+                                                          const std::optional<double> projectile_pitch) noexcept
         {
             const auto delta2d = calc_vector_2d_distance(predicted_target_position - projectile.m_origin);
             const auto height = delta2d * std::tan(angles::degrees_to_radians(projectile_pitch.value()));
 
             return {predicted_target_position.x, predicted_target_position.y, projectile.m_origin.z + height};
         }
+
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
         [[nodiscard]]
-        static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        static double calc_direct_pitch_angle(const Vector3<double>& origin, const Vector3<double>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
 
             return angles::radians_to_degrees(std::asin(direction.z));
         }
+
         [[nodiscard]]
-        static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
+        static double calc_direct_yaw_angle(const Vector3<double>& origin, const Vector3<double>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
 
             return angles::radians_to_degrees(std::atan2(direction.y, direction.x));
-        };
+        }
     };
 } // namespace omath::unreal_engine

include/omath/linear_algebra/mat.hpp

@@ -37,6 +37,12 @@ namespace omath
         COLUMN_MAJOR
     };
 
+    enum class NDCDepthRange : uint8_t
+    {
+        NEGATIVE_ONE_TO_ONE = 0, // OpenGL: [-1.0, 1.0]
+        ZERO_TO_ONE              // DirectX / Vulkan: [0.0, 1.0]
+    };
+
     template<typename M1, typename M2> concept MatTemplateEqual
             = (M1::rows == M2::rows) && (M1::columns == M2::columns)
               && std::is_same_v<typename M1::value_type, typename M2::value_type> && (M1::store_type == M2::store_type);
@@ -658,36 +664,117 @@ namespace omath
         } * mat_translation<Type, St>(-camera_origin);
     }
 
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
+             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
     [[nodiscard]]
-    Mat<4, 4, Type, St> mat_perspective_left_handed(const float field_of_view, const float aspect_ratio,
+    Mat<4, 4, Type, St> mat_perspective_left_handed(const Type field_of_view, const Type aspect_ratio,
-                                                    const float near, const float far) noexcept
+                                                    const Type near, const Type far) noexcept
     {
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+        const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2});
 
-        return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
+        if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-                {0.f, 1.f / fov_half_tan, 0.f, 0.f},
+            return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0},                Type{0},             Type{0}},
-                {0.f, 0.f, (far + near) / (far - near), -(2.f * near * far) / (far - near)},
+                    {Type{0},                                 Type{1} / fov_half_tan, Type{0},             Type{0}},
-                {0.f, 0.f, 1.f, 0.f}};
+                    {Type{0},                                 Type{0},                far / (far - near), -(near * far) / (far - near)},
+                    {Type{0},                                 Type{0},                Type{1},            Type{0}}};
+        else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0},                Type{0},                      Type{0}},
+                    {Type{0},                                 Type{1} / fov_half_tan, Type{0},                      Type{0}},
+                    {Type{0},                                 Type{0},                (far + near) / (far - near), -(Type{2} * near * far) / (far - near)},
+                    {Type{0},                                 Type{0},                Type{1},                     Type{0}}};
+        else
+            std::unreachable();
     }
 
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
+             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
     [[nodiscard]]
-    Mat<4, 4, Type, St> mat_perspective_right_handed(const float field_of_view, const float aspect_ratio,
+    Mat<4, 4, Type, St> mat_perspective_right_handed(const Type field_of_view, const Type aspect_ratio,
-                                                     const float near, const float far) noexcept
+                                                     const Type near, const Type far) noexcept
     {
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+        const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2});
 
-        return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
+        if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-                {0.f, 1.f / fov_half_tan, 0.f, 0.f},
+            return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0},                Type{0},             Type{0}},
-                {0.f, 0.f, -(far + near) / (far - near), -(2.f * near * far) / (far - near)},
+                    {Type{0},                                 Type{1} / fov_half_tan, Type{0},             Type{0}},
-                {0.f, 0.f, -1.f, 0.f}};
+                    {Type{0},                                 Type{0},                -far / (far - near), -(near * far) / (far - near)},
+                    {Type{0},                                 Type{0},                -Type{1},            Type{0}}};
+        else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0},                Type{0},                      Type{0}},
+                    {Type{0},                                 Type{1} / fov_half_tan, Type{0},                      Type{0}},
+                    {Type{0},                                 Type{0},                -(far + near) / (far - near), -(Type{2} * near * far) / (far - near)},
+                    {Type{0},                                 Type{0},                -Type{1},                     Type{0}}};
+        else
+            std::unreachable();
     }
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+
+    // Horizontal-FOV variants — use these when the engine reports FOV as
+    // horizontal (UE's FMinimalViewInfo::FOV, Quake-family fov_x, etc.).
+    // X and Y scales derived as: X = 1 / tan(hfov/2), Y = aspect / tan(hfov/2).
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
+             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
+    [[nodiscard]]
+    Mat<4, 4, Type, St> mat_perspective_left_handed_horizontal_fov(const Type horizontal_fov,
+                                                                   const Type aspect_ratio, const Type near,
+                                                                   const Type far) noexcept
+    {
+        const auto inv_tan_half_hfov = Type{1} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
+        const auto x_axis = inv_tan_half_hfov;
+        const auto y_axis = inv_tan_half_hfov * aspect_ratio;
+
+        if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
+            return {{x_axis,     Type{0},    Type{0},             Type{0}},
+                    {Type{0},    y_axis,     Type{0},             Type{0}},
+                    {Type{0},    Type{0},    far / (far - near),  -(near * far) / (far - near)},
+                    {Type{0},    Type{0},    Type{1},             Type{0}}};
+        else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return {{x_axis,  Type{0}, Type{0},                     Type{0}},
+                    {Type{0}, y_axis,  Type{0},                     Type{0}},
+                    {Type{0}, Type{0}, (far + near) / (far - near), -(2.f * near * far) / (far - near)},
+                    {Type{0}, Type{0}, Type{1},                     Type{0}}};
+        else
+            std::unreachable();
+    }
+
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
+             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
+    [[nodiscard]]
+    Mat<4, 4, Type, St> mat_perspective_right_handed_horizontal_fov(const Type horizontal_fov,
+                                                                    const Type aspect_ratio, const Type near,
+                                                                    const Type far) noexcept
+    {
+        const auto inv_tan_half_hfov = Type{1} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
+        const auto x_axis = inv_tan_half_hfov;
+        const auto y_axis = inv_tan_half_hfov * aspect_ratio;
+
+        if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
+            return {{x_axis,  Type{0}, Type{0},             Type{0}},
+                    {Type{0}, y_axis,  Type{0},             Type{0}},
+                    {Type{0}, Type{0}, -far / (far - near), -(near * far) / (far - near)},
+                    {Type{0}, Type{0}, -Type{1},            Type{0}}};
+        else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return {{x_axis,  Type{0}, Type{0},                      Type{0}},
+                    {Type{0}, y_axis,  Type{0},                      Type{0}},
+                    {Type{0}, Type{0}, -(far + near) / (far - near), -(2.f * near * far) / (far - near)},
+                    {Type{0}, Type{0}, -Type{1},                     Type{0}}};
+        else
+            std::unreachable();
+    }
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
+             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
     [[nodiscard]]
     Mat<4, 4, Type, St> mat_ortho_left_handed(const Type left, const Type right, const Type bottom, const Type top,
                                               const Type near, const Type far) noexcept
     {
+        if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
+            return
+            {
+                { static_cast<Type>(2) / (right - left), 0.f,       0.f,    -(right + left) / (right - left)},
+                { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,    -(top + bottom) / (top - bottom)},
+                { 0.f,      0.f,       static_cast<Type>(1) / (far - near), -near / (far - near)            },
+                { 0.f,      0.f,       0.f,                                 1.f                             }
+            };
+        else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
             return
             {
                 { static_cast<Type>(2) / (right - left), 0.f,       0.f,    -(right + left) / (right - left)},
@@ -695,12 +782,24 @@ namespace omath
                 { 0.f,      0.f,       static_cast<Type>(2) / (far - near), -(far + near) / (far - near)    },
                 { 0.f,      0.f,       0.f,                                 1.f                             }
             };
+        else
+            std::unreachable();
     }
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
+             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
     [[nodiscard]]
     Mat<4, 4, Type, St> mat_ortho_right_handed(const Type left, const Type right, const Type bottom, const Type top,
                                                const Type near, const Type far) noexcept
     {
+        if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
+            return
+            {
+                    { static_cast<Type>(2) / (right - left), 0.f,       0.f,     -(right + left) / (right - left)},
+                    { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,     -(top + bottom) / (top - bottom)},
+                    { 0.f,      0.f,       -static_cast<Type>(1) / (far - near), -near / (far - near)            },
+                    { 0.f,      0.f,       0.f,                                  1.f                             }
+            };
+        else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
             return
             {
                     { static_cast<Type>(2) / (right - left), 0.f,       0.f,     -(right + left) / (right - left)},
@@ -708,6 +807,8 @@ namespace omath
                     { 0.f,      0.f,       -static_cast<Type>(2) / (far - near), -(far + near) / (far - near)    },
                     { 0.f,      0.f,       0.f,                                  1.f                             }
             };
+        else
+            std::unreachable();
     }
     template<class T = float, MatStoreType St = MatStoreType::COLUMN_MAJOR>
    Mat<4, 4, T, St> mat_look_at_left_handed(const Vector3<T>& eye, const Vector3<T>& center, const Vector3<T>& up)

include/omath/linear_algebra/vector2.hpp

@@ -26,6 +26,12 @@ namespace omath
         // Constructors
         constexpr Vector2() = default;
 
+        template<class CastedType>
+        requires std::is_arithmetic_v<CastedType>
+        [[nodiscard]] constexpr explicit operator Vector2<CastedType>() const noexcept
+        {
+            return {static_cast<CastedType>(x), static_cast<CastedType>(y)};
+        }
         constexpr Vector2(const Type& x, const Type& y) noexcept: x(x), y(y)
         {
         }

include/omath/linear_algebra/vector3.hpp

@@ -30,6 +30,13 @@ namespace omath
         }
         constexpr Vector3() noexcept: Vector2<Type>() {};
 
+        template<class CastedType>
+        requires std::is_arithmetic_v<CastedType>
+        [[nodiscard]] constexpr explicit operator Vector3<CastedType>() const noexcept
+        {
+            return {static_cast<CastedType>(this->x), static_cast<CastedType>(this->y),
+                    static_cast<CastedType>(this->z)};
+        }
         [[nodiscard]] constexpr bool operator==(const Vector3& other) const noexcept
         {
             return Vector2<Type>::operator==(other) && (other.z == z);

include/omath/linear_algebra/vector4.hpp

@@ -21,6 +21,15 @@ namespace omath
         }
         constexpr Vector4() noexcept: Vector3<Type>(), w(static_cast<Type>(0)) {};
 
+
+        template<class CastedType>
+        requires std::is_arithmetic_v<CastedType>
+        [[nodiscard]] constexpr explicit operator Vector4<CastedType>() const noexcept
+        {
+            return {static_cast<CastedType>(this->x), static_cast<CastedType>(this->y),
+                    static_cast<CastedType>(this->z), static_cast<CastedType>(this->w)};
+        }
+
         [[nodiscard]]
         constexpr bool operator==(const Vector4& other) const noexcept
         {

include/omath/pathfinding/walk_bot.hpp

@@ -0,0 +1,46 @@
+//
+// Created by orange on 4/12/2026.
+//
+#pragma once
+#include "navigation_mesh.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+#include <functional>
+#include <memory>
+namespace omath::pathfinding
+{
+    enum class WalkBotStatus
+    {
+        IDLE,
+        PATHING,
+        FINISHED
+    };
+    class WalkBot
+    {
+    public:
+        WalkBot() = default;
+        explicit WalkBot(const std::shared_ptr<NavigationMesh>& mesh, float min_node_distance = 1.f);
+
+        void set_nav_mesh(const std::shared_ptr<NavigationMesh>& mesh);
+        void set_min_node_distance(float distance);
+
+        void set_target(const Vector3<float>& target);
+
+        // Clear navigation state so the bot can be re-routed without stale
+        // visited-node memory.
+        void reset();
+
+        // Call every game tick with the current bot world position.
+        void update(const Vector3<float>& bot_position);
+
+        void on_path(const std::function<void(const Vector3<float>&)>& callback);
+        void on_status(const std::function<void(WalkBotStatus)>& callback);
+
+    private:
+        std::weak_ptr<NavigationMesh> m_nav_mesh;
+        std::optional<std::function<void(const Vector3<float>&)>> m_on_next_path_node;
+        std::optional<std::function<void(WalkBotStatus)>> m_on_status_update;
+        std::optional<Vector3<float>> m_last_visited;
+        std::optional<Vector3<float>> m_target;
+        float m_min_node_distance{1.f};
+    };
+} // namespace omath::pathfinding

include/omath/projectile_prediction/proj_pred_engine.hpp

@@ -8,22 +8,24 @@
 
 namespace omath::projectile_prediction
 {
+    template<class ArithmeticType = float>
     struct AimAngles
     {
-        float pitch{};
+        ArithmeticType pitch{};
-        float yaw{};
+        ArithmeticType yaw{};
     };
 
+    template<class ArithmeticType = float>
     class ProjPredEngineInterface
     {
     public:
         [[nodiscard]]
-        virtual std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
+        virtual std::optional<Vector3<ArithmeticType>> maybe_calculate_aim_point(
-                                                                        const Target& target) const = 0;
+            const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target) const = 0;
 
         [[nodiscard]]
-        virtual std::optional<AimAngles> maybe_calculate_aim_angles(const Projectile& projectile,
+        virtual std::optional<AimAngles<ArithmeticType>> maybe_calculate_aim_angles(
-                                                                     const Target& target) const = 0;
+            const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target) const = 0;
 
         virtual ~ProjPredEngineInterface() = default;
     };

include/omath/projectile_prediction/proj_pred_engine_avx2.hpp

@@ -6,14 +6,14 @@
 
 namespace omath::projectile_prediction
 {
-    class ProjPredEngineAvx2 final : public ProjPredEngineInterface
+    class ProjPredEngineAvx2 final : public ProjPredEngineInterface<float>
     {
     public:
         [[nodiscard]] std::optional<Vector3<float>>
-        maybe_calculate_aim_point(const Projectile& projectile, const Target& target) const override;
+        maybe_calculate_aim_point(const Projectile<float>& projectile, const Target<float>& target) const override;
 
-        [[nodiscard]] std::optional<AimAngles>
+        [[nodiscard]] std::optional<AimAngles<float>>
-        maybe_calculate_aim_angles(const Projectile& projectile, const Target& target) const override;
+        maybe_calculate_aim_angles(const Projectile<float>& projectile, const Target<float>& target) const override;
 
         ProjPredEngineAvx2(float gravity_constant, float simulation_time_step, float maximum_simulation_time);
         ~ProjPredEngineAvx2() override = default;

include/omath/projectile_prediction/proj_pred_engine_legacy.hpp

@@ -13,24 +13,23 @@
 
 namespace omath::projectile_prediction
 {
-    template<class T>
+    template<class T, class ArithmeticType>
     concept PredEngineConcept =
-            requires(const Projectile& projectile, const Target& target, const Vector3<float>& vec_a,
+            requires(const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target,
-                     const Vector3<float>& vec_b,
+                     const Vector3<ArithmeticType>& vec_a, const Vector3<ArithmeticType>& vec_b,
-                     Vector3<float> v3, // by-value for calc_viewpoint_from_angles
+                     Vector3<ArithmeticType> v3,
-                     float pitch, float yaw, float time, float gravity, std::optional<float> maybe_pitch) {
+                     ArithmeticType pitch, ArithmeticType yaw, ArithmeticType time, ArithmeticType gravity,
-                // Presence + return types
+                     std::optional<ArithmeticType> maybe_pitch) {
                 {
                     T::predict_projectile_position(projectile, pitch, yaw, time, gravity)
-                } -> std::same_as<Vector3<float>>;
+                } -> std::same_as<Vector3<ArithmeticType>>;
-                { T::predict_target_position(target, time, gravity) } -> std::same_as<Vector3<float>>;
+                { T::predict_target_position(target, time, gravity) } -> std::same_as<Vector3<ArithmeticType>>;
-                { T::calc_vector_2d_distance(vec_a) } -> std::same_as<float>;
+                { T::calc_vector_2d_distance(vec_a) } -> std::same_as<ArithmeticType>;
-                { T::get_vector_height_coordinate(vec_b) } -> std::same_as<float>;
+                { T::get_vector_height_coordinate(vec_b) } -> std::same_as<ArithmeticType>;
-                { T::calc_viewpoint_from_angles(projectile, v3, maybe_pitch) } -> std::same_as<Vector3<float>>;
+                { T::calc_viewpoint_from_angles(projectile, v3, maybe_pitch) } -> std::same_as<Vector3<ArithmeticType>>;
-                { T::calc_direct_pitch_angle(vec_a, vec_b) } -> std::same_as<float>;
+                { T::calc_direct_pitch_angle(vec_a, vec_b) } -> std::same_as<ArithmeticType>;
-                { T::calc_direct_yaw_angle(vec_a, vec_b) } -> std::same_as<float>;
+                { T::calc_direct_yaw_angle(vec_a, vec_b) } -> std::same_as<ArithmeticType>;
 
-                // Enforce noexcept as in PredEngineTrait
                 requires noexcept(T::predict_projectile_position(projectile, pitch, yaw, time, gravity));
                 requires noexcept(T::predict_target_position(target, time, gravity));
                 requires noexcept(T::calc_vector_2d_distance(vec_a));
@@ -39,21 +38,24 @@ namespace omath::projectile_prediction
                 requires noexcept(T::calc_direct_pitch_angle(vec_a, vec_b));
                 requires noexcept(T::calc_direct_yaw_angle(vec_a, vec_b));
             };
-    template<class EngineTrait = source_engine::PredEngineTrait>
+
-    requires PredEngineConcept<EngineTrait>
+    template<class EngineTrait = source_engine::PredEngineTrait, class ArithmeticType = float>
-    class ProjPredEngineLegacy final : public ProjPredEngineInterface
+    requires PredEngineConcept<EngineTrait, ArithmeticType>
+    class ProjPredEngineLegacy final : public ProjPredEngineInterface<ArithmeticType>
     {
     public:
-        explicit ProjPredEngineLegacy(const float gravity_constant, const float simulation_time_step,
+        explicit ProjPredEngineLegacy(const ArithmeticType gravity_constant,
-                                      const float maximum_simulation_time, const float distance_tolerance)
+                                      const ArithmeticType simulation_time_step,
+                                      const ArithmeticType maximum_simulation_time,
+                                      const ArithmeticType distance_tolerance)
             : m_gravity_constant(gravity_constant), m_simulation_time_step(simulation_time_step),
               m_maximum_simulation_time(maximum_simulation_time), m_distance_tolerance(distance_tolerance)
         {
         }
 
         [[nodiscard]]
-        std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
+        std::optional<Vector3<ArithmeticType>> maybe_calculate_aim_point(
-                                                                const Target& target) const override
+            const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target) const override
         {
             const auto solution = find_solution(projectile, target);
             if (!solution)
@@ -64,28 +66,31 @@ namespace omath::projectile_prediction
         }
 
         [[nodiscard]]
-        std::optional<AimAngles> maybe_calculate_aim_angles(const Projectile& projectile,
+        std::optional<AimAngles<ArithmeticType>> maybe_calculate_aim_angles(
-                                                             const Target& target) const override
+            const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target) const override
         {
             const auto solution = find_solution(projectile, target);
             if (!solution)
                 return std::nullopt;
 
-            const auto yaw = EngineTrait::calc_direct_yaw_angle(projectile.m_origin + projectile.m_launch_offset, solution->predicted_target_position);
+            const auto yaw = EngineTrait::calc_direct_yaw_angle(
-            return AimAngles{solution->pitch, yaw};
+                projectile.m_origin + projectile.m_launch_offset, solution->predicted_target_position);
+            return AimAngles<ArithmeticType>{solution->pitch, yaw};
         }
 
     private:
         struct Solution
         {
-            Vector3<float> predicted_target_position;
+            Vector3<ArithmeticType> predicted_target_position;
-            float pitch;
+            ArithmeticType pitch;
         };
 
         [[nodiscard]]
-        std::optional<Solution> find_solution(const Projectile& projectile, const Target& target) const
+        std::optional<Solution> find_solution(const Projectile<ArithmeticType>& projectile,
+                                              const Target<ArithmeticType>& target) const
         {
-            for (float time = 0.f; time < m_maximum_simulation_time; time += m_simulation_time_step)
+            for (ArithmeticType time = ArithmeticType{0}; time < m_maximum_simulation_time;
+                 time += m_simulation_time_step)
             {
                 const auto predicted_target_position =
                         EngineTrait::predict_target_position(target, time, m_gravity_constant);
@@ -105,10 +110,10 @@ namespace omath::projectile_prediction
             return std::nullopt;
         }
 
-        const float m_gravity_constant;
+        const ArithmeticType m_gravity_constant;
-        const float m_simulation_time_step;
+        const ArithmeticType m_simulation_time_step;
-        const float m_maximum_simulation_time;
+        const ArithmeticType m_maximum_simulation_time;
-        const float m_distance_tolerance;
+        const ArithmeticType m_distance_tolerance;
 
         // Realization of this formula:
         // https://stackoverflow.com/questions/54917375/how-to-calculate-the-angle-to-shoot-a-bullet-in-order-to-hit-a-moving-target
@@ -123,15 +128,15 @@ namespace omath::projectile_prediction
        \]
         */
         [[nodiscard]]
-        std::optional<float>
+        std::optional<ArithmeticType>
-        maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
+        maybe_calculate_projectile_launch_pitch_angle(const Projectile<ArithmeticType>& projectile,
-                                                      const Vector3<float>& target_position) const noexcept
+                                                      const Vector3<ArithmeticType>& target_position) const noexcept
         {
             const auto bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
 
             const auto launch_origin = projectile.m_origin + projectile.m_launch_offset;
 
-            if (bullet_gravity == 0.f)
+            if (bullet_gravity == ArithmeticType{0})
                 return EngineTrait::calc_direct_pitch_angle(launch_origin, target_position);
 
             const auto delta = target_position - launch_origin;
@@ -140,24 +145,28 @@ namespace omath::projectile_prediction
             const auto distance2d_sqr = distance2d * distance2d;
             const auto launch_speed_sqr = projectile.m_launch_speed * projectile.m_launch_speed;
 
-            float root = launch_speed_sqr * launch_speed_sqr
+            ArithmeticType root = launch_speed_sqr * launch_speed_sqr
                                   - bullet_gravity
                                             * (bullet_gravity * distance2d_sqr
-                                      + 2.0f * EngineTrait::get_vector_height_coordinate(delta) * launch_speed_sqr);
+                                               + ArithmeticType{2} * EngineTrait::get_vector_height_coordinate(delta)
+                                                         * launch_speed_sqr);
 
-            if (root < 0.0f) [[unlikely]]
+            if (root < ArithmeticType{0}) [[unlikely]]
                 return std::nullopt;
 
             root = std::sqrt(root);
-            const float angle = std::atan((launch_speed_sqr - root) / (bullet_gravity * distance2d));
+            const ArithmeticType angle = std::atan((launch_speed_sqr - root) / (bullet_gravity * distance2d));
 
             return angles::radians_to_degrees(angle);
         }
+
         [[nodiscard]]
-        bool is_projectile_reached_target(const Vector3<float>& target_position, const Projectile& projectile,
+        bool is_projectile_reached_target(const Vector3<ArithmeticType>& target_position,
-                                          const float pitch, const float time) const noexcept
+                                          const Projectile<ArithmeticType>& projectile,
+                                          const ArithmeticType pitch, const ArithmeticType time) const noexcept
         {
-            const auto yaw = EngineTrait::calc_direct_yaw_angle(projectile.m_origin + projectile.m_launch_offset, target_position);
+            const auto yaw = EngineTrait::calc_direct_yaw_angle(
+                projectile.m_origin + projectile.m_launch_offset, target_position);
             const auto projectile_position =
                     EngineTrait::predict_projectile_position(projectile, pitch, yaw, time, m_gravity_constant);
 

include/omath/projectile_prediction/projectile.hpp

@@ -7,12 +7,13 @@
 
 namespace omath::projectile_prediction
 {
+    template <class ArithmeticType = float>
     class Projectile final
     {
     public:
-        Vector3<float> m_origin;
+        Vector3<ArithmeticType> m_origin;
-        Vector3<float> m_launch_offset{0.f, 0.f, 0.f};
+        Vector3<ArithmeticType> m_launch_offset{};
-        float m_launch_speed{};
+        ArithmeticType m_launch_speed{};
-        float m_gravity_scale{};
+        ArithmeticType m_gravity_scale{};
     };
 } // namespace omath::projectile_prediction

include/omath/projectile_prediction/target.hpp

@@ -7,11 +7,12 @@
 
 namespace omath::projectile_prediction
 {
+    template <class ArithmeticType = float>
     class Target final
     {
     public:
-        Vector3<float> m_origin;
+        Vector3<ArithmeticType> m_origin;
-        Vector3<float> m_velocity;
+        Vector3<ArithmeticType> m_velocity;
         bool m_is_airborne{};
     };
 } // namespace omath::projectile_prediction

include/omath/projection/camera.hpp

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "omath/3d_primitives/aabb.hpp"
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
@@ -41,23 +42,32 @@ namespace omath::projection
         AUTO,
         MANUAL,
     };
-    template<class T, class MatType, class ViewAnglesType>
+    struct CameraAxes
+    {
+        bool inverted_forward = false;
+        bool inverted_right = false;
+    };
+
+    template<class T, class MatType, class ViewAnglesType, class NumericType>
     concept CameraEngineConcept =
-            requires(const Vector3<float>& cam_origin, const Vector3<float>& look_at, const ViewAnglesType& angles,
+            requires(const Vector3<NumericType>& cam_origin, const Vector3<NumericType>& look_at,
-                     const FieldOfView& fov, const ViewPort& viewport, float znear, float zfar) {
+                     const ViewAnglesType& angles, const FieldOfView& fov, const ViewPort& viewport, NumericType z_near,
+                     NumericType z_far, NDCDepthRange ndc_depth_range) {
                 // Presence + return types
                 { T::calc_look_at_angle(cam_origin, look_at) } -> std::same_as<ViewAnglesType>;
                 { T::calc_view_matrix(angles, cam_origin) } -> std::same_as<MatType>;
-                { T::calc_projection_matrix(fov, viewport, znear, zfar) } -> std::same_as<MatType>;
+                { T::calc_projection_matrix(fov, viewport, z_near, z_far, ndc_depth_range) } -> std::same_as<MatType>;
-
+                requires std::is_floating_point_v<NumericType>;
                 // Enforce noexcept as in the trait declaration
                 requires noexcept(T::calc_look_at_angle(cam_origin, look_at));
                 requires noexcept(T::calc_view_matrix(angles, cam_origin));
-                requires noexcept(T::calc_projection_matrix(fov, viewport, znear, zfar));
+                requires noexcept(T::calc_projection_matrix(fov, viewport, z_near, z_far, ndc_depth_range));
             };
 
-    template<class Mat4X4Type, class ViewAnglesType, class TraitClass, bool inverted_z = false>
+    template<class Mat4X4Type, class ViewAnglesType, class TraitClass,
-    requires CameraEngineConcept<TraitClass, Mat4X4Type, ViewAnglesType>
+             NDCDepthRange depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE, CameraAxes axes = {},
+             class NumericType = float>
+    requires CameraEngineConcept<TraitClass, Mat4X4Type, ViewAnglesType, NumericType>
     class Camera final
     {
 #ifdef OMATH_BUILD_TESTS
@@ -73,48 +83,110 @@ namespace omath::projection
         };
 
         ~Camera() = default;
-        Camera(const Vector3<float>& position, const ViewAnglesType& view_angles, const ViewPort& view_port,
+        Camera(const Vector3<NumericType>& position, const ViewAnglesType& view_angles, const ViewPort& view_port,
-               const FieldOfView& fov, const float near, const float far) noexcept
+               const FieldOfView& fov, const NumericType near, const NumericType far) noexcept
             : m_view_port(view_port), m_field_of_view(fov), m_far_plane_distance(far), m_near_plane_distance(near),
               m_view_angles(view_angles), m_origin(position)
         {
         }
 
-        void look_at(const Vector3<float>& target)
+        struct ProjectionParams final
+        {
+            FieldOfView fov;
+            NumericType aspect_ratio{};
+        };
+
+        // Recovers vertical FOV and aspect ratio from a perspective projection matrix
+        // built by any of the engine traits.  Both variants (ZERO_TO_ONE and
+        // NEGATIVE_ONE_TO_ONE) share the same m[0,0]/m[1,1] layout, so this works
+        // regardless of the NDC depth range.
+        [[nodiscard]]
+        static ProjectionParams extract_projection_params(const Mat4X4Type& proj_matrix) noexcept
+        {
+            // m[1,1] == 1 / tan(fov/2)  =>  fov = 2 * atan(1 / m[1,1])
+            const auto f = proj_matrix.at(1, 1);
+            // m[0,0] == m[1,1] / aspect_ratio  =>  aspect = m[1,1] / m[0,0]
+            return {FieldOfView::from_radians(NumericType{2} * std::atan(NumericType{1} / f)),
+                    f / proj_matrix.at(0, 0)};
+        }
+
+        [[nodiscard]]
+        static ViewAnglesType calc_view_angles_from_view_matrix(const Mat4X4Type& view_matrix) noexcept
+        {
+            Vector3<NumericType> forward_vector = {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]};
+            if constexpr (axes.inverted_forward)
+                forward_vector = -forward_vector;
+            return TraitClass::calc_look_at_angle({}, forward_vector);
+        }
+
+        [[nodiscard]]
+        static Vector3<NumericType> calc_origin_from_view_matrix(const Mat4X4Type& view_matrix) noexcept
+        {
+            // The view matrix is R * T(-origin), so the last column stores t = -R * origin.
+            // Recovering origin: origin = -R^T * t
+            return {
+                    -(view_matrix[0, 0] * view_matrix[0, 3] + view_matrix[1, 0] * view_matrix[1, 3]
+                      + view_matrix[2, 0] * view_matrix[2, 3]),
+                    -(view_matrix[0, 1] * view_matrix[0, 3] + view_matrix[1, 1] * view_matrix[1, 3]
+                      + view_matrix[2, 1] * view_matrix[2, 3]),
+                    -(view_matrix[0, 2] * view_matrix[0, 3] + view_matrix[1, 2] * view_matrix[1, 3]
+                      + view_matrix[2, 2] * view_matrix[2, 3]),
+            };
+        }
+
+        void look_at(const Vector3<NumericType>& target)
         {
             m_view_angles = TraitClass::calc_look_at_angle(m_origin, target);
             m_view_projection_matrix = std::nullopt;
             m_view_matrix = std::nullopt;
         }
         [[nodiscard]]
-        ViewAnglesType calc_look_at_angles(const Vector3<float>& look_to) const
+        ViewAnglesType calc_look_at_angles(const Vector3<NumericType>& look_to) const
         {
             return TraitClass::calc_look_at_angle(m_origin, look_to);
         }
 
         [[nodiscard]]
-        Vector3<float> get_forward() const noexcept
+        Vector3<NumericType> get_forward() const noexcept
         {
             const auto& view_matrix = get_view_matrix();
-
-            if constexpr (inverted_z)
-                return -Vector3<float>{view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]};
             return {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]};
         }
 
         [[nodiscard]]
-        Vector3<float> get_right() const noexcept
+        Vector3<NumericType> get_right() const noexcept
         {
             const auto& view_matrix = get_view_matrix();
             return {view_matrix[0, 0], view_matrix[0, 1], view_matrix[0, 2]};
         }
 
         [[nodiscard]]
-        Vector3<float> get_up() const noexcept
+        Vector3<NumericType> get_up() const noexcept
         {
             const auto& view_matrix = get_view_matrix();
             return {view_matrix[1, 0], view_matrix[1, 1], view_matrix[1, 2]};
         }
+        [[nodiscard]]
+        Vector3<NumericType> get_abs_forward() const noexcept
+        {
+            if constexpr (axes.inverted_forward)
+                return -get_forward();
+            return get_forward();
+        }
+
+        [[nodiscard]]
+        Vector3<NumericType> get_abs_right() const noexcept
+        {
+            if constexpr (axes.inverted_right)
+                return -get_right();
+            return get_right();
+        }
+
+        [[nodiscard]]
+        Vector3<NumericType> get_abs_up() const noexcept
+        {
+            return get_up();
+        }
 
         [[nodiscard]] const Mat4X4Type& get_view_projection_matrix() const noexcept
         {
@@ -134,8 +206,8 @@ namespace omath::projection
         [[nodiscard]] const Mat4X4Type& get_projection_matrix() const noexcept
         {
             if (!m_projection_matrix.has_value())
-                m_projection_matrix = TraitClass::calc_projection_matrix(m_field_of_view, m_view_port,
+                m_projection_matrix = TraitClass::calc_projection_matrix(
-                                                                         m_near_plane_distance, m_far_plane_distance);
+                        m_field_of_view, m_view_port, m_near_plane_distance, m_far_plane_distance, depth_range);
 
             return m_projection_matrix.value();
         }
@@ -147,14 +219,14 @@ namespace omath::projection
             m_projection_matrix = std::nullopt;
         }
 
-        void set_near_plane(const float near_plane) noexcept
+        void set_near_plane(const NumericType near_plane) noexcept
         {
             m_near_plane_distance = near_plane;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
 
-        void set_far_plane(const float far_plane) noexcept
+        void set_far_plane(const NumericType far_plane) noexcept
         {
             m_far_plane_distance = far_plane;
             m_view_projection_matrix = std::nullopt;
@@ -168,7 +240,7 @@ namespace omath::projection
             m_view_matrix = std::nullopt;
         }
 
-        void set_origin(const Vector3<float>& origin) noexcept
+        void set_origin(const Vector3<NumericType>& origin) noexcept
         {
             m_origin = origin;
             m_view_projection_matrix = std::nullopt;
@@ -186,12 +258,12 @@ namespace omath::projection
             return m_field_of_view;
         }
 
-        [[nodiscard]] const float& get_near_plane() const noexcept
+        [[nodiscard]] const NumericType& get_near_plane() const noexcept
         {
             return m_near_plane_distance;
         }
 
-        [[nodiscard]] const float& get_far_plane() const noexcept
+        [[nodiscard]] const NumericType& get_far_plane() const noexcept
         {
             return m_far_plane_distance;
         }
@@ -201,14 +273,14 @@ namespace omath::projection
             return m_view_angles;
         }
 
-        [[nodiscard]] const Vector3<float>& get_origin() const noexcept
+        [[nodiscard]] const Vector3<NumericType>& get_origin() const noexcept
         {
             return m_origin;
         }
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
-        [[nodiscard]] std::expected<Vector3<float>, Error>
+        [[nodiscard]] std::expected<Vector3<NumericType>, Error>
-        world_to_screen(const Vector3<float>& world_position) const noexcept
+        world_to_screen(const Vector3<NumericType>& world_position) const noexcept
         {
             const auto normalized_cords = world_to_view_port(world_position);
 
@@ -223,8 +295,8 @@ namespace omath::projection
                 std::unreachable();
         }
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
-        [[nodiscard]] std::expected<Vector3<float>, Error>
+        [[nodiscard]] std::expected<Vector3<NumericType>, Error>
-        world_to_screen_unclipped(const Vector3<float>& world_position) const noexcept
+        world_to_screen_unclipped(const Vector3<NumericType>& world_position) const noexcept
         {
             const auto normalized_cords = world_to_view_port(world_position, ViewPortClipping::MANUAL);
 
@@ -239,14 +311,14 @@ namespace omath::projection
                 std::unreachable();
         }
 
-        [[nodiscard]] bool is_culled_by_frustum(const Triangle<Vector3<float>>& triangle) const noexcept
+        [[nodiscard]] bool is_culled_by_frustum(const Triangle<Vector3<NumericType>>& triangle) const noexcept
         {
             // Transform to clip space (before perspective divide)
-            auto to_clip = [this](const Vector3<float>& point)
+            auto to_clip = [this](const Vector3<NumericType>& point)
             {
                 auto clip = get_view_projection_matrix()
-                            * mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(point);
+                            * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(point);
-                return std::array<float, 4>{
+                return std::array<NumericType, 4>{
                         clip.at(0, 0), // x
                         clip.at(1, 0), // y
                         clip.at(2, 0), // z
@@ -259,42 +331,119 @@ namespace omath::projection
             const auto c2 = to_clip(triangle.m_vertex3);
 
             // If all vertices are behind the camera (w <= 0), trivially reject
-            if (c0[3] <= 0.f && c1[3] <= 0.f && c2[3] <= 0.f)
+            if (c0[3] <= NumericType{0} && c1[3] <= NumericType{0} && c2[3] <= NumericType{0})
                 return true;
 
             // Helper: all three vertices outside the same clip plane
-            auto all_outside_plane = [](const int axis, const std::array<float, 4>& a, const std::array<float, 4>& b,
+            auto all_outside_plane = [](const int axis, const std::array<NumericType, 4>& a,
-                                        const std::array<float, 4>& c, const bool positive_side)
+                                        const std::array<NumericType, 4>& b, const std::array<NumericType, 4>& c,
+                                        const bool positive_side)
             {
                 if (positive_side)
                     return a[axis] > a[3] && b[axis] > b[3] && c[axis] > c[3];
                 return a[axis] < -a[3] && b[axis] < -b[3] && c[axis] < -c[3];
             };
 
-            // Clip volume in clip space (OpenGL-style):
+            // Clip volume in clip space:
             // -w <= x <= w
             // -w <= y <= w
-            // -w <= z <= w
+            // z_min <= z <= w  (z_min = -w for [-1,1], 0 for [0,1])
 
-            for (int i = 0; i < 3; i++)
+            // x and y planes
+            for (int i = 0; i < 2; i++)
             {
                 if (all_outside_plane(i, c0, c1, c2, false))
-                    return true; // x < -w (left)
+                    return true;
                 if (all_outside_plane(i, c0, c1, c2, true))
-                    return true; // x >  w (right)
+                    return true;
+            }
+
+            // z far plane: z > w
+            if (all_outside_plane(2, c0, c1, c2, true))
+                return true;
+
+            // z near plane
+            if constexpr (depth_range == NDCDepthRange::ZERO_TO_ONE)
+            {
+                // 0 <= z, so reject if z < 0 for all vertices
+                if (c0[2] < 0.f && c1[2] < 0.f && c2[2] < 0.f)
+                    return true;
+            }
+            else
+            {
+                // -w <= z
+                if (all_outside_plane(2, c0, c1, c2, false))
+                    return true;
             }
             return false;
         }
 
-        [[nodiscard]] std::expected<Vector3<float>, Error>
+        [[nodiscard]] bool is_aabb_culled_by_frustum(const primitives::Aabb<NumericType>& aabb) const noexcept
-        world_to_view_port(const Vector3<float>& world_position,
+        {
+            const auto& m = get_view_projection_matrix();
+
+            // Gribb-Hartmann: extract 6 frustum planes from the view-projection matrix.
+            // Each plane is (a, b, c, d) such that ax + by + cz + d >= 0 means inside.
+            // For a 4x4 matrix with rows r0..r3:
+            //   Left   = r3 + r0
+            //   Right  = r3 - r0
+            //   Bottom = r3 + r1
+            //   Top    = r3 - r1
+            //   Near   = r3 + r2  ([-1,1]) or r2 ([0,1])
+            //   Far    = r3 - r2
+            struct Plane final
+            {
+                NumericType a, b, c, d;
+            };
+
+            const auto extract_plane = [&m](const int sign, const int row) -> Plane
+            {
+                return {
+                        m.at(3, 0) + static_cast<NumericType>(sign) * m.at(row, 0),
+                        m.at(3, 1) + static_cast<NumericType>(sign) * m.at(row, 1),
+                        m.at(3, 2) + static_cast<NumericType>(sign) * m.at(row, 2),
+                        m.at(3, 3) + static_cast<NumericType>(sign) * m.at(row, 3),
+                };
+            };
+
+            std::array<Plane, 6> planes = {
+                    extract_plane(1, 0), // left
+                    extract_plane(-1, 0), // right
+                    extract_plane(1, 1), // bottom
+                    extract_plane(-1, 1), // top
+                    extract_plane(-1, 2), // far
+            };
+
+            // Near plane depends on NDC depth range
+            if constexpr (depth_range == NDCDepthRange::ZERO_TO_ONE)
+                planes[5] = {m.at(2, 0), m.at(2, 1), m.at(2, 2), m.at(2, 3)};
+            else
+                planes[5] = extract_plane(1, 2);
+
+            // For each plane, find the AABB corner most in the direction of the plane normal
+            // (the "positive vertex"). If it's outside, the entire AABB is outside.
+            for (const auto& [a, b, c, d] : planes)
+            {
+                const auto px = a >= NumericType{0} ? aabb.max.x : aabb.min.x;
+                const auto py = b >= NumericType{0} ? aabb.max.y : aabb.min.y;
+                const auto pz = c >= NumericType{0} ? aabb.max.z : aabb.min.z;
+
+                if (a * px + b * py + c * pz + d < NumericType{0})
+                    return true;
+            }
+
+            return false;
+        }
+
+        [[nodiscard]] std::expected<Vector3<NumericType>, Error>
+        world_to_view_port(const Vector3<NumericType>& world_position,
                            const ViewPortClipping& clipping = ViewPortClipping::AUTO) const noexcept
         {
             auto projected = get_view_projection_matrix()
-                             * mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(world_position);
+                             * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(world_position);
 
             const auto& w = projected.at(3, 0);
-            constexpr auto eps = std::numeric_limits<float>::epsilon();
+            constexpr auto eps = std::numeric_limits<NumericType>::epsilon();
             if (w <= eps)
                 return std::unexpected(Error::PERSPECTIVE_DIVIDER_LESS_EQ_ZERO);
 
@@ -306,15 +455,17 @@ namespace omath::projection
                 return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
             // ReSharper disable once CppTooWideScope
-            const auto clipped_manually = clipping == ViewPortClipping::MANUAL && (projected.at(2, 0) < 0.0f - eps
+            constexpr auto z_min = depth_range == NDCDepthRange::ZERO_TO_ONE ? NumericType{0} : -NumericType{1};
-                                          || projected.at(2, 0) > 1.0f + eps);
+            const auto clipped_manually =
+                    clipping == ViewPortClipping::MANUAL
+                    && (projected.at(2, 0) < z_min - eps || projected.at(2, 0) > NumericType{1} + eps);
             if (clipped_manually)
                 return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
-            return Vector3<float>{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)};
+            return Vector3<NumericType>{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)};
         }
         [[nodiscard]]
-        std::expected<Vector3<float>, Error> view_port_to_world(const Vector3<float>& ndc) const noexcept
+        std::expected<Vector3<NumericType>, Error> view_port_to_world(const Vector3<NumericType>& ndc) const noexcept
         {
             const auto inv_view_proj = get_view_projection_matrix().inverted();
 
@@ -322,54 +473,74 @@ namespace omath::projection
                 return std::unexpected(Error::INV_VIEW_PROJ_MAT_DET_EQ_ZERO);
 
             auto inverted_projection =
-                    inv_view_proj.value() * mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(ndc);
+                    inv_view_proj.value() * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(ndc);
 
             const auto& w = inverted_projection.at(3, 0);
 
-            if (std::abs(w) < std::numeric_limits<float>::epsilon())
+            if (std::abs(w) < std::numeric_limits<NumericType>::epsilon())
                 return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
             inverted_projection /= w;
 
-            return Vector3<float>{inverted_projection.at(0, 0), inverted_projection.at(1, 0),
+            return Vector3<NumericType>{inverted_projection.at(0, 0), inverted_projection.at(1, 0),
                                         inverted_projection.at(2, 0)};
         }
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
         [[nodiscard]]
-        std::expected<Vector3<float>, Error> screen_to_world(const Vector3<float>& screen_pos) const noexcept
+        std::expected<Vector3<NumericType>, Error>
+        screen_to_world(const Vector3<NumericType>& screen_pos) const noexcept
         {
             return view_port_to_world(screen_to_ndc<screen_start>(screen_pos));
         }
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
         [[nodiscard]]
-        std::expected<Vector3<float>, Error> screen_to_world(const Vector2<float>& screen_pos) const noexcept
+        std::expected<Vector3<NumericType>, Error>
+        screen_to_world(const Vector2<NumericType>& screen_pos) const noexcept
         {
             const auto& [x, y] = screen_pos;
-            return screen_to_world<screen_start>({x, y, 1.f});
+            return screen_to_world<screen_start>({x, y, 1});
         }
 
     protected:
         ViewPort m_view_port{};
-        Angle<float, 0.f, 180.f, AngleFlags::Clamped> m_field_of_view;
+        FieldOfView m_field_of_view;
 
         mutable std::optional<Mat4X4Type> m_view_projection_matrix;
         mutable std::optional<Mat4X4Type> m_projection_matrix;
         mutable std::optional<Mat4X4Type> m_view_matrix;
-        float m_far_plane_distance;
+        NumericType m_far_plane_distance;
-        float m_near_plane_distance;
+        NumericType m_near_plane_distance;
 
         ViewAnglesType m_view_angles;
-        Vector3<float> m_origin;
+        Vector3<NumericType> m_origin;
 
     private:
         template<class Type>
         [[nodiscard]] constexpr static bool is_ndc_out_of_bounds(const Type& ndc) noexcept
         {
-            constexpr auto eps = std::numeric_limits<float>::epsilon();
+            constexpr auto eps = std::numeric_limits<NumericType>::epsilon();
-            return std::ranges::any_of(ndc.raw_array(),
+
-                                       [](const auto& val) { return val < -1.0f - eps || val > 1.0f + eps; });
+            const auto& data = ndc.raw_array();
+            // x and y are always in [-1, 1]
+            if (data[0] < -NumericType{1} - eps || data[0] > NumericType{1} + eps)
+                return true;
+            if (data[1] < -NumericType{1} - eps || data[1] > NumericType{1} + eps)
+                return true;
+            return is_ndc_z_value_out_of_bounds(data[2]);
+        }
+        template<class ZType>
+        [[nodiscard]]
+        constexpr static bool is_ndc_z_value_out_of_bounds(const ZType& z_ndc) noexcept
+        {
+            constexpr auto eps = std::numeric_limits<NumericType>::epsilon();
+            if constexpr (depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+                return z_ndc < -NumericType{1} - eps || z_ndc > NumericType{1} + eps;
+            if constexpr (depth_range == NDCDepthRange::ZERO_TO_ONE)
+                return z_ndc < NumericType{0} - eps || z_ndc > NumericType{1} + eps;
+
+            std::unreachable();
         }
 
         // NDC REPRESENTATION:
@@ -386,8 +557,8 @@ namespace omath::projection
                                 v
             */
 
-        [[nodiscard]] Vector3<float>
+        [[nodiscard]] Vector3<NumericType>
-        ndc_to_screen_position_from_top_left_corner(const Vector3<float>& ndc) const noexcept
+        ndc_to_screen_position_from_top_left_corner(const Vector3<NumericType>& ndc) const noexcept
         {
             /*
             +------------------------>
@@ -400,11 +571,12 @@ namespace omath::projection
             |
             ⌄
             */
-            return {(ndc.x + 1.f) / 2.f * m_view_port.m_width, (ndc.y / -2.f + 0.5f) * m_view_port.m_height, ndc.z};
+            return {(ndc.x + NumericType{1}) / NumericType{2} * m_view_port.m_width,
+                    (ndc.y / -NumericType{2} + NumericType{0.5}) * m_view_port.m_height, ndc.z};
         }
 
-        [[nodiscard]] Vector3<float>
+        [[nodiscard]] Vector3<NumericType>
-        ndc_to_screen_position_from_bottom_left_corner(const Vector3<float>& ndc) const noexcept
+        ndc_to_screen_position_from_bottom_left_corner(const Vector3<NumericType>& ndc) const noexcept
         {
             /*
              ^
@@ -417,18 +589,19 @@ namespace omath::projection
              | (0, 0)
              +------------------------>
              */
-            return {(ndc.x + 1.f) / 2.f * m_view_port.m_width, (ndc.y / 2.f + 0.5f) * m_view_port.m_height, ndc.z};
+            return {(ndc.x + NumericType{1}) / NumericType{2} * m_view_port.m_width,
+                    (ndc.y / NumericType{2} + NumericType{0.5}) * m_view_port.m_height, ndc.z};
         }
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
-        [[nodiscard]] Vector3<float> screen_to_ndc(const Vector3<float>& screen_pos) const noexcept
+        [[nodiscard]] Vector3<NumericType> screen_to_ndc(const Vector3<NumericType>& screen_pos) const noexcept
         {
             if constexpr (screen_start == ScreenStart::TOP_LEFT_CORNER)
-                return {screen_pos.x / m_view_port.m_width * 2.f - 1.f, 1.f - screen_pos.y / m_view_port.m_height * 2.f,
+                return {screen_pos.x / m_view_port.m_width * NumericType{2} - NumericType{1},
-                        screen_pos.z};
+                        NumericType{1} - screen_pos.y / m_view_port.m_height * NumericType{2}, screen_pos.z};
             else if constexpr (screen_start == ScreenStart::BOTTOM_LEFT_CORNER)
-                return {screen_pos.x / m_view_port.m_width * 2.f - 1.f,
+                return {screen_pos.x / m_view_port.m_width * NumericType{2} - NumericType{1},
-                        (screen_pos.y / m_view_port.m_height - 0.5f) * 2.f, screen_pos.z};
+                        (screen_pos.y / m_view_port.m_height - NumericType{0.5}) * NumericType{2}, screen_pos.z};
             else
                 std::unreachable();
         }

include/omath/rev_eng/internal_rev_object.hpp

@@ -116,19 +116,31 @@ namespace omath::rev_eng
             return call_method<ReturnType>(vtable[Id], arg_list...);
         }
 
-        template<std::size_t TableIndex, std::size_t Id, class ReturnType>
+        template<std::ptrdiff_t TableOffset, std::size_t Id, class ReturnType>
         ReturnType call_virtual_method(auto... arg_list)
         {
-            const auto vtable = *reinterpret_cast<void***>(
+            auto sub_this = reinterpret_cast<void*>(
-                reinterpret_cast<std::uintptr_t>(this) + TableIndex * sizeof(std::uintptr_t));
+                reinterpret_cast<std::uintptr_t>(this) + TableOffset);
-            return call_method<ReturnType>(vtable[Id], arg_list...);
+            const auto vtable = *reinterpret_cast<void***>(sub_this);
+#ifdef _MSC_VER
+            using Fn = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
+#else
+            using Fn = ReturnType(*)(void*, decltype(arg_list)...);
+#endif
+            return reinterpret_cast<Fn>(vtable[Id])(sub_this, arg_list...);
         }
-        template<std::size_t TableIndex, std::size_t Id, class ReturnType>
+        template<std::ptrdiff_t TableOffset, std::size_t Id, class ReturnType>
         ReturnType call_virtual_method(auto... arg_list) const
         {
-            const auto vtable = *reinterpret_cast<void* const* const*>(
+            auto sub_this = reinterpret_cast<const void*>(
-                reinterpret_cast<std::uintptr_t>(this) + TableIndex * sizeof(std::uintptr_t));
+                reinterpret_cast<std::uintptr_t>(this) + TableOffset);
-            return call_method<ReturnType>(vtable[Id], arg_list...);
+            const auto vtable = *reinterpret_cast<void* const* const*>(sub_this);
+#ifdef _MSC_VER
+            using Fn = ReturnType(__thiscall*)(const void*, decltype(arg_list)...);
+#else
+            using Fn = ReturnType(*)(const void*, decltype(arg_list)...);
+#endif
+            return reinterpret_cast<Fn>(vtable[Id])(sub_this, arg_list...);
         }
 
     private:

include/omath/trigonometry/angle.hpp

@@ -36,6 +36,7 @@ namespace omath
         }
 
     public:
+        using ArithmeticType = Type;
         [[nodiscard]]
         constexpr static Angle from_degrees(const Type& degrees) noexcept
         {

include/omath/trigonometry/view_angles.hpp

@@ -2,14 +2,25 @@
 // Created by Orange on 11/30/2024.
 //
 #pragma once
-
+#include "omath/linear_algebra/vector3.hpp"
+#include <type_traits>
 namespace omath
 {
     template<class PitchType, class YawType, class RollType>
+    requires std::is_same_v<typename PitchType::ArithmeticType, typename YawType::ArithmeticType>
+             && std::is_same_v<typename YawType::ArithmeticType, typename RollType::ArithmeticType>
     struct ViewAngles
     {
+        using ArithmeticType = PitchType::ArithmeticType;
+
         PitchType pitch;
         YawType yaw;
         RollType roll;
+
+        [[nodiscard]]
+        Vector3<ArithmeticType> as_vector3() const
+        {
+            return {pitch.as_degrees(), yaw.as_degrees(), roll.as_degrees()};
+        }
     };
 } // namespace omath

scripts/gource-timelapse.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+# =============================================================================
+# Gource Timelapse — renders the repository history as a video
+# Requires: gource, ffmpeg
+# =============================================================================
+
+set -euo pipefail
+
+# --- Config (override via env vars) ---
+OUTPUT="${OUTPUT:-gource-timelapse.mp4}"
+SECONDS_PER_DAY="${SECONDS_PER_DAY:-0.1}"
+RESOLUTION="${RESOLUTION:-1920x1080}"
+FPS="${FPS:-60}"
+TITLE="${TITLE:-omath}"
+
+# --- Dependency checks ---
+for cmd in gource ffmpeg; do
+    if ! command -v "$cmd" &>/dev/null; then
+        echo "Error: '$cmd' is not installed."
+        echo "  macOS:  brew install $cmd"
+        echo "  Linux:  sudo apt install $cmd"
+        exit 1
+    fi
+done
+
+echo "----------------------------------------------------"
+echo "Rendering gource timelapse → $OUTPUT"
+echo "  Resolution : $RESOLUTION"
+echo "  FPS        : $FPS"
+echo "  Speed      : ${SECONDS_PER_DAY}s per day"
+echo "----------------------------------------------------"
+
+gource \
+    --title "$TITLE" \
+    --seconds-per-day "$SECONDS_PER_DAY" \
+    --auto-skip-seconds 0.1 \
+    --time-scale 3 \
+    --max-files 0 \
+    --hide filenames \
+    --date-format "%Y-%m-%d" \
+    --multi-sampling \
+    --bloom-multiplier 0.5 \
+    --elasticity 0.05 \
+    --${RESOLUTION%x*}x${RESOLUTION#*x} \
+    --output-framerate "$FPS" \
+    --output-ppm-stream - \
+    | ffmpeg -y \
+        -r "$FPS" \
+        -f image2pipe \
+        -vcodec ppm \
+        -i - \
+        -vcodec libx264 \
+        -preset fast \
+        -pix_fmt yuv420p \
+        -crf 18 \
+        "$OUTPUT"
+
+echo "----------------------------------------------------"
+echo "Done: $OUTPUT"
+echo "----------------------------------------------------"

source/engines/cry_engine/formulas.cpp

@@ -35,8 +35,15 @@ namespace omath::cry_engine
                * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
     }
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        return mat_perspective_left_handed(field_of_view, aspect_ratio, near, far);
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
+
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
+        std::unreachable();
     }
 } // namespace omath::unity_engine

source/engines/cry_engine/traits/camera_trait.cpp

@@ -19,8 +19,9 @@ namespace omath::cry_engine
     }
     Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                                const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
     }
 } // namespace omath::unity_engine

source/engines/frostbite_engine/formulas.cpp

@@ -35,8 +35,16 @@ namespace omath::frostbite_engine
                * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
     }
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        return mat_perspective_left_handed(field_of_view, aspect_ratio, near, far);
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
+
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
+
+        std::unreachable();
     }
 } // namespace omath::unity_engine

source/engines/frostbite_engine/traits/camera_trait.cpp

@@ -19,8 +19,9 @@ namespace omath::frostbite_engine
     }
     Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                                const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
     }
 } // namespace omath::unity_engine

source/engines/iw_engine/formulas.cpp

@@ -36,18 +36,26 @@ namespace omath::iw_engine
     }
 
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        // NOTE: Need magic number to fix fov calculation, since IW engine inherit Quake proj matrix calculation
+        // InfinityWard Engine (inherited from Quake) stores FOV as horizontal FOV at a 4:3
-        constexpr auto k_multiply_factor = 0.75f;
+        // reference aspect. Convert to true vertical FOV, then delegate to the
+        // standard vertical-FOV left-handed builder with the caller's actual
+        // aspect ratio.
+        //   vfov = 2 · atan( tan(hfov_4:3 / 2) / (4/3) )
+        constexpr float k_source_reference_aspect = 4.f / 3.f;
+        const float half_hfov_4_3 = angles::degrees_to_radians(field_of_view) / 2.f;
+        const float vfov_deg = angles::radians_to_degrees(
+                2.f * std::atan(std::tan(half_hfov_4_3) / k_source_reference_aspect));
 
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f) * k_multiply_factor;
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-
+            return mat_perspective_left_handed<
-        return {
+                    float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                    vfov_deg, aspect_ratio, near, far);
-                {0, 1.f / (fov_half_tan), 0, 0},
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
+            return mat_perspective_left_handed<
-                {0, 0, 1, 0},
+                    float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-        };
+                    vfov_deg, aspect_ratio, near, far);
+        std::unreachable();
     };
 } // namespace omath::iw_engine

source/engines/iw_engine/traits/camera_trait.cpp

@@ -19,8 +19,9 @@ namespace omath::iw_engine
     }
     Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                                const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
     }
 } // namespace omath::iw_engine

source/engines/opengl_engine/formulas.cpp

@@ -8,15 +8,15 @@ namespace omath::opengl_engine
 
     Vector3<float> forward_vector(const ViewAngles& angles) noexcept
     {
-        const auto vec
+        const auto vec =
-                = rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_forward);
+                rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_forward);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
     Vector3<float> right_vector(const ViewAngles& angles) noexcept
     {
-        const auto vec
+        const auto vec =
-                = rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_right);
+                rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_right);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
@@ -37,15 +37,16 @@ namespace omath::opengl_engine
                * mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(angles.pitch);
     }
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_right_handed<float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
 
-        return {
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+            return mat_perspective_right_handed<float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                {0, 1.f / (fov_half_tan), 0, 0},
+                        field_of_view, aspect_ratio, near, far);
-                {0, 0, -(far + near) / (far - near), -(2.f * far * near) / (far - near)},
+
-                {0, 0, -1, 0},
+        std::unreachable();
-        };
     }
 } // namespace omath::opengl_engine

source/engines/opengl_engine/traits/camera_trait.cpp

@@ -20,8 +20,9 @@ namespace omath::opengl_engine
     }
     Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                                const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
     }
 } // namespace omath::opengl_engine

source/engines/source_engine/formulas.cpp

@@ -36,18 +36,26 @@ namespace omath::source_engine
     }
 
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        // NOTE: Need magic number to fix fov calculation, since source inherit Quake proj matrix calculation
+        // Source (inherited from Quake) stores FOV as horizontal FOV at a 4:3
-        constexpr auto k_multiply_factor = 0.75f;
+        // reference aspect. Convert to true vertical FOV, then delegate to the
+        // standard vertical-FOV left-handed builder with the caller's actual
+        // aspect ratio.
+        //   vfov = 2 · atan( tan(hfov_4:3 / 2) / (4/3) )
+        constexpr float k_source_reference_aspect = 4.f / 3.f;
+        const float half_hfov_4_3 = angles::degrees_to_radians(field_of_view) / 2.f;
+        const float vfov_deg = angles::radians_to_degrees(
+                2.f * std::atan(std::tan(half_hfov_4_3) / k_source_reference_aspect));
 
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f) * k_multiply_factor;
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-
+            return mat_perspective_left_handed<
-        return {
+                    float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                    vfov_deg, aspect_ratio, near, far);
-                {0, 1.f / (fov_half_tan), 0, 0},
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
+            return mat_perspective_left_handed<
-                {0, 0, 1, 0},
+                    float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-        };
+                    vfov_deg, aspect_ratio, near, far);
+        std::unreachable();
     }
 } // namespace omath::source_engine

source/engines/source_engine/traits/camera_trait.cpp

@@ -20,8 +20,9 @@ namespace omath::source_engine
     }
     Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                                const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
     }
 } // namespace omath::source_engine

source/engines/unity_engine/formulas.cpp

@@ -35,8 +35,15 @@ namespace omath::unity_engine
                * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
     }
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        return omath::mat_perspective_right_handed(field_of_view, aspect_ratio, near, far);
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return omath::mat_perspective_right_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return omath::mat_perspective_right_handed<float, MatStoreType::ROW_MAJOR,
+                                                       NDCDepthRange::NEGATIVE_ONE_TO_ONE>(field_of_view, aspect_ratio,
+                                                                                           near, far);
+        std::unreachable();
     }
 } // namespace omath::unity_engine

source/engines/unity_engine/traits/camera_trait.cpp

@@ -19,8 +19,9 @@ namespace omath::unity_engine
     }
     Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                                const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
     }
 } // namespace omath::unity_engine

source/engines/unreal_engine/formulas.cpp

@@ -2,41 +2,56 @@
 // Created by Vlad on 3/22/2025.
 //
 #include "omath/engines/unreal_engine/formulas.hpp"
-
 namespace omath::unreal_engine
 {
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    Vector3<double> forward_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    Vector3<double> right_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept
+    Vector3<double> up_vector(const ViewAngles& angles) noexcept
     {
         const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
 
         return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
     }
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept
     {
-        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), -right_vector(angles),
+        return mat_camera_view<double, MatStoreType::ROW_MAJOR>(forward_vector(angles), right_vector(angles),
                                                                up_vector(angles), cam_origin);
     }
     Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
     {
-        return mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.roll)
+        // UE FRotator is intrinsic Z-Y-X (Yaw → Pitch → Roll applied in local
-               * mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+        // frame), which for column-vector composition is Rz·Ry·Rx.
-               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.pitch);
+        // Pitch and roll axes in omath spin opposite to UE's convention, so
+        // both carry a sign flip.
+        return mat_rotation_axis_z<double, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_y<double, MatStoreType::ROW_MAJOR>(-angles.pitch)
+               * mat_rotation_axis_x<double, MatStoreType::ROW_MAJOR>(-angles.roll);
     }
-    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
+
-                                              const float far) noexcept
+
+    Mat4X4 calc_perspective_projection_matrix(const double field_of_view, const double aspect_ratio, const double near,
+                                              const double far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        return mat_perspective_left_handed(field_of_view, aspect_ratio, near, far);
+        // UE stores horizontal FOV in FMinimalViewInfo — use the left-handed
+        // horizontal-FOV builder directly.
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_horizontal_fov<
+                    double, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_horizontal_fov<
+                    double, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
+        std::unreachable();
     }
 } // namespace omath::unreal_engine

source/engines/unreal_engine/traits/camera_trait.cpp

@@ -6,21 +6,22 @@
 namespace omath::unreal_engine
 {
 
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
+    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<double>& cam_origin, const Vector3<double>& look_at) noexcept
     {
         const auto direction = (look_at - cam_origin).normalized();
 
-        return {PitchAngle::from_radians(-std::asin(direction.z)),
+        return {PitchAngle::from_radians(std::asin(direction.z)),
                 YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
     }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept
     {
         return unreal_engine::calc_view_matrix(angles, cam_origin);
     }
     Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
+                                               const projection::ViewPort& view_port, const double near,
-                                               const float far) noexcept
+                                               const double far, const NDCDepthRange ndc_depth_range) noexcept
     {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
     }
 } // namespace omath::unreal_engine

source/lua/lua_engines.cpp

@@ -78,7 +78,8 @@ namespace
     }
 
     // Register an engine: alias shared types, register unique Camera
-    template<class EngineTraits>
+    template<class EngineTraits, class ArithmeticType = float>
+    requires std::is_arithmetic_v<ArithmeticType>
     void register_engine(sol::table& omath_table, const char* subtable_name)
     {
         using PitchAngle = typename EngineTraits::PitchAngle;
@@ -92,9 +93,9 @@ namespace
 
         engine_table.new_usertype<Camera>(
                 "Camera",
-                sol::constructors<Camera(const omath::Vector3<float>&, const ViewAngles&,
+                sol::constructors<Camera(const omath::Vector3<ArithmeticType>&, const ViewAngles&,
                                          const omath::projection::ViewPort&, const omath::projection::FieldOfView&,
-                                         float, float)>(),
+                                         ArithmeticType, ArithmeticType)>(),
                 "look_at", &Camera::look_at, "get_forward", &Camera::get_forward, "get_right", &Camera::get_right,
                 "get_up", &Camera::get_up, "get_origin", &Camera::get_origin, "get_view_angles",
                 &Camera::get_view_angles, "get_near_plane", &Camera::get_near_plane, "get_far_plane",
@@ -104,8 +105,8 @@ namespace
                 &Camera::set_near_plane, "set_far_plane", &Camera::set_far_plane,
 
                 "world_to_screen",
-                [](const Camera& cam, const omath::Vector3<float>& pos)
+                [](const Camera& cam, const omath::Vector3<ArithmeticType>& pos)
-                        -> std::tuple<sol::optional<omath::Vector3<float>>, sol::optional<std::string>>
+                        -> std::tuple<sol::optional<omath::Vector3<ArithmeticType>>, sol::optional<std::string>>
                 {
                     auto result = cam.world_to_screen(pos);
                     if (result)
@@ -114,8 +115,8 @@ namespace
                 },
 
                 "screen_to_world",
-                [](const Camera& cam, const omath::Vector3<float>& pos)
+                [](const Camera& cam, const omath::Vector3<ArithmeticType>& pos)
-                        -> std::tuple<sol::optional<omath::Vector3<float>>, sol::optional<std::string>>
+                        -> std::tuple<sol::optional<omath::Vector3<ArithmeticType>>, sol::optional<std::string>>
                 {
                     auto result = cam.screen_to_world(pos);
                     if (result)
@@ -224,7 +225,7 @@ namespace omath::lua
         register_engine<IWEngineTraits>(omath_table, "iw");
         register_engine<SourceEngineTraits>(omath_table, "source");
         register_engine<UnityEngineTraits>(omath_table, "unity");
-        register_engine<UnrealEngineTraits>(omath_table, "unreal");
+        register_engine<UnrealEngineTraits, double>(omath_table, "unreal");
         register_engine<CryEngineTraits>(omath_table, "cry");
     }
 } // namespace omath::lua::detail

source/pathfinding/a_star.cpp

@@ -87,11 +87,11 @@ namespace omath::pathfinding
 
             const auto current_node = current_node_it->second;
 
+            closed_list.emplace(current, current_node);
+
             if (current == end_vertex)
                 return reconstruct_final_path(closed_list, current);
 
-            closed_list.emplace(current, current_node);
-
             for (const auto& neighbor: nav_mesh.get_neighbors(current))
             {
                 if (closed_list.contains(neighbor))

source/pathfinding/walk_bot.cpp

@@ -0,0 +1,92 @@
+//
+// Created by orange on 4/12/2026.
+//
+#include "omath/pathfinding/walk_bot.hpp"
+#include "omath/pathfinding/a_star.hpp"
+
+namespace omath::pathfinding
+{
+
+    WalkBot::WalkBot(const std::shared_ptr<NavigationMesh>& mesh, const float min_node_distance)
+        : m_nav_mesh(mesh), m_min_node_distance(min_node_distance) {}
+
+    void WalkBot::set_nav_mesh(const std::shared_ptr<NavigationMesh>& mesh)
+    {
+        m_nav_mesh = mesh;
+    }
+
+    void WalkBot::set_min_node_distance(const float distance)
+    {
+        m_min_node_distance = distance;
+    }
+
+    void WalkBot::set_target(const Vector3<float>& target)
+    {
+        m_target = target;
+    }
+
+    void WalkBot::reset()
+    {
+        m_last_visited.reset();
+    }
+
+    void WalkBot::update(const Vector3<float>& bot_position)
+    {
+        if (!m_target.has_value())
+            return;
+
+        if (m_target->distance_to(bot_position) <= m_min_node_distance)
+        {
+            if (m_on_status_update.has_value())
+                m_on_status_update->operator()(WalkBotStatus::FINISHED);
+            return;
+        }
+
+        if (!m_on_next_path_node.has_value())
+            return;
+
+        const auto nav_mesh = m_nav_mesh.lock();
+        if (!nav_mesh)
+        {
+            if (m_on_status_update.has_value())
+                m_on_status_update->operator()(WalkBotStatus::IDLE);
+            return;
+        }
+
+        const auto path = Astar::find_path(bot_position, *m_target, *nav_mesh);
+        if (path.empty())
+        {
+            if (m_on_status_update.has_value())
+                m_on_status_update->operator()(WalkBotStatus::IDLE);
+            return;
+        }
+
+        const auto& nearest = path.front();
+
+        // Record the nearest node as visited once we are close enough to it.
+        if (nearest.distance_to(bot_position) <= m_min_node_distance)
+            m_last_visited = nearest;
+
+        // If the nearest node was already visited, advance to the next one so
+        // we never oscillate back to a node we just left.
+        // If the bot was displaced (blown back), nearest will be an unvisited
+        // node, so we route to it first before continuing forward.
+        if (m_last_visited.has_value() && *m_last_visited == nearest && path.size() > 1)
+            m_on_next_path_node->operator()(path[1]);
+        else
+            m_on_next_path_node->operator()(nearest);
+
+        if (m_on_status_update.has_value())
+            m_on_status_update->operator()(WalkBotStatus::PATHING);
+    }
+
+    void WalkBot::on_path(const std::function<void(const Vector3<float>&)>& callback)
+    {
+        m_on_next_path_node = callback;
+    }
+
+    void WalkBot::on_status(const std::function<void(WalkBotStatus)>& callback)
+    {
+        m_on_status_update = callback;
+    }
+} // namespace omath::pathfinding

source/projectile_prediction/proj_pred_engine_avx2.cpp

@@ -14,8 +14,8 @@
 namespace omath::projectile_prediction
 {
     std::optional<Vector3<float>>
-    ProjPredEngineAvx2::maybe_calculate_aim_point([[maybe_unused]] const Projectile& projectile,
+    ProjPredEngineAvx2::maybe_calculate_aim_point([[maybe_unused]] const Projectile<float>& projectile,
-                                                  [[maybe_unused]] const Target& target) const
+                                                  [[maybe_unused]] const Target<float>& target) const
     {
 #if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
         const float bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
@@ -124,9 +124,9 @@ namespace omath::projectile_prediction
                 std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
 #endif
     }
-    std::optional<AimAngles>
+    std::optional<AimAngles<float>>
-    ProjPredEngineAvx2::maybe_calculate_aim_angles([[maybe_unused]] const Projectile& projectile,
+    ProjPredEngineAvx2::maybe_calculate_aim_angles([[maybe_unused]] const Projectile<float>& projectile,
-                                                    [[maybe_unused]] const Target& target) const
+                                                    [[maybe_unused]] const Target<float>& target) const
     {
 #if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
         const float bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
@@ -201,7 +201,7 @@ namespace omath::projectile_prediction
 
                     const Vector3 delta = target_pos - projectile.m_origin;
                     const float yaw = angles::radians_to_degrees(std::atan2(delta.y, delta.x));
-                    return AimAngles{*pitch, yaw};
+                    return AimAngles<float>{*pitch, yaw};
                 }
             }
         }

tests/engines/unit_test_cry_engine.cpp

@@ -238,3 +238,53 @@ TEST(unit_test_cry_engine, loook_at_random_z_axis)
     }
     EXPECT_LE(failed_points, 100);
 }
+
+TEST(unit_test_cry_engine, ViewAnglesAsVector3Zero)
+{
+    const omath::cry_engine::ViewAngles angles{};
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 0.f);
+    EXPECT_FLOAT_EQ(vec.y, 0.f);
+    EXPECT_FLOAT_EQ(vec.z, 0.f);
+}
+
+TEST(unit_test_cry_engine, ViewAnglesAsVector3Values)
+{
+    const omath::cry_engine::ViewAngles angles{
+        omath::cry_engine::PitchAngle::from_degrees(45.f),
+        omath::cry_engine::YawAngle::from_degrees(-90.f),
+        omath::cry_engine::RollAngle::from_degrees(30.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 45.f);
+    EXPECT_FLOAT_EQ(vec.y, -90.f);
+    EXPECT_FLOAT_EQ(vec.z, 30.f);
+}
+
+TEST(unit_test_cry_engine, ViewAnglesAsVector3ClampedPitch)
+{
+    // Pitch is clamped to [-90, 90]
+    const omath::cry_engine::ViewAngles angles{
+        omath::cry_engine::PitchAngle::from_degrees(120.f),
+        omath::cry_engine::YawAngle::from_degrees(0.f),
+        omath::cry_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 90.f);
+}
+
+TEST(unit_test_cry_engine, ViewAnglesAsVector3NormalizedYaw)
+{
+    // Yaw is normalized to [-180, 180], 270 wraps to -90
+    const omath::cry_engine::ViewAngles angles{
+        omath::cry_engine::PitchAngle::from_degrees(0.f),
+        omath::cry_engine::YawAngle::from_degrees(270.f),
+        omath::cry_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_NEAR(vec.y, -90.f, 0.01f);
+}

tests/engines/unit_test_frostbite_engine.cpp

@@ -405,3 +405,232 @@ TEST(unit_test_frostbite_engine, look_at_down)
          std::views::zip(dir_vector.as_array(), (-omath::frostbite_engine::k_abs_up).as_array()))
         EXPECT_NEAR(result, etalon, 0.0001f);
 }
+
+TEST(unit_test_frostbite_engine, ViewAnglesAsVector3Zero)
+{
+    const omath::frostbite_engine::ViewAngles angles{};
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 0.f);
+    EXPECT_FLOAT_EQ(vec.y, 0.f);
+    EXPECT_FLOAT_EQ(vec.z, 0.f);
+}
+
+TEST(unit_test_frostbite_engine, ViewAnglesAsVector3Values)
+{
+    const omath::frostbite_engine::ViewAngles angles{
+        omath::frostbite_engine::PitchAngle::from_degrees(45.f),
+        omath::frostbite_engine::YawAngle::from_degrees(-90.f),
+        omath::frostbite_engine::RollAngle::from_degrees(30.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 45.f);
+    EXPECT_FLOAT_EQ(vec.y, -90.f);
+    EXPECT_FLOAT_EQ(vec.z, 30.f);
+}
+
+TEST(unit_test_frostbite_engine, ViewAnglesAsVector3ClampedPitch)
+{
+    const omath::frostbite_engine::ViewAngles angles{
+        omath::frostbite_engine::PitchAngle::from_degrees(120.f),
+        omath::frostbite_engine::YawAngle::from_degrees(0.f),
+        omath::frostbite_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 90.f);
+}
+
+TEST(unit_test_frostbite_engine, ViewAnglesAsVector3NormalizedYaw)
+{
+    const omath::frostbite_engine::ViewAngles angles{
+        omath::frostbite_engine::PitchAngle::from_degrees(0.f),
+        omath::frostbite_engine::YawAngle::from_degrees(270.f),
+        omath::frostbite_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_NEAR(vec.y, -90.f, 0.01f);
+}
+
+// ---------------------------------------------------------------------------
+// extract_projection_params
+// ---------------------------------------------------------------------------
+
+// Tolerance: tan/atan round-trip in single precision introduces ~1e-5 rad
+// error, which is ~5.7e-4 degrees.
+static constexpr float k_fov_tolerance_deg  = 0.001f;
+static constexpr float k_aspect_tolerance   = 1e-5f;
+
+TEST(unit_test_frostbite_engine, ExtractProjectionParams_BasicRoundTrip)
+{
+    // Build a matrix with known inputs and verify both outputs are recovered.
+    constexpr float fov_deg    = 60.f;
+    constexpr float aspect     = 16.f / 9.f;
+    const auto mat = omath::frostbite_engine::calc_perspective_projection_matrix(
+        fov_deg, aspect, 0.1f, 1000.f, omath::NDCDepthRange::ZERO_TO_ONE);
+
+    const auto [fov, ar] = omath::frostbite_engine::Camera::extract_projection_params(mat);
+
+    EXPECT_NEAR(fov.as_degrees(), fov_deg, k_fov_tolerance_deg);
+    EXPECT_NEAR(ar, aspect, k_aspect_tolerance);
+}
+
+TEST(unit_test_frostbite_engine, ExtractProjectionParams_NegOneToOneDepthRange)
+{
+    // The FOV/aspect encoding in rows 0 and 1 is identical for both NDC
+    // depth ranges, so extraction must work the same way.
+    constexpr float fov_deg = 75.f;
+    constexpr float aspect  = 4.f / 3.f;
+    const auto mat = omath::frostbite_engine::calc_perspective_projection_matrix(
+        fov_deg, aspect, 0.1f, 500.f, omath::NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+
+    const auto [fov, ar] = omath::frostbite_engine::Camera::extract_projection_params(mat);
+
+    EXPECT_NEAR(fov.as_degrees(), fov_deg, k_fov_tolerance_deg);
+    EXPECT_NEAR(ar, aspect, k_aspect_tolerance);
+}
+
+TEST(unit_test_frostbite_engine, ExtractProjectionParams_Fov45)
+{
+    constexpr float fov_deg = 45.f;
+    constexpr float aspect  = 16.f / 9.f;
+    const auto mat = omath::frostbite_engine::calc_perspective_projection_matrix(
+        fov_deg, aspect, 0.01f, 1000.f);
+
+    const auto [fov, ar] = omath::frostbite_engine::Camera::extract_projection_params(mat);
+
+    EXPECT_NEAR(fov.as_degrees(), fov_deg, k_fov_tolerance_deg);
+    EXPECT_NEAR(ar, aspect, k_aspect_tolerance);
+}
+
+TEST(unit_test_frostbite_engine, ExtractProjectionParams_Fov90)
+{
+    constexpr float fov_deg = 90.f;
+    constexpr float aspect  = 16.f / 9.f;
+    const auto mat = omath::frostbite_engine::calc_perspective_projection_matrix(
+        fov_deg, aspect, 0.01f, 1000.f);
+
+    const auto [fov, ar] = omath::frostbite_engine::Camera::extract_projection_params(mat);
+
+    EXPECT_NEAR(fov.as_degrees(), fov_deg, k_fov_tolerance_deg);
+    EXPECT_NEAR(ar, aspect, k_aspect_tolerance);
+}
+
+TEST(unit_test_frostbite_engine, ExtractProjectionParams_Fov120)
+{
+    constexpr float fov_deg = 120.f;
+    constexpr float aspect  = 16.f / 9.f;
+    const auto mat = omath::frostbite_engine::calc_perspective_projection_matrix(
+        fov_deg, aspect, 0.01f, 1000.f);
+
+    const auto [fov, ar] = omath::frostbite_engine::Camera::extract_projection_params(mat);
+
+    EXPECT_NEAR(fov.as_degrees(), fov_deg, k_fov_tolerance_deg);
+    EXPECT_NEAR(ar, aspect, k_aspect_tolerance);
+}
+
+TEST(unit_test_frostbite_engine, ExtractProjectionParams_AspectRatio_4by3)
+{
+    constexpr float fov_deg = 60.f;
+    constexpr float aspect  = 4.f / 3.f;
+    const auto mat = omath::frostbite_engine::calc_perspective_projection_matrix(
+        fov_deg, aspect, 0.1f, 500.f);
+
+    const auto [fov, ar] = omath::frostbite_engine::Camera::extract_projection_params(mat);
+
+    EXPECT_NEAR(fov.as_degrees(), fov_deg, k_fov_tolerance_deg);
+    EXPECT_NEAR(ar, aspect, k_aspect_tolerance);
+}
+
+TEST(unit_test_frostbite_engine, ExtractProjectionParams_AspectRatio_Ultrawide)
+{
+    constexpr float fov_deg = 90.f;
+    constexpr float aspect  = 21.f / 9.f;
+    const auto mat = omath::frostbite_engine::calc_perspective_projection_matrix(
+        fov_deg, aspect, 0.1f, 500.f);
+
+    const auto [fov, ar] = omath::frostbite_engine::Camera::extract_projection_params(mat);
+
+    EXPECT_NEAR(fov.as_degrees(), fov_deg, k_fov_tolerance_deg);
+    EXPECT_NEAR(ar, aspect, k_aspect_tolerance);
+}
+
+TEST(unit_test_frostbite_engine, ExtractProjectionParams_AspectRatio_Square)
+{
+    constexpr float fov_deg = 90.f;
+    constexpr float aspect  = 1.f;
+    const auto mat = omath::frostbite_engine::calc_perspective_projection_matrix(
+        fov_deg, aspect, 0.1f, 500.f);
+
+    const auto [fov, ar] = omath::frostbite_engine::Camera::extract_projection_params(mat);
+
+    EXPECT_NEAR(fov.as_degrees(), fov_deg, k_fov_tolerance_deg);
+    EXPECT_NEAR(ar, aspect, k_aspect_tolerance);
+}
+
+TEST(unit_test_frostbite_engine, ExtractProjectionParams_FovAndAspectAreIndependent)
+{
+    // Changing only FOV must not affect recovered aspect ratio, and vice versa.
+    constexpr float aspect = 16.f / 9.f;
+
+    for (const float fov_deg : {45.f, 60.f, 90.f, 110.f})
+    {
+        const auto mat = omath::frostbite_engine::calc_perspective_projection_matrix(
+            fov_deg, aspect, 0.1f, 1000.f);
+        const auto [fov, ar] = omath::frostbite_engine::Camera::extract_projection_params(mat);
+
+        EXPECT_NEAR(fov.as_degrees(), fov_deg, k_fov_tolerance_deg);
+        EXPECT_NEAR(ar, aspect, k_aspect_tolerance);
+    }
+}
+
+TEST(unit_test_frostbite_engine, ExtractProjectionParams_ViaCamera_RoundTrip)
+{
+    // End-to-end: construct a Camera, retrieve its projection matrix, then
+    // recover the FOV and aspect ratio and compare against the original inputs.
+    constexpr auto fov_in  = omath::projection::FieldOfView::from_degrees(90.f);
+    constexpr float aspect = 1920.f / 1080.f;
+
+    const auto cam = omath::frostbite_engine::Camera(
+        {0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov_in, 0.01f, 1000.f);
+
+    const auto [fov_out, ar_out] =
+        omath::frostbite_engine::Camera::extract_projection_params(cam.get_projection_matrix());
+
+    EXPECT_NEAR(fov_out.as_degrees(), fov_in.as_degrees(), k_fov_tolerance_deg);
+    EXPECT_NEAR(ar_out, aspect, k_aspect_tolerance);
+}
+
+TEST(unit_test_frostbite_engine, ExtractProjectionParams_ViaCamera_AfterFovChange)
+{
+    // Verify that the extracted FOV tracks the camera's FOV after set_field_of_view().
+    auto cam = omath::frostbite_engine::Camera(
+        {0.f, 0.f, 0.f}, {}, {1920.f, 1080.f},
+        omath::projection::FieldOfView::from_degrees(60.f), 0.01f, 1000.f);
+
+    cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(110.f));
+
+    const auto [fov, ar] =
+        omath::frostbite_engine::Camera::extract_projection_params(cam.get_projection_matrix());
+
+    EXPECT_NEAR(fov.as_degrees(), 110.f, k_fov_tolerance_deg);
+    EXPECT_NEAR(ar, 1920.f / 1080.f, k_aspect_tolerance);
+}
+
+TEST(unit_test_frostbite_engine, ExtractProjectionParams_ViaCamera_AfterViewportChange)
+{
+    // Verify that the extracted aspect ratio tracks the viewport after set_view_port().
+    auto cam = omath::frostbite_engine::Camera(
+        {0.f, 0.f, 0.f}, {}, {1920.f, 1080.f},
+        omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
+
+    cam.set_view_port({1280.f, 720.f});
+
+    const auto [fov, ar] =
+        omath::frostbite_engine::Camera::extract_projection_params(cam.get_projection_matrix());
+
+    EXPECT_NEAR(fov.as_degrees(), 90.f, k_fov_tolerance_deg);
+    EXPECT_NEAR(ar, 1280.f / 720.f, k_aspect_tolerance);
+}

tests/engines/unit_test_iw_engine.cpp

@@ -281,3 +281,53 @@ TEST(unit_test_iw_engine, look_at_down)
     EXPECT_NEAR(dir_vector.x,- 0.017f, 0.01f);
     EXPECT_NEAR(dir_vector.y, 0.f, 0.001f);
 }
+
+TEST(unit_test_iw_engine, ViewAnglesAsVector3Zero)
+{
+    const omath::iw_engine::ViewAngles angles{};
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 0.f);
+    EXPECT_FLOAT_EQ(vec.y, 0.f);
+    EXPECT_FLOAT_EQ(vec.z, 0.f);
+}
+
+TEST(unit_test_iw_engine, ViewAnglesAsVector3Values)
+{
+    const omath::iw_engine::ViewAngles angles{
+        omath::iw_engine::PitchAngle::from_degrees(45.f),
+        omath::iw_engine::YawAngle::from_degrees(-90.f),
+        omath::iw_engine::RollAngle::from_degrees(30.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 45.f);
+    EXPECT_FLOAT_EQ(vec.y, -90.f);
+    EXPECT_FLOAT_EQ(vec.z, 30.f);
+}
+
+TEST(unit_test_iw_engine, ViewAnglesAsVector3ClampedPitch)
+{
+    // Pitch is clamped to [-89, 89]
+    const omath::iw_engine::ViewAngles angles{
+        omath::iw_engine::PitchAngle::from_degrees(120.f),
+        omath::iw_engine::YawAngle::from_degrees(0.f),
+        omath::iw_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 89.f);
+}
+
+TEST(unit_test_iw_engine, ViewAnglesAsVector3NormalizedYaw)
+{
+    // Yaw is normalized to [-180, 180], 270 wraps to -90
+    const omath::iw_engine::ViewAngles angles{
+        omath::iw_engine::PitchAngle::from_degrees(0.f),
+        omath::iw_engine::YawAngle::from_degrees(270.f),
+        omath::iw_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_NEAR(vec.y, -90.f, 0.01f);
+}

tests/engines/unit_test_open_gl.cpp

@@ -395,3 +395,51 @@ TEST(unit_test_opengl_engine, look_at_down)
     for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-omath::opengl_engine::k_abs_up).as_array()))
         EXPECT_NEAR(result, etalon, 0.0001f);
 }
+
+TEST(unit_test_opengl, ViewAnglesAsVector3Zero)
+{
+    const omath::opengl_engine::ViewAngles angles{};
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 0.f);
+    EXPECT_FLOAT_EQ(vec.y, 0.f);
+    EXPECT_FLOAT_EQ(vec.z, 0.f);
+}
+
+TEST(unit_test_opengl, ViewAnglesAsVector3Values)
+{
+    const omath::opengl_engine::ViewAngles angles{
+        omath::opengl_engine::PitchAngle::from_degrees(45.f),
+        omath::opengl_engine::YawAngle::from_degrees(-90.f),
+        omath::opengl_engine::RollAngle::from_degrees(30.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 45.f);
+    EXPECT_FLOAT_EQ(vec.y, -90.f);
+    EXPECT_FLOAT_EQ(vec.z, 30.f);
+}
+
+TEST(unit_test_opengl, ViewAnglesAsVector3ClampedPitch)
+{
+    const omath::opengl_engine::ViewAngles angles{
+        omath::opengl_engine::PitchAngle::from_degrees(120.f),
+        omath::opengl_engine::YawAngle::from_degrees(0.f),
+        omath::opengl_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 90.f);
+}
+
+TEST(unit_test_opengl, ViewAnglesAsVector3NormalizedYaw)
+{
+    const omath::opengl_engine::ViewAngles angles{
+        omath::opengl_engine::PitchAngle::from_degrees(0.f),
+        omath::opengl_engine::YawAngle::from_degrees(270.f),
+        omath::opengl_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_NEAR(vec.y, -90.f, 0.01f);
+}

tests/engines/unit_test_source_engine.cpp

@@ -423,3 +423,53 @@ TEST(unit_test_source_engine, look_at_down)
     EXPECT_NEAR(dir_vector.x,- 0.017f, 0.01f);
     EXPECT_NEAR(dir_vector.y, 0.f, 0.001f);
 }
+
+TEST(unit_test_source_engine, ViewAnglesAsVector3Zero)
+{
+    const omath::source_engine::ViewAngles angles{};
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 0.f);
+    EXPECT_FLOAT_EQ(vec.y, 0.f);
+    EXPECT_FLOAT_EQ(vec.z, 0.f);
+}
+
+TEST(unit_test_source_engine, ViewAnglesAsVector3Values)
+{
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(45.f),
+        omath::source_engine::YawAngle::from_degrees(-90.f),
+        omath::source_engine::RollAngle::from_degrees(30.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 45.f);
+    EXPECT_FLOAT_EQ(vec.y, -90.f);
+    EXPECT_FLOAT_EQ(vec.z, 30.f);
+}
+
+TEST(unit_test_source_engine, ViewAnglesAsVector3ClampedPitch)
+{
+    // Pitch is clamped to [-89, 89]
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(120.f),
+        omath::source_engine::YawAngle::from_degrees(0.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 89.f);
+}
+
+TEST(unit_test_source_engine, ViewAnglesAsVector3NormalizedYaw)
+{
+    // Yaw is normalized to [-180, 180], 270 wraps to -90
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(0.f),
+        omath::source_engine::YawAngle::from_degrees(270.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_NEAR(vec.y, -90.f, 0.01f);
+}

tests/engines/unit_test_traits_engines.cpp

@@ -21,6 +21,9 @@
 #include <omath/engines/unreal_engine/traits/camera_trait.hpp>
 
 #include <omath/engines/source_engine/traits/pred_engine_trait.hpp>
+#include <omath/engines/source_engine/traits/camera_trait.hpp>
+
+#include <omath/engines/cry_engine/traits/camera_trait.hpp>
 
 #include <omath/projectile_prediction/projectile.hpp>
 #include <omath/projectile_prediction/target.hpp>
@@ -41,46 +44,46 @@ static void expect_matrix_near(const MatT& a, const MatT& b, float eps = 1e-5f)
 #include <omath/engines/cry_engine/traits/pred_engine_trait.hpp>
 
 // Helper: verify that zero offset matches default-initialized offset behavior
-template<typename Trait>
+template<typename Trait, typename AT = float>
-static void verify_launch_offset_at_time_zero(const Vector3<float>& origin, const Vector3<float>& offset)
+static void verify_launch_offset_at_time_zero(const Vector3<AT>& origin, const Vector3<AT>& offset)
 {
-    projectile_prediction::Projectile p;
+    projectile_prediction::Projectile<AT> p;
     p.m_origin = origin;
     p.m_launch_offset = offset;
-    p.m_launch_speed = 100.f;
+    p.m_launch_speed = static_cast<AT>(100);
-    p.m_gravity_scale = 1.f;
+    p.m_gravity_scale = static_cast<AT>(1);
 
-    const auto pos = Trait::predict_projectile_position(p, 0.f, 0.f, 0.f, 9.81f);
+    const auto pos = Trait::predict_projectile_position(p, AT{0}, AT{0}, AT{0}, static_cast<AT>(9.81));
     const auto expected = origin + offset;
-    EXPECT_NEAR(pos.x, expected.x, 1e-4f);
+    EXPECT_NEAR(static_cast<double>(pos.x), static_cast<double>(expected.x), 1e-4);
-    EXPECT_NEAR(pos.y, expected.y, 1e-4f);
+    EXPECT_NEAR(static_cast<double>(pos.y), static_cast<double>(expected.y), 1e-4);
-    EXPECT_NEAR(pos.z, expected.z, 1e-4f);
+    EXPECT_NEAR(static_cast<double>(pos.z), static_cast<double>(expected.z), 1e-4);
 }
 
-template<typename Trait>
+template<typename Trait, typename AT = float>
 static void verify_zero_offset_matches_default()
 {
-    projectile_prediction::Projectile p;
+    projectile_prediction::Projectile<AT> p;
-    p.m_origin = {10.f, 20.f, 30.f};
+    p.m_origin = {static_cast<AT>(10), static_cast<AT>(20), static_cast<AT>(30)};
-    p.m_launch_offset = {0.f, 0.f, 0.f};
+    p.m_launch_offset = {};
-    p.m_launch_speed = 50.f;
+    p.m_launch_speed = static_cast<AT>(50);
-    p.m_gravity_scale = 1.f;
+    p.m_gravity_scale = static_cast<AT>(1);
 
-    projectile_prediction::Projectile p2;
+    projectile_prediction::Projectile<AT> p2;
-    p2.m_origin = {10.f, 20.f, 30.f};
+    p2.m_origin = {static_cast<AT>(10), static_cast<AT>(20), static_cast<AT>(30)};
-    p2.m_launch_speed = 50.f;
+    p2.m_launch_speed = static_cast<AT>(50);
-    p2.m_gravity_scale = 1.f;
+    p2.m_gravity_scale = static_cast<AT>(1);
 
-    const auto pos1 = Trait::predict_projectile_position(p, 15.f, 30.f, 1.f, 9.81f);
+    const auto pos1 = Trait::predict_projectile_position(p, static_cast<AT>(15), static_cast<AT>(30), static_cast<AT>(1), static_cast<AT>(9.81));
-    const auto pos2 = Trait::predict_projectile_position(p2, 15.f, 30.f, 1.f, 9.81f);
+    const auto pos2 = Trait::predict_projectile_position(p2, static_cast<AT>(15), static_cast<AT>(30), static_cast<AT>(1), static_cast<AT>(9.81));
 #if defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || defined(_M_ARM64)
-    constexpr float tol = 1e-6f;
+    constexpr double tol = 1e-6;
 #else
-    constexpr float tol = 1e-4f;
+    constexpr double tol = 1e-4;
 #endif
-    EXPECT_NEAR(pos1.x, pos2.x, tol);
+    EXPECT_NEAR(static_cast<double>(pos1.x), static_cast<double>(pos2.x), tol);
-    EXPECT_NEAR(pos1.y, pos2.y, tol);
+    EXPECT_NEAR(static_cast<double>(pos1.y), static_cast<double>(pos2.y), tol);
-    EXPECT_NEAR(pos1.z, pos2.z, tol);
+    EXPECT_NEAR(static_cast<double>(pos1.z), static_cast<double>(pos2.z), tol);
 }
 
 TEST(LaunchOffsetTests, Source_OffsetAtTimeZero)
@@ -125,11 +128,11 @@ TEST(LaunchOffsetTests, Unity_ZeroOffsetMatchesDefault)
 }
 TEST(LaunchOffsetTests, Unreal_OffsetAtTimeZero)
 {
-    verify_launch_offset_at_time_zero<unreal_engine::PredEngineTrait>({0, 0, 0}, {5, 3, -2});
+    verify_launch_offset_at_time_zero<unreal_engine::PredEngineTrait, double>({0, 0, 0}, {5, 3, -2});
 }
 TEST(LaunchOffsetTests, Unreal_ZeroOffsetMatchesDefault)
 {
-    verify_zero_offset_matches_default<unreal_engine::PredEngineTrait>();
+    verify_zero_offset_matches_default<unreal_engine::PredEngineTrait, double>();
 }
 TEST(LaunchOffsetTests, CryEngine_OffsetAtTimeZero)
 {
@@ -218,9 +221,14 @@ TEST(TraitTests, Frostbite_Pred_And_Mesh_And_Camera)
     // CameraTrait look at should be callable
     const auto angles = e::CameraTrait::calc_look_at_angle({0, 0, 0}, {0, 1, 1});
     (void)angles;
-    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f);
+    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
     const auto expected = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f);
     expect_matrix_near(proj, expected);
+
+    const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    expect_matrix_near(proj_zo, expected_zo);
+    EXPECT_NE(proj, proj_zo);
 }
 
 TEST(TraitTests, IW_Pred_And_Mesh_And_Camera)
@@ -264,10 +272,15 @@ TEST(TraitTests, IW_Pred_And_Mesh_And_Camera)
     e::ViewAngles va;
     expect_matrix_near(e::MeshTrait::rotation_matrix(va), e::rotation_matrix(va));
 
-    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(45.f), {1920.f, 1080.f}, 0.1f, 1000.f);
+    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(45.f), {1920.f, 1080.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
     const auto expected = e::calc_perspective_projection_matrix(45.f, 1920.f / 1080.f, 0.1f, 1000.f);
     expect_matrix_near(proj, expected);
 
+    const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(45.f), {1920.f, 1080.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(45.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    expect_matrix_near(proj_zo, expected_zo);
+    EXPECT_NE(proj, proj_zo);
+
     // non-airborne
     t.m_is_airborne = false;
     const auto pred_ground_iw = e::PredEngineTrait::predict_target_position(t, 2.f, 9.81f);
@@ -314,10 +327,15 @@ TEST(TraitTests, OpenGL_Pred_And_Mesh_And_Camera)
     e::ViewAngles va;
     expect_matrix_near(e::MeshTrait::rotation_matrix(va), e::rotation_matrix(va));
 
-    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f);
+    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
     const auto expected = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f);
     expect_matrix_near(proj, expected);
 
+    const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    expect_matrix_near(proj_zo, expected_zo);
+    EXPECT_NE(proj, proj_zo);
+
     // non-airborne
     t.m_is_airborne = false;
     const auto pred_ground_gl = e::PredEngineTrait::predict_target_position(t, 2.f, 9.81f);
@@ -364,10 +382,15 @@ TEST(TraitTests, Unity_Pred_And_Mesh_And_Camera)
     e::ViewAngles va;
     expect_matrix_near(e::MeshTrait::rotation_matrix(va), e::rotation_matrix(va));
 
-    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f);
+    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
     const auto expected = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f);
     expect_matrix_near(proj, expected);
 
+    const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    expect_matrix_near(proj_zo, expected_zo);
+    EXPECT_NE(proj, proj_zo);
+
     // non-airborne
     t.m_is_airborne = false;
     const auto pred_ground_unity = e::PredEngineTrait::predict_target_position(t, 2.f, 9.81f);
@@ -378,48 +401,274 @@ TEST(TraitTests, Unreal_Pred_And_Mesh_And_Camera)
 {
     namespace e = omath::unreal_engine;
 
-    projectile_prediction::Projectile p;
+    projectile_prediction::Projectile<double> p;
-    p.m_origin = {0.f, 0.f, 0.f};
+    p.m_origin = {0.0, 0.0, 0.0};
-    p.m_launch_speed = 10.f;
+    p.m_launch_speed = 10.0;
-    p.m_gravity_scale = 1.f;
+    p.m_gravity_scale = 1.0;
 
-    const auto pos = e::PredEngineTrait::predict_projectile_position(p, 0.f, 0.f, 1.f, 9.81f);
+    const auto pos = e::PredEngineTrait::predict_projectile_position(p, 0.0, 0.0, 1.0, 9.81);
-    EXPECT_NEAR(pos.x, 10.f, 1e-4f);
+    EXPECT_NEAR(pos.x, 10.0, 1e-4);
-    EXPECT_NEAR(pos.y, -9.81f * 0.5f, 1e-4f);
+    EXPECT_NEAR(pos.y, -9.81 * 0.5, 1e-4);
 
-    projectile_prediction::Target t;
+    projectile_prediction::Target<double> t;
-    t.m_origin = {0.f, 5.f, 0.f};
+    t.m_origin = {0.0, 5.0, 0.0};
-    t.m_velocity = {2.f, 0.f, 0.f};
+    t.m_velocity = {2.0, 0.0, 0.0};
     t.m_is_airborne = true;
-    const auto pred = e::PredEngineTrait::predict_target_position(t, 2.f, 9.81f);
+    const auto pred = e::PredEngineTrait::predict_target_position(t, 2.0, 9.81);
-    EXPECT_NEAR(pred.x, 4.f, 1e-6f);
+    EXPECT_NEAR(pred.x, 4.0, 1e-6);
-    EXPECT_NEAR(pred.y, 5.f - 9.81f * (2.f * 2.f) * 0.5f, 1e-6f);
+    EXPECT_NEAR(pred.y, 5.0 - 9.81 * (2.0 * 2.0) * 0.5, 1e-6);
 
-    EXPECT_NEAR(e::PredEngineTrait::calc_vector_2d_distance({3.f, 0.f, 4.f}), 5.f, 1e-6f);
+    EXPECT_NEAR(e::PredEngineTrait::calc_vector_2d_distance({3.0, 0.0, 4.0}), 5.0, 1e-6);
-    EXPECT_NEAR(e::PredEngineTrait::get_vector_height_coordinate({1.f, 2.5f, 3.f}), 2.5f, 1e-6f);
+    EXPECT_NEAR(e::PredEngineTrait::get_vector_height_coordinate({1.0, 2.5, 3.0}), 2.5, 1e-6);
 
-    std::optional<float> pitch = 45.f;
+    std::optional<double> pitch = 45.0;
-    auto vp = e::PredEngineTrait::calc_viewpoint_from_angles(p, {10.f, 0.f, 0.f}, pitch);
+    auto vp = e::PredEngineTrait::calc_viewpoint_from_angles(p, Vector3<double>{10.0, 0.0, 0.0}, pitch);
-    EXPECT_NEAR(vp.z, 0.f + 10.f * std::tan(angles::degrees_to_radians(45.f)), 1e-6f);
+    EXPECT_NEAR(vp.z, 0.0 + 10.0 * std::tan(angles::degrees_to_radians(45.0)), 1e-6);
 
-    Vector3<float> origin{0.f, 0.f, 0.f};
+    Vector3<double> origin{0.0, 0.0, 0.0};
-    Vector3<float> view_to{1.f, 1.f, 1.f};
+    Vector3<double> view_to{1.0, 1.0, 1.0};
     const auto pitch_calc = e::PredEngineTrait::calc_direct_pitch_angle(origin, view_to);
     const auto dir = (view_to - origin).normalized();
-    EXPECT_NEAR(pitch_calc, angles::radians_to_degrees(std::asin(dir.z)), 1e-3f);
+    EXPECT_NEAR(pitch_calc, angles::radians_to_degrees(std::asin(dir.z)), 1e-3);
 
     const auto yaw_calc = e::PredEngineTrait::calc_direct_yaw_angle(origin, view_to);
-    EXPECT_NEAR(yaw_calc, angles::radians_to_degrees(std::atan2(dir.y, dir.x)), 1e-3f);
+    EXPECT_NEAR(yaw_calc, angles::radians_to_degrees(std::atan2(dir.y, dir.x)), 1e-3);
 
     e::ViewAngles va;
     expect_matrix_near(e::MeshTrait::rotation_matrix(va), e::rotation_matrix(va));
 
-    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f);
+    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
     const auto expected = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f);
     expect_matrix_near(proj, expected);
 
+    const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    expect_matrix_near(proj_zo, expected_zo);
+    EXPECT_NE(proj, proj_zo);
+
     // non-airborne
     t.m_is_airborne = false;
-    const auto pred_ground_unreal = e::PredEngineTrait::predict_target_position(t, 2.f, 9.81f);
+    const auto pred_ground_unreal = e::PredEngineTrait::predict_target_position(t, 2.0, 9.81);
-    EXPECT_NEAR(pred_ground_unreal.x, 4.f, 1e-6f);
+    EXPECT_NEAR(pred_ground_unreal.x, 4.0, 1e-6);
+}
+
+// ── NDC Depth Range tests for Source and CryEngine camera traits ────────────
+
+TEST(NDCDepthRangeTests, Source_BothDepthRanges)
+{
+    namespace e = omath::source_engine;
+
+    const auto proj_no = e::CameraTrait::calc_projection_matrix(
+            projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f,
+            NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto expected_no = e::calc_perspective_projection_matrix(
+            90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    expect_matrix_near(proj_no, expected_no);
+
+    const auto proj_zo = e::CameraTrait::calc_projection_matrix(
+            projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f,
+            NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(
+            90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    expect_matrix_near(proj_zo, expected_zo);
+
+    EXPECT_NE(proj_no, proj_zo);
+}
+
+TEST(NDCDepthRangeTests, CryEngine_BothDepthRanges)
+{
+    namespace e = omath::cry_engine;
+
+    const auto proj_no = e::CameraTrait::calc_projection_matrix(
+            projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f,
+            NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto expected_no = e::calc_perspective_projection_matrix(
+            90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    expect_matrix_near(proj_no, expected_no);
+
+    const auto proj_zo = e::CameraTrait::calc_projection_matrix(
+            projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f,
+            NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(
+            90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    expect_matrix_near(proj_zo, expected_zo);
+
+    EXPECT_NE(proj_no, proj_zo);
+}
+
+// ── Verify Z mapping for ZERO_TO_ONE across all engines ─────────────────────
+
+// Helper: projects a point at given z through a left-handed projection matrix and returns NDC z
+template<class Type = float, MatStoreType Store = MatStoreType::ROW_MAJOR>
+static float project_z_lh(const Mat<4, 4, Type, Store>& proj, float z)
+{
+    auto clip = proj * mat_column_from_vector<Type, Store>({0, 0, static_cast<Type>(z)});
+    return static_cast<float>(clip.at(2, 0) / clip.at(3, 0));
+}
+
+TEST(NDCDepthRangeTests, Source_ZeroToOne_ZRange)
+{
+    namespace e = omath::source_engine;
+    // Source is left-handed
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+
+    EXPECT_NEAR(project_z_lh(proj, 0.1f), 0.0f, 1e-4f);
+    EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-4f);
+    EXPECT_GT(project_z_lh(proj, 500.f), 0.0f);
+    EXPECT_LT(project_z_lh(proj, 500.f), 1.0f);
+}
+
+TEST(NDCDepthRangeTests, IW_ZeroToOne_ZRange)
+{
+    namespace e = omath::iw_engine;
+    // IW is left-handed
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+
+    EXPECT_NEAR(project_z_lh(proj, 0.1f), 0.0f, 1e-4f);
+    EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-4f);
+    EXPECT_GT(project_z_lh(proj, 500.f), 0.0f);
+    EXPECT_LT(project_z_lh(proj, 500.f), 1.0f);
+}
+
+TEST(NDCDepthRangeTests, OpenGL_ZeroToOne_ZRange)
+{
+    namespace e = omath::opengl_engine;
+    // OpenGL is right-handed (negative z forward), column-major
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+
+    // OpenGL engine uses column-major matrices, project manually
+    auto proj_z = [&](float z) {
+        auto clip = proj * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>({0, 0, z});
+        return clip.at(2, 0) / clip.at(3, 0);
+    };
+
+    EXPECT_NEAR(proj_z(-0.1f), 0.0f, 1e-4f);
+    EXPECT_NEAR(proj_z(-1000.f), 1.0f, 1e-4f);
+    EXPECT_GT(proj_z(-500.f), 0.0f);
+    EXPECT_LT(proj_z(-500.f), 1.0f);
+}
+
+TEST(NDCDepthRangeTests, Frostbite_ZeroToOne_ZRange)
+{
+    namespace e = omath::frostbite_engine;
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+
+    EXPECT_NEAR(project_z_lh(proj, 0.1f), 0.0f, 1e-4f);
+    EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-4f);
+    EXPECT_GT(project_z_lh(proj, 500.f), 0.0f);
+    EXPECT_LT(project_z_lh(proj, 500.f), 1.0f);
+}
+
+TEST(NDCDepthRangeTests, Unity_ZeroToOne_ZRange)
+{
+    namespace e = omath::unity_engine;
+    // Unity is right-handed, row-major
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+
+    auto proj_z = [&](float z) {
+        auto clip = proj * mat_column_from_vector<float>({0, 0, z});
+        return clip.at(2, 0) / clip.at(3, 0);
+    };
+
+    EXPECT_NEAR(proj_z(-0.1f), 0.0f, 1e-4f);
+    EXPECT_NEAR(proj_z(-1000.f), 1.0f, 1e-4f);
+    EXPECT_GT(proj_z(-500.f), 0.0f);
+    EXPECT_LT(proj_z(-500.f), 1.0f);
+}
+
+TEST(NDCDepthRangeTests, Unreal_ZeroToOne_ZRange)
+{
+    namespace e = omath::unreal_engine;
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+
+    EXPECT_NEAR(project_z_lh(proj, 0.1f), 0.0f, 1e-4f);
+    EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-4f);
+    EXPECT_GT(project_z_lh(proj, 500.f), 0.0f);
+    EXPECT_LT(project_z_lh(proj, 500.f), 1.0f);
+}
+
+TEST(NDCDepthRangeTests, CryEngine_ZeroToOne_ZRange)
+{
+    namespace e = omath::cry_engine;
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+
+    EXPECT_NEAR(project_z_lh(proj, 0.1f), 0.0f, 1e-4f);
+    EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-4f);
+    EXPECT_GT(project_z_lh(proj, 500.f), 0.0f);
+    EXPECT_LT(project_z_lh(proj, 500.f), 1.0f);
+}
+
+// ── Verify Z mapping for NEGATIVE_ONE_TO_ONE across all engines ─────────────
+
+TEST(NDCDepthRangeTests, Source_NegativeOneToOne_ZRange)
+{
+    namespace e = omath::source_engine;
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+
+    EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f);
+    EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f);
+}
+
+TEST(NDCDepthRangeTests, IW_NegativeOneToOne_ZRange)
+{
+    namespace e = omath::iw_engine;
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+
+    EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f);
+    EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f);
+}
+
+TEST(NDCDepthRangeTests, Frostbite_NegativeOneToOne_ZRange)
+{
+    namespace e = omath::frostbite_engine;
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+
+    EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f);
+    EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f);
+}
+
+TEST(NDCDepthRangeTests, Unreal_NegativeOneToOne_ZRange)
+{
+    namespace e = omath::unreal_engine;
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+
+    EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f);
+    EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f);
+}
+
+TEST(NDCDepthRangeTests, CryEngine_NegativeOneToOne_ZRange)
+{
+    namespace e = omath::cry_engine;
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+
+    EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f);
+    EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f);
+}
+
+TEST(NDCDepthRangeTests, OpenGL_NegativeOneToOne_ZRange)
+{
+    namespace e = omath::opengl_engine;
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+
+    auto proj_z = [&](float z) {
+        auto clip = proj * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>({0, 0, z});
+        return clip.at(2, 0) / clip.at(3, 0);
+    };
+
+    EXPECT_NEAR(proj_z(-0.1f), -1.0f, 1e-3f);
+    EXPECT_NEAR(proj_z(-1000.f), 1.0f, 1e-3f);
+}
+
+TEST(NDCDepthRangeTests, Unity_NegativeOneToOne_ZRange)
+{
+    namespace e = omath::unity_engine;
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+
+    auto proj_z = [&](float z) {
+        auto clip = proj * mat_column_from_vector<float>({0, 0, z});
+        return clip.at(2, 0) / clip.at(3, 0);
+    };
+
+    EXPECT_NEAR(proj_z(-0.1f), -1.0f, 1e-3f);
+    EXPECT_NEAR(proj_z(-1000.f), 1.0f, 1e-3f);
 }

tests/engines/unit_test_unity_engine.cpp

@@ -417,3 +417,51 @@ TEST(unit_test_unity_engine, look_at_down)
          std::views::zip(dir_vector.as_array(), (-omath::unity_engine::k_abs_up).as_array()))
         EXPECT_NEAR(result, etalon, 0.0001f);
 }
+
+TEST(unit_test_unity_engine, ViewAnglesAsVector3Zero)
+{
+    const omath::unity_engine::ViewAngles angles{};
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 0.f);
+    EXPECT_FLOAT_EQ(vec.y, 0.f);
+    EXPECT_FLOAT_EQ(vec.z, 0.f);
+}
+
+TEST(unit_test_unity_engine, ViewAnglesAsVector3Values)
+{
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(45.f),
+        omath::unity_engine::YawAngle::from_degrees(-90.f),
+        omath::unity_engine::RollAngle::from_degrees(30.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 45.f);
+    EXPECT_FLOAT_EQ(vec.y, -90.f);
+    EXPECT_FLOAT_EQ(vec.z, 30.f);
+}
+
+TEST(unit_test_unity_engine, ViewAnglesAsVector3ClampedPitch)
+{
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(120.f),
+        omath::unity_engine::YawAngle::from_degrees(0.f),
+        omath::unity_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 90.f);
+}
+
+TEST(unit_test_unity_engine, ViewAnglesAsVector3NormalizedYaw)
+{
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(0.f),
+        omath::unity_engine::YawAngle::from_degrees(270.f),
+        omath::unity_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_NEAR(vec.y, -90.f, 0.01f);
+}

tests/engines/unit_test_unreal_engine.cpp

@@ -32,7 +32,7 @@ TEST(unit_test_unreal_engine, ForwardVectorRotationPitch)
 {
     omath::unreal_engine::ViewAngles angles;
 
-    angles.pitch = omath::unreal_engine::PitchAngle::from_degrees(-90.f);
+    angles.pitch = omath::unreal_engine::PitchAngle::from_degrees(90.f);
 
     const auto forward = omath::unreal_engine::forward_vector(angles);
     EXPECT_NEAR(forward.x, omath::unreal_engine::k_abs_up.x, 0.00001f);
@@ -44,7 +44,7 @@ TEST(unit_test_unreal_engine, ForwardVectorRotationRoll)
 {
     omath::unreal_engine::ViewAngles angles;
 
-    angles.roll = omath::unreal_engine::RollAngle::from_degrees(-90.f);
+    angles.roll = omath::unreal_engine::RollAngle::from_degrees(90.f);
 
     const auto forward = omath::unreal_engine::up_vector(angles);
     EXPECT_NEAR(forward.x, omath::unreal_engine::k_abs_right.x, 0.00001f);
@@ -111,7 +111,7 @@ TEST(unit_test_unreal_engine, CameraSetAndGetOrigin)
 {
     auto cam = omath::unreal_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, {}, 0.01f, 1000.f);
 
-    EXPECT_EQ(cam.get_origin(), omath::Vector3<float>{});
+    EXPECT_EQ(cam.get_origin(), omath::Vector3<double>{});
     cam.set_field_of_view(omath::projection::FieldOfView::from_degrees(50.f));
 
     EXPECT_EQ(cam.get_field_of_view().as_degrees(), 50.f);
@@ -129,7 +129,7 @@ TEST(unit_test_unreal_engine, loook_at_random_all_axis)
     std::size_t failed_points = 0;
     for (int i = 0; i < 100; i++)
     {
-        const auto position_to_look = omath::Vector3<float>{dist(gen), dist(gen), dist(gen)};
+        const auto position_to_look = omath::Vector3<double>{dist(gen), dist(gen), dist(gen)};
 
         if (cam.get_origin().distance_to(position_to_look) < 10)
             continue;
@@ -151,7 +151,7 @@ TEST(unit_test_unreal_engine, loook_at_random_all_axis)
 TEST(unit_test_unreal_engine, loook_at_random_x_axis)
 {
     std::mt19937 gen(std::random_device{}()); // Seed with a non-deterministic source
-    std::uniform_real_distribution<float> dist(-1000.f, 1000.f);
+    std::uniform_real_distribution<double> dist(-1000.f, 1000.f);
 
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     auto cam = omath::unreal_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.001f, 10000.f);
@@ -159,7 +159,7 @@ TEST(unit_test_unreal_engine, loook_at_random_x_axis)
     std::size_t failed_points = 0;
     for (int i = 0; i < 1000; i++)
     {
-        const auto position_to_look = omath::Vector3<float>{dist(gen), dist(gen), dist(gen)};
+        const auto position_to_look = omath::Vector3<double>{dist(gen), dist(gen), dist(gen)};
 
         if (cam.get_origin().distance_to(position_to_look) < 10)
             continue;
@@ -190,7 +190,7 @@ TEST(unit_test_unreal_engine, loook_at_random_y_axis)
     std::size_t failed_points = 0;
     for (int i = 0; i < 1000; i++)
     {
-        const auto position_to_look = omath::Vector3<float>{0.f, dist(gen), 0.f};
+        const auto position_to_look = omath::Vector3<double>{0.f, dist(gen), 0.f};
 
         if (cam.get_origin().distance_to(position_to_look) < 10)
             continue;
@@ -221,7 +221,7 @@ TEST(unit_test_unreal_engine, loook_at_random_z_axis)
     std::size_t failed_points = 0;
     for (int i = 0; i < 1000; i++)
     {
-        const auto position_to_look = omath::Vector3<float>{0.f, 0.f, dist(gen)};
+        const auto position_to_look = omath::Vector3<double>{0.f, 0.f, dist(gen)};
 
         if (cam.get_origin().distance_to(position_to_look) < 10)
             continue;
@@ -418,3 +418,51 @@ TEST(unit_test_unreal_engine, look_at_down)
     for (const auto& [result, etalon] : std::views::zip(dir_vector.as_array(), (-omath::unreal_engine::k_abs_up).as_array()))
         EXPECT_NEAR(result, etalon, 0.0001f);
 }
+
+TEST(unit_test_unreal_engine, ViewAnglesAsVector3Zero)
+{
+    const omath::unreal_engine::ViewAngles angles{};
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 0.f);
+    EXPECT_FLOAT_EQ(vec.y, 0.f);
+    EXPECT_FLOAT_EQ(vec.z, 0.f);
+}
+
+TEST(unit_test_unreal_engine, ViewAnglesAsVector3Values)
+{
+    const omath::unreal_engine::ViewAngles angles{
+        omath::unreal_engine::PitchAngle::from_degrees(45.f),
+        omath::unreal_engine::YawAngle::from_degrees(-90.f),
+        omath::unreal_engine::RollAngle::from_degrees(30.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 45.f);
+    EXPECT_FLOAT_EQ(vec.y, -90.f);
+    EXPECT_FLOAT_EQ(vec.z, 30.f);
+}
+
+TEST(unit_test_unreal_engine, ViewAnglesAsVector3ClampedPitch)
+{
+    const omath::unreal_engine::ViewAngles angles{
+        omath::unreal_engine::PitchAngle::from_degrees(120.f),
+        omath::unreal_engine::YawAngle::from_degrees(0.f),
+        omath::unreal_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_FLOAT_EQ(vec.x, 90.f);
+}
+
+TEST(unit_test_unreal_engine, ViewAnglesAsVector3NormalizedYaw)
+{
+    const omath::unreal_engine::ViewAngles angles{
+        omath::unreal_engine::PitchAngle::from_degrees(0.f),
+        omath::unreal_engine::YawAngle::from_degrees(270.f),
+        omath::unreal_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto vec = angles.as_vector3();
+
+    EXPECT_NEAR(vec.y, -90.f, 0.01f);
+}

tests/general/mem_fd_helper.hpp

@@ -20,8 +20,8 @@
 #include <vector>
 
 #if defined(__linux__)
-#  include <unistd.h>
 #include <fcntl.h>
+#include <unistd.h>
 #if defined(__ANDROID__)
 #if __ANDROID_API__ >= 30
 #include <sys/mman.h>
@@ -57,9 +57,11 @@ public:
     MemFdFile(MemFdFile&& o) noexcept
         : m_path(std::move(o.m_path))
 #if defined(OMATH_TEST_USE_MEMFD)
-        , m_fd(o.m_fd)
+          ,
+          m_fd(o.m_fd)
 #else
-        , m_temp_path(std::move(o.m_temp_path))
+          ,
+          m_temp_path(std::move(o.m_temp_path))
 #endif
     {
 #if defined(OMATH_TEST_USE_MEMFD)
@@ -69,9 +71,15 @@ public:
 #endif
     }
 
-    [[nodiscard]] bool valid() const { return !m_path.empty(); }
+    [[nodiscard]] bool valid() const
+    {
+        return !m_path.empty();
+    }
 
-    [[nodiscard]] const std::filesystem::path& path() const { return m_path; }
+    [[nodiscard]] const std::filesystem::path& path() const
+    {
+        return m_path;
+    }
 
     static MemFdFile create(const std::vector<std::uint8_t>& data)
     {
@@ -163,25 +171,27 @@ inline std::vector<std::uint8_t> build_minimal_pe(const std::vector<std::uint8_t
 
     std::vector<std::uint8_t> buf(data_off + section_bytes.size(), 0u);
 
-    buf[0] = 'M'; buf[1] = 'Z';
+    buf[0] = 'M';
+    buf[1] = 'Z';
     std::memcpy(buf.data() + 0x3Cu, &e_lfanew, 4);
 
-    buf[nt_off] = 'P'; buf[nt_off + 1] = 'E';
+    buf[nt_off] = 'P';
+    buf[nt_off + 1] = 'E';
 
-    const std::uint16_t machine = 0x8664u, num_sections = 1u;
+    constexpr std::uint16_t machine = 0x8664u, num_sections = 1u;
     std::memcpy(buf.data() + fh_off, &machine, 2);
     std::memcpy(buf.data() + fh_off + 2, &num_sections, 2);
     std::memcpy(buf.data() + fh_off + 16, &size_opt, 2);
 
-    const std::uint16_t magic = 0x20Bu;
+    constexpr std::uint16_t magic = 0x20Bu;
     std::memcpy(buf.data() + oh_off, &magic, 2);
 
-    const char name[8] = {'.','t','e','x','t',0,0,0};
+    constexpr char name[8] = {'.', 't', 'e', 'x', 't', 0, 0, 0};
     std::memcpy(buf.data() + sh_off, name, 8);
 
     const auto vsize = static_cast<std::uint32_t>(section_bytes.size());
-    const std::uint32_t vaddr   = 0x1000u;
+    constexpr std::uint32_t vaddr = 0x1000u;
-    const auto ptr_raw = static_cast<std::uint32_t>(data_off);
+    constexpr auto ptr_raw = static_cast<std::uint32_t>(data_off);
     std::memcpy(buf.data() + sh_off + 8, &vsize, 4);
     std::memcpy(buf.data() + sh_off + 12, &vaddr, 4);
     std::memcpy(buf.data() + sh_off + 16, &vsize, 4);

tests/general/unit_test_a_star.cpp

@@ -40,8 +40,9 @@ TEST(AStarExtra, TrivialNeighbor)
     nav.m_vertex_map[v2] = {v1};
 
     const auto path = Astar::find_path(v1, v2, nav);
-    ASSERT_EQ(path.size(), 1u);
+    ASSERT_EQ(path.size(), 2u);
-    EXPECT_EQ(path.front(), v2);
+    EXPECT_EQ(path.front(), v1);
+    EXPECT_EQ(path.back(), v2);
 }
 
 TEST(AStarExtra, StartEqualsGoal)
@@ -101,7 +102,7 @@ TEST(AStarExtra, LongerPathAvoidsBlock)
     constexpr Vector3<float> goal = idx(2, 1);
     const auto path = Astar::find_path(start, goal, nav);
     ASSERT_FALSE(path.empty());
-    EXPECT_EQ(path.front(), goal);
+    EXPECT_EQ(path.back(), goal);
 }
 
 TEST(AstarTests, TrivialDirectNeighborPath)
@@ -114,8 +115,9 @@ TEST(AstarTests, TrivialDirectNeighborPath)
     nav.m_vertex_map.emplace(v2, std::vector<Vector3<float>>{v1});
 
     const auto path = Astar::find_path(v1, v2, nav);
-    ASSERT_EQ(path.size(), 1u);
+    ASSERT_EQ(path.size(), 2u);
-    EXPECT_EQ(path.front(), v2);
+    EXPECT_EQ(path.front(), v1);
+    EXPECT_EQ(path.back(), v2);
 }
 
 TEST(AstarTests, NoPathWhenDisconnected)

tests/general/unit_test_aabb.cpp

@@ -0,0 +1,240 @@
+//
+// Created by Vladislav on 19.04.2026.
+//
+#include <gtest/gtest.h>
+#include "omath/3d_primitives/aabb.hpp"
+
+using AABB = omath::primitives::Aabb<float>;
+using Vec3 = omath::Vector3<float>;
+
+// --- center() ---
+
+TEST(AabbTests, CenterOfSymmetricBox)
+{
+    constexpr AABB box{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    constexpr auto c = box.center();
+    EXPECT_FLOAT_EQ(c.x, 0.f);
+    EXPECT_FLOAT_EQ(c.y, 0.f);
+    EXPECT_FLOAT_EQ(c.z, 0.f);
+}
+
+TEST(AabbTests, CenterOfOffsetBox)
+{
+    constexpr AABB box{{1.f, 2.f, 3.f}, {3.f, 6.f, 7.f}};
+    constexpr auto c = box.center();
+    EXPECT_FLOAT_EQ(c.x, 2.f);
+    EXPECT_FLOAT_EQ(c.y, 4.f);
+    EXPECT_FLOAT_EQ(c.z, 5.f);
+}
+
+TEST(AabbTests, CenterOfDegenerateBox)
+{
+    constexpr AABB box{{5.f, 5.f, 5.f}, {5.f, 5.f, 5.f}};
+    constexpr auto c = box.center();
+    EXPECT_FLOAT_EQ(c.x, 5.f);
+    EXPECT_FLOAT_EQ(c.y, 5.f);
+    EXPECT_FLOAT_EQ(c.z, 5.f);
+}
+
+// --- extents() ---
+
+TEST(AabbTests, ExtentsOfSymmetricBox)
+{
+    constexpr AABB box{{-2.f, -3.f, -4.f}, {2.f, 3.f, 4.f}};
+    constexpr auto e = box.extents();
+    EXPECT_FLOAT_EQ(e.x, 2.f);
+    EXPECT_FLOAT_EQ(e.y, 3.f);
+    EXPECT_FLOAT_EQ(e.z, 4.f);
+}
+
+TEST(AabbTests, ExtentsOfUnitBox)
+{
+    constexpr AABB box{{0.f, 0.f, 0.f}, {2.f, 2.f, 2.f}};
+    constexpr auto e = box.extents();
+    EXPECT_FLOAT_EQ(e.x, 1.f);
+    EXPECT_FLOAT_EQ(e.y, 1.f);
+    EXPECT_FLOAT_EQ(e.z, 1.f);
+}
+
+TEST(AabbTests, ExtentsOfDegenerateBox)
+{
+    constexpr AABB box{{3.f, 3.f, 3.f}, {3.f, 3.f, 3.f}};
+    constexpr auto e = box.extents();
+    EXPECT_FLOAT_EQ(e.x, 0.f);
+    EXPECT_FLOAT_EQ(e.y, 0.f);
+    EXPECT_FLOAT_EQ(e.z, 0.f);
+}
+
+using UpAxis = omath::primitives::UpAxis;
+
+// --- top() ---
+
+TEST(AabbTests, TopYUpSymmetricBox)
+{
+    constexpr AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
+    constexpr auto t = box.top<UpAxis::Y>();
+    EXPECT_FLOAT_EQ(t.x, 0.f);
+    EXPECT_FLOAT_EQ(t.y, 2.f);
+    EXPECT_FLOAT_EQ(t.z, 0.f);
+}
+
+TEST(AabbTests, TopYUpOffsetBox)
+{
+    constexpr AABB box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
+    constexpr auto t = box.top<UpAxis::Y>();
+    EXPECT_FLOAT_EQ(t.x, 2.f);
+    EXPECT_FLOAT_EQ(t.y, 10.f);
+    EXPECT_FLOAT_EQ(t.z, 4.f);
+}
+
+TEST(AabbTests, TopZUpSymmetricBox)
+{
+    constexpr AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
+    constexpr auto t = box.top<UpAxis::Z>();
+    EXPECT_FLOAT_EQ(t.x, 0.f);
+    EXPECT_FLOAT_EQ(t.y, 0.f);
+    EXPECT_FLOAT_EQ(t.z, 3.f);
+}
+
+TEST(AabbTests, TopZUpOffsetBox)
+{
+    constexpr AABB box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
+    constexpr auto t = box.top<UpAxis::Z>();
+    EXPECT_FLOAT_EQ(t.x, 2.f);
+    EXPECT_FLOAT_EQ(t.y, 7.f);
+    EXPECT_FLOAT_EQ(t.z, 6.f);
+}
+
+TEST(AabbTests, TopDefaultIsYUp)
+{
+    constexpr AABB box{{0.f, 0.f, 0.f}, {2.f, 4.f, 6.f}};
+    EXPECT_EQ(box.top(), box.top<UpAxis::Y>());
+}
+
+// --- bottom() ---
+
+TEST(AabbTests, BottomYUpSymmetricBox)
+{
+    constexpr AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
+    constexpr auto b = box.bottom<UpAxis::Y>();
+    EXPECT_FLOAT_EQ(b.x, 0.f);
+    EXPECT_FLOAT_EQ(b.y, -2.f);
+    EXPECT_FLOAT_EQ(b.z, 0.f);
+}
+
+TEST(AabbTests, BottomYUpOffsetBox)
+{
+    constexpr AABB box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
+    constexpr auto b = box.bottom<UpAxis::Y>();
+    EXPECT_FLOAT_EQ(b.x, 2.f);
+    EXPECT_FLOAT_EQ(b.y, 4.f);
+    EXPECT_FLOAT_EQ(b.z, 4.f);
+}
+
+TEST(AabbTests, BottomZUpSymmetricBox)
+{
+    constexpr AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
+    constexpr auto b = box.bottom<UpAxis::Z>();
+    EXPECT_FLOAT_EQ(b.x, 0.f);
+    EXPECT_FLOAT_EQ(b.y, 0.f);
+    EXPECT_FLOAT_EQ(b.z, -3.f);
+}
+
+TEST(AabbTests, BottomZUpOffsetBox)
+{
+    constexpr AABB box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
+    constexpr auto b = box.bottom<UpAxis::Z>();
+    EXPECT_FLOAT_EQ(b.x, 2.f);
+    EXPECT_FLOAT_EQ(b.y, 7.f);
+    EXPECT_FLOAT_EQ(b.z, 2.f);
+}
+
+TEST(AabbTests, BottomDefaultIsYUp)
+{
+    constexpr AABB box{{0.f, 0.f, 0.f}, {2.f, 4.f, 6.f}};
+    EXPECT_EQ(box.bottom(), box.bottom<UpAxis::Y>());
+}
+
+TEST(AabbTests, TopAndBottomAreSymmetric)
+{
+    constexpr AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
+    EXPECT_FLOAT_EQ(box.top<UpAxis::Y>().y, -box.bottom<UpAxis::Y>().y);
+    EXPECT_FLOAT_EQ(box.top<UpAxis::Z>().z, -box.bottom<UpAxis::Z>().z);
+}
+
+// --- is_collide() ---
+
+TEST(AabbTests, OverlappingBoxesCollide)
+{
+    constexpr AABB a{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    constexpr AABB b{{0.f, 0.f, 0.f}, {2.f, 2.f, 2.f}};
+    EXPECT_TRUE(a.is_collide(b));
+    EXPECT_TRUE(b.is_collide(a));
+}
+
+TEST(AabbTests, SeparatedBoxesDoNotCollide)
+{
+    constexpr AABB a{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    constexpr AABB b{{2.f, 2.f, 2.f}, {4.f, 4.f, 4.f}};
+    EXPECT_FALSE(a.is_collide(b));
+    EXPECT_FALSE(b.is_collide(a));
+}
+
+TEST(AabbTests, TouchingFacesCollide)
+{
+    constexpr AABB a{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    constexpr AABB b{{1.f, -1.f, -1.f}, {3.f, 1.f, 1.f}};
+    EXPECT_TRUE(a.is_collide(b));
+    EXPECT_TRUE(b.is_collide(a));
+}
+
+TEST(AabbTests, ContainedBoxCollides)
+{
+    constexpr AABB outer{{-3.f, -3.f, -3.f}, {3.f, 3.f, 3.f}};
+    constexpr AABB inner{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    EXPECT_TRUE(outer.is_collide(inner));
+    EXPECT_TRUE(inner.is_collide(outer));
+}
+
+TEST(AabbTests, SeparatedOnXAxisDoNotCollide)
+{
+    constexpr AABB a{{0.f, 0.f, 0.f}, {1.f, 1.f, 1.f}};
+    constexpr AABB b{{2.f, 0.f, 0.f}, {3.f, 1.f, 1.f}};
+    EXPECT_FALSE(a.is_collide(b));
+}
+
+TEST(AabbTests, SeparatedOnYAxisDoNotCollide)
+{
+    constexpr AABB a{{0.f, 0.f, 0.f}, {1.f, 1.f, 1.f}};
+    constexpr AABB b{{0.f, 2.f, 0.f}, {1.f, 3.f, 1.f}};
+    EXPECT_FALSE(a.is_collide(b));
+}
+
+TEST(AabbTests, SeparatedOnZAxisDoNotCollide)
+{
+    constexpr AABB a{{0.f, 0.f, 0.f}, {1.f, 1.f, 1.f}};
+    constexpr AABB b{{0.f, 0.f, 2.f}, {1.f, 1.f, 3.f}};
+    EXPECT_FALSE(a.is_collide(b));
+}
+
+TEST(AabbTests, IdenticalBoxesCollide)
+{
+    constexpr AABB a{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    EXPECT_TRUE(a.is_collide(a));
+}
+
+TEST(AabbTests, DegeneratePointBoxCollidesWhenInsideOther)
+{
+    constexpr AABB box{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    constexpr AABB point{{0.f, 0.f, 0.f}, {0.f, 0.f, 0.f}};
+    EXPECT_TRUE(box.is_collide(point));
+    EXPECT_TRUE(point.is_collide(box));
+}
+
+TEST(AabbTests, DegeneratePointBoxDoesNotCollideWhenOutside)
+{
+    constexpr AABB box{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    constexpr AABB point{{5.f, 0.f, 0.f}, {5.f, 0.f, 0.f}};
+    EXPECT_FALSE(box.is_collide(point));
+    EXPECT_FALSE(point.is_collide(box));
+}

tests/general/unit_test_cry_pred_engine_trait.cpp

@@ -0,0 +1,275 @@
+//
+// Created by Vladislav on 20.04.2026.
+//
+#include <gtest/gtest.h>
+#include <omath/engines/cry_engine/traits/pred_engine_trait.hpp>
+#include <omath/projectile_prediction/projectile.hpp>
+#include <omath/projectile_prediction/target.hpp>
+
+using namespace omath;
+using namespace omath::cry_engine;
+
+// ---- predict_projectile_position ----
+
+TEST(CryPredEngineTrait, PredictProjectilePositionAtTimeZero)
+{
+    projectile_prediction::Projectile p;
+    p.m_origin       = {1.f, 2.f, 3.f};
+    p.m_launch_offset = {4.f, 5.f, 6.f};
+    p.m_launch_speed  = 100.f;
+    p.m_gravity_scale = 1.f;
+
+    const auto pos = PredEngineTrait::predict_projectile_position(p, 0.f, 0.f, 0.f, 9.81f);
+
+    // At t=0 no velocity is applied, just origin+offset
+    EXPECT_NEAR(pos.x, 5.f, 1e-4f);
+    EXPECT_NEAR(pos.y, 7.f, 1e-4f);
+    EXPECT_NEAR(pos.z, 9.f, 1e-4f);
+}
+
+TEST(CryPredEngineTrait, PredictProjectilePositionZeroAnglesForwardIsY)
+{
+    // Cry engine forward = +Y. At pitch=0, yaw=0 the projectile travels along +Y.
+    projectile_prediction::Projectile p;
+    p.m_origin       = {0.f, 0.f, 0.f};
+    p.m_launch_speed  = 10.f;
+    p.m_gravity_scale = 0.f; // no gravity so we isolate direction
+
+    const auto pos = PredEngineTrait::predict_projectile_position(p, 0.f, 0.f, 1.f, 9.81f);
+
+    EXPECT_NEAR(pos.x, 0.f, 1e-4f);
+    EXPECT_NEAR(pos.y, 10.f, 1e-4f);
+    EXPECT_NEAR(pos.z, 0.f, 1e-4f);
+}
+
+TEST(CryPredEngineTrait, PredictProjectilePositionGravityDropsZ)
+{
+    projectile_prediction::Projectile p;
+    p.m_origin       = {0.f, 0.f, 0.f};
+    p.m_launch_speed  = 10.f;
+    p.m_gravity_scale = 1.f;
+
+    const auto pos = PredEngineTrait::predict_projectile_position(p, 0.f, 0.f, 2.f, 9.81f);
+
+    // z = 0 - (9.81 * 1) * (4) * 0.5 = -19.62
+    EXPECT_NEAR(pos.z, -9.81f * 4.f * 0.5f, 1e-3f);
+}
+
+TEST(CryPredEngineTrait, PredictProjectilePositionGravityScaleZeroNoZDrop)
+{
+    projectile_prediction::Projectile p;
+    p.m_origin       = {0.f, 0.f, 0.f};
+    p.m_launch_speed  = 10.f;
+    p.m_gravity_scale = 0.f;
+
+    const auto pos = PredEngineTrait::predict_projectile_position(p, 0.f, 0.f, 3.f, 9.81f);
+
+    EXPECT_NEAR(pos.z, 0.f, 1e-4f);
+}
+
+TEST(CryPredEngineTrait, PredictProjectilePositionWithLaunchOffset)
+{
+    projectile_prediction::Projectile p;
+    p.m_origin        = {5.f, 0.f, 0.f};
+    p.m_launch_offset = {0.f, 0.f, 2.f};
+    p.m_launch_speed  = 10.f;
+    p.m_gravity_scale = 0.f;
+
+    const auto pos = PredEngineTrait::predict_projectile_position(p, 0.f, 0.f, 1.f, 0.f);
+
+    // launch position = {5, 0, 2}, travels along +Y by 10
+    EXPECT_NEAR(pos.x, 5.f,  1e-4f);
+    EXPECT_NEAR(pos.y, 10.f, 1e-4f);
+    EXPECT_NEAR(pos.z, 2.f,  1e-4f);
+}
+
+// ---- predict_target_position ----
+
+TEST(CryPredEngineTrait, PredictTargetPositionGroundedStationary)
+{
+    projectile_prediction::Target t;
+    t.m_origin     = {10.f, 20.f, 5.f};
+    t.m_velocity   = {0.f, 0.f, 0.f};
+    t.m_is_airborne = false;
+
+    const auto pred = PredEngineTrait::predict_target_position(t, 5.f, 9.81f);
+
+    EXPECT_NEAR(pred.x, 10.f, 1e-6f);
+    EXPECT_NEAR(pred.y, 20.f, 1e-6f);
+    EXPECT_NEAR(pred.z,  5.f, 1e-6f);
+}
+
+TEST(CryPredEngineTrait, PredictTargetPositionGroundedMoving)
+{
+    projectile_prediction::Target t;
+    t.m_origin     = {0.f, 0.f, 0.f};
+    t.m_velocity   = {3.f, 4.f, 0.f};
+    t.m_is_airborne = false;
+
+    const auto pred = PredEngineTrait::predict_target_position(t, 2.f, 9.81f);
+
+    EXPECT_NEAR(pred.x, 6.f,  1e-6f);
+    EXPECT_NEAR(pred.y, 8.f,  1e-6f);
+    EXPECT_NEAR(pred.z, 0.f,  1e-6f); // grounded — no gravity
+}
+
+TEST(CryPredEngineTrait, PredictTargetPositionAirborneGravityDropsZ)
+{
+    projectile_prediction::Target t;
+    t.m_origin     = {0.f, 0.f, 20.f};
+    t.m_velocity   = {0.f, 0.f, 0.f};
+    t.m_is_airborne = true;
+
+    const auto pred = PredEngineTrait::predict_target_position(t, 2.f, 9.81f);
+
+    // z = 20 - 9.81 * 4 * 0.5 = 20 - 19.62 = 0.38
+    EXPECT_NEAR(pred.z, 20.f - 9.81f * 4.f * 0.5f, 1e-4f);
+}
+
+TEST(CryPredEngineTrait, PredictTargetPositionAirborneMovingWithGravity)
+{
+    projectile_prediction::Target t;
+    t.m_origin     = {0.f, 0.f, 50.f};
+    t.m_velocity   = {10.f, 5.f, 0.f};
+    t.m_is_airborne = true;
+
+    const auto pred = PredEngineTrait::predict_target_position(t, 3.f, 9.81f);
+
+    EXPECT_NEAR(pred.x, 30.f, 1e-4f);
+    EXPECT_NEAR(pred.y, 15.f, 1e-4f);
+    EXPECT_NEAR(pred.z, 50.f - 9.81f * 9.f * 0.5f, 1e-4f);
+}
+
+// ---- calc_vector_2d_distance ----
+
+TEST(CryPredEngineTrait, CalcVector2dDistance_3_4_5)
+{
+    EXPECT_NEAR(PredEngineTrait::calc_vector_2d_distance({3.f, 4.f, 999.f}), 5.f, 1e-5f);
+}
+
+TEST(CryPredEngineTrait, CalcVector2dDistance_ZeroVector)
+{
+    EXPECT_NEAR(PredEngineTrait::calc_vector_2d_distance({0.f, 0.f, 0.f}), 0.f, 1e-6f);
+}
+
+TEST(CryPredEngineTrait, CalcVector2dDistance_ZIgnored)
+{
+    // Z does not affect the 2D distance
+    EXPECT_NEAR(PredEngineTrait::calc_vector_2d_distance({0.f, 5.f, 100.f}),
+                PredEngineTrait::calc_vector_2d_distance({0.f, 5.f, 0.f}), 1e-6f);
+}
+
+// ---- get_vector_height_coordinate ----
+
+TEST(CryPredEngineTrait, GetVectorHeightCoordinate_ReturnsZ)
+{
+    // Cry engine up = +Z
+    EXPECT_FLOAT_EQ(PredEngineTrait::get_vector_height_coordinate({1.f, 2.f, 7.f}), 7.f);
+}
+
+// ---- calc_direct_pitch_angle ----
+
+TEST(CryPredEngineTrait, CalcDirectPitchAngle_Flat)
+{
+    // Target at same height → pitch = 0
+    EXPECT_NEAR(PredEngineTrait::calc_direct_pitch_angle({0.f, 0.f, 0.f}, {0.f, 100.f, 0.f}), 0.f, 1e-4f);
+}
+
+TEST(CryPredEngineTrait, CalcDirectPitchAngle_LookingUp)
+{
+    // Target at 45° above (equal XY distance and Z height)
+    // direction to {0, 1, 1} normalized = {0, 0.707, 0.707}, asin(0.707) = 45°
+    EXPECT_NEAR(PredEngineTrait::calc_direct_pitch_angle({0.f, 0.f, 0.f}, {0.f, 1.f, 1.f}), 45.f, 1e-3f);
+}
+
+TEST(CryPredEngineTrait, CalcDirectPitchAngle_LookingDown)
+{
+    // Target directly below
+    EXPECT_NEAR(PredEngineTrait::calc_direct_pitch_angle({0.f, 0.f, 10.f}, {0.f, 0.f, 0.f}), -90.f, 1e-3f);
+}
+
+TEST(CryPredEngineTrait, CalcDirectPitchAngle_LookingDirectlyUp)
+{
+    EXPECT_NEAR(PredEngineTrait::calc_direct_pitch_angle({0.f, 0.f, 0.f}, {0.f, 0.f, 100.f}), 90.f, 1e-3f);
+}
+
+// ---- calc_direct_yaw_angle ----
+
+TEST(CryPredEngineTrait, CalcDirectYawAngle_ForwardAlongY)
+{
+    // Cry engine forward = +Y → yaw = 0
+    EXPECT_NEAR(PredEngineTrait::calc_direct_yaw_angle({0.f, 0.f, 0.f}, {0.f, 100.f, 0.f}), 0.f, 1e-4f);
+}
+
+TEST(CryPredEngineTrait, CalcDirectYawAngle_AlongPositiveX)
+{
+    // direction = {1, 0, 0}, yaw = -atan2(1, 0) = -90°
+    EXPECT_NEAR(PredEngineTrait::calc_direct_yaw_angle({0.f, 0.f, 0.f}, {100.f, 0.f, 0.f}), -90.f, 1e-3f);
+}
+
+TEST(CryPredEngineTrait, CalcDirectYawAngle_AlongNegativeX)
+{
+    // direction = {-1, 0, 0}, yaw = -atan2(-1, 0) = 90°
+    EXPECT_NEAR(PredEngineTrait::calc_direct_yaw_angle({0.f, 0.f, 0.f}, {-100.f, 0.f, 0.f}), 90.f, 1e-3f);
+}
+
+TEST(CryPredEngineTrait, CalcDirectYawAngle_BackwardAlongNegY)
+{
+    // direction = {0, -1, 0}, yaw = -atan2(0, -1) = ±180°
+    const float yaw = PredEngineTrait::calc_direct_yaw_angle({0.f, 0.f, 0.f}, {0.f, -100.f, 0.f});
+    EXPECT_NEAR(std::abs(yaw), 180.f, 1e-3f);
+}
+
+TEST(CryPredEngineTrait, CalcDirectYawAngle_OffOriginCamera)
+{
+    // Same relative direction regardless of camera position
+    const float yaw_a = PredEngineTrait::calc_direct_yaw_angle({0.f, 0.f, 0.f}, {0.f, 100.f, 0.f});
+    const float yaw_b = PredEngineTrait::calc_direct_yaw_angle({50.f, 50.f, 0.f}, {50.f, 150.f, 0.f});
+    EXPECT_NEAR(yaw_a, yaw_b, 1e-4f);
+}
+
+// ---- calc_viewpoint_from_angles ----
+
+TEST(CryPredEngineTrait, CalcViewpointFromAngles_45Degrees)
+{
+    projectile_prediction::Projectile p;
+    p.m_origin      = {0.f, 0.f, 0.f};
+    p.m_launch_speed = 10.f;
+
+    // Target along +Y at distance 10; pitch=45° → height = 10 * tan(45°) = 10
+    const Vector3<float> target{0.f, 10.f, 0.f};
+    const auto vp = PredEngineTrait::calc_viewpoint_from_angles(p, target, 45.f);
+
+    EXPECT_NEAR(vp.x, 0.f,  1e-4f);
+    EXPECT_NEAR(vp.y, 10.f, 1e-4f);
+    EXPECT_NEAR(vp.z, 10.f, 1e-3f);
+}
+
+TEST(CryPredEngineTrait, CalcViewpointFromAngles_ZeroPitch)
+{
+    projectile_prediction::Projectile p;
+    p.m_origin      = {0.f, 0.f, 5.f};
+    p.m_launch_speed = 1.f;
+
+    const Vector3<float> target{3.f, 4.f, 0.f};
+    const auto vp = PredEngineTrait::calc_viewpoint_from_angles(p, target, 0.f);
+
+    // tan(0) = 0 → viewpoint Z = origin.z + 0 = 5
+    EXPECT_NEAR(vp.x, 3.f, 1e-4f);
+    EXPECT_NEAR(vp.y, 4.f, 1e-4f);
+    EXPECT_NEAR(vp.z, 5.f, 1e-4f);
+}
+
+TEST(CryPredEngineTrait, CalcViewpointXYMatchesPredictedTargetXY)
+{
+    projectile_prediction::Projectile p;
+    p.m_origin      = {1.f, 2.f, 3.f};
+    p.m_launch_speed = 50.f;
+
+    const Vector3<float> target{10.f, 20.f, 5.f};
+    const auto vp = PredEngineTrait::calc_viewpoint_from_angles(p, target, 30.f);
+
+    // X and Y always match the predicted target position
+    EXPECT_NEAR(vp.x, target.x, 1e-4f);
+    EXPECT_NEAR(vp.y, target.y, 1e-4f);
+}

tests/general/unit_test_line_tracer_aabb.cpp

@@ -0,0 +1,125 @@
+//
+// Created by Vlad on 3/25/2025.
+//
+#include "omath/collision/line_tracer.hpp"
+#include "omath/3d_primitives/aabb.hpp"
+#include <gtest/gtest.h>
+
+using Vec3 = omath::Vector3<float>;
+using Ray = omath::collision::Ray<>;
+using LineTracer = omath::collision::LineTracer<>;
+using AABB = omath::primitives::Aabb<float>;
+
+static Ray make_ray(Vec3 start, Vec3 end, bool infinite = false)
+{
+    Ray r;
+    r.start = start;
+    r.end = end;
+    r.infinite_length = infinite;
+    return r;
+}
+
+// Ray passing straight through the center along Z axis
+TEST(LineTracerAABBTests, HitCenterAlongZ)
+{
+    const AABB box{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    const auto ray = make_ray({0.f, 0.f, -5.f}, {0.f, 0.f, 5.f});
+
+    const auto hit = LineTracer::get_ray_hit_point(ray, box);
+    EXPECT_NE(hit, ray.end);
+    EXPECT_NEAR(hit.z, -1.f, 1e-4f);
+    EXPECT_NEAR(hit.x, 0.f, 1e-4f);
+    EXPECT_NEAR(hit.y, 0.f, 1e-4f);
+}
+
+// Ray passing straight through the center along X axis
+TEST(LineTracerAABBTests, HitCenterAlongX)
+{
+    const AABB box{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    const auto ray = make_ray({-5.f, 0.f, 0.f}, {5.f, 0.f, 0.f});
+
+    const auto hit = LineTracer::get_ray_hit_point(ray, box);
+    EXPECT_NE(hit, ray.end);
+    EXPECT_NEAR(hit.x, -1.f, 1e-4f);
+}
+
+// Ray that misses entirely (too far in Y)
+TEST(LineTracerAABBTests, MissReturnsEnd)
+{
+    const AABB box{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    const auto ray = make_ray({0.f, 5.f, -5.f}, {0.f, 5.f, 5.f});
+
+    const auto hit = LineTracer::get_ray_hit_point(ray, box);
+    EXPECT_EQ(hit, ray.end);
+}
+
+// Ray that stops short before reaching the box
+TEST(LineTracerAABBTests, RayTooShortReturnsEnd)
+{
+    const AABB box{{3.f, -1.f, -1.f}, {5.f, 1.f, 1.f}};
+    const auto ray = make_ray({0.f, 0.f, 0.f}, {2.f, 0.f, 0.f});
+
+    const auto hit = LineTracer::get_ray_hit_point(ray, box);
+    EXPECT_EQ(hit, ray.end);
+}
+
+// Infinite ray that starts before the box should hit
+TEST(LineTracerAABBTests, InfiniteRayHits)
+{
+    const AABB box{{3.f, -1.f, -1.f}, {5.f, 1.f, 1.f}};
+    const auto ray = make_ray({0.f, 0.f, 0.f}, {2.f, 0.f, 0.f}, true);
+
+    const auto hit = LineTracer::get_ray_hit_point(ray, box);
+    EXPECT_NE(hit, ray.end);
+    EXPECT_NEAR(hit.x, 3.f, 1e-4f);
+}
+
+// Ray starting inside the box — t_min=0, so hit point equals ray.start
+TEST(LineTracerAABBTests, RayStartsInsideBox)
+{
+    const AABB box{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    const auto ray = make_ray({0.f, 0.f, 0.f}, {0.f, 0.f, 5.f});
+
+    const auto hit = LineTracer::get_ray_hit_point(ray, box);
+    EXPECT_NE(hit, ray.end);
+    // t_min is clamped to 0, so hit == start
+    EXPECT_NEAR(hit.x, 0.f, 1e-4f);
+    EXPECT_NEAR(hit.y, 0.f, 1e-4f);
+    EXPECT_NEAR(hit.z, 0.f, 1e-4f);
+}
+
+// Ray parallel to XY plane, pointing along X, at Z outside the box
+TEST(LineTracerAABBTests, ParallelRayOutsideSlabMisses)
+{
+    const AABB box{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    // Z component of ray is 3.0 — outside box's Z slab
+    const auto ray = make_ray({-5.f, 0.f, 3.f}, {5.f, 0.f, 3.f});
+
+    const auto hit = LineTracer::get_ray_hit_point(ray, box);
+    EXPECT_EQ(hit, ray.end);
+}
+
+// Ray parallel to XY plane, pointing along X, at Z inside the box
+TEST(LineTracerAABBTests, ParallelRayInsideSlabHits)
+{
+    const AABB box{{-1.f, -1.f, -1.f}, {1.f, 1.f, 1.f}};
+    const auto ray = make_ray({-5.f, 0.f, 0.f}, {5.f, 0.f, 0.f});
+
+    const auto hit = LineTracer::get_ray_hit_point(ray, box);
+    EXPECT_NE(hit, ray.end);
+    EXPECT_NEAR(hit.x, -1.f, 1e-4f);
+}
+
+// Diagonal ray hitting a corner region
+TEST(LineTracerAABBTests, DiagonalRayHits)
+{
+    const AABB box{{0.f, 0.f, 0.f}, {2.f, 2.f, 2.f}};
+    const auto ray = make_ray({-1.f, -1.f, -1.f}, {3.f, 3.f, 3.f});
+
+    const auto hit = LineTracer::get_ray_hit_point(ray, box);
+    EXPECT_NE(hit, ray.end);
+    // Entry point should be at (0,0,0)
+    EXPECT_NEAR(hit.x, 0.f, 1e-4f);
+    EXPECT_NEAR(hit.y, 0.f, 1e-4f);
+    EXPECT_NEAR(hit.z, 0.f, 1e-4f);
+}

tests/general/unit_test_mat.cpp

@@ -220,8 +220,8 @@ TEST(UnitTestMatStandalone, Equanity)
     constexpr omath::Vector3<float> left_handed = {0, 2, 10};
     constexpr omath::Vector3<float> right_handed = {0, 2, -10};
 
-    const auto proj_left_handed = omath::mat_perspective_left_handed(90.f, 16.f / 9.f, 0.1, 1000);
+    const auto proj_left_handed = omath::mat_perspective_left_handed(90.f, 16.f / 9.f, 0.1f, 1000.f);
-    const auto proj_right_handed = omath::mat_perspective_right_handed(90.f, 16.f / 9.f, 0.1, 1000);
+    const auto proj_right_handed = omath::mat_perspective_right_handed(90.f, 16.f / 9.f, 0.1f, 1000.f);
 
     auto ndc_left_handed = proj_left_handed * omath::mat_column_from_vector(left_handed);
     auto ndc_right_handed = proj_right_handed * omath::mat_column_from_vector(right_handed);
@@ -241,3 +241,125 @@ TEST(UnitTestMatStandalone, MatPerspectiveLeftHanded)
 
     EXPECT_TRUE(projected.at(2, 0) > -1.0f && projected.at(2, 0) < 0.f);
 }
+
+TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedZeroToOne)
+{
+    const auto proj = mat_perspective_left_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+            90.f, 16.f / 9.f, 0.1f, 1000.f);
+
+    // Near plane point should map to z ~ 0
+    auto near_pt = proj * mat_column_from_vector<float>({0, 0, 0.1f});
+    near_pt /= near_pt.at(3, 0);
+    EXPECT_NEAR(near_pt.at(2, 0), 0.0f, 1e-4f);
+
+    // Far plane point should map to z ~ 1
+    auto far_pt = proj * mat_column_from_vector<float>({0, 0, 1000.f});
+    far_pt /= far_pt.at(3, 0);
+    EXPECT_NEAR(far_pt.at(2, 0), 1.0f, 1e-4f);
+
+    // Mid-range point should be in [0, 1]
+    auto mid_pt = proj * mat_column_from_vector<float>({0, 0, 500.f});
+    mid_pt /= mid_pt.at(3, 0);
+    EXPECT_GT(mid_pt.at(2, 0), 0.0f);
+    EXPECT_LT(mid_pt.at(2, 0), 1.0f);
+}
+
+TEST(UnitTestMatStandalone, MatPerspectiveRightHandedZeroToOne)
+{
+    const auto proj = mat_perspective_right_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+            90.f, 16.f / 9.f, 0.1f, 1000.f);
+
+    // Near plane point (negative z for right-handed) should map to z ~ 0
+    auto near_pt = proj * mat_column_from_vector<float>({0, 0, -0.1f});
+    near_pt /= near_pt.at(3, 0);
+    EXPECT_NEAR(near_pt.at(2, 0), 0.0f, 1e-4f);
+
+    // Far plane point should map to z ~ 1
+    auto far_pt = proj * mat_column_from_vector<float>({0, 0, -1000.f});
+    far_pt /= far_pt.at(3, 0);
+    EXPECT_NEAR(far_pt.at(2, 0), 1.0f, 1e-4f);
+
+    // Mid-range point should be in [0, 1]
+    auto mid_pt = proj * mat_column_from_vector<float>({0, 0, -500.f});
+    mid_pt /= mid_pt.at(3, 0);
+    EXPECT_GT(mid_pt.at(2, 0), 0.0f);
+    EXPECT_LT(mid_pt.at(2, 0), 1.0f);
+}
+
+TEST(UnitTestMatStandalone, MatPerspectiveNegativeOneToOneRange)
+{
+    // Verify existing [-1, 1] behavior with explicit template arg matches default
+    const auto proj_default = mat_perspective_left_handed(90.f, 16.f / 9.f, 0.1f, 1000.f);
+    const auto proj_explicit = mat_perspective_left_handed<float, MatStoreType::ROW_MAJOR,
+            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(90.f, 16.f / 9.f, 0.1f, 1000.f);
+
+    EXPECT_EQ(proj_default, proj_explicit);
+
+    // Near plane should map to z ~ -1
+    auto near_pt = proj_default * mat_column_from_vector<float>({0, 0, 0.1f});
+    near_pt /= near_pt.at(3, 0);
+    EXPECT_NEAR(near_pt.at(2, 0), -1.0f, 1e-3f);
+
+    // Far plane should map to z ~ 1
+    auto far_pt = proj_default * mat_column_from_vector<float>({0, 0, 1000.f});
+    far_pt /= far_pt.at(3, 0);
+    EXPECT_NEAR(far_pt.at(2, 0), 1.0f, 1e-3f);
+}
+
+TEST(UnitTestMatStandalone, MatPerspectiveZeroToOneEquanity)
+{
+    // LH and RH should produce same NDC for mirrored z
+    constexpr omath::Vector3<float> left_handed = {0, 2, 10};
+    constexpr omath::Vector3<float> right_handed = {0, 2, -10};
+
+    const auto proj_lh = mat_perspective_left_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+            90.f, 16.f / 9.f, 0.1f, 1000.f);
+    const auto proj_rh = mat_perspective_right_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+            90.f, 16.f / 9.f, 0.1f, 1000.f);
+
+    auto ndc_lh = proj_lh * mat_column_from_vector(left_handed);
+    auto ndc_rh = proj_rh * mat_column_from_vector(right_handed);
+
+    ndc_lh /= ndc_lh.at(3, 0);
+    ndc_rh /= ndc_rh.at(3, 0);
+
+    EXPECT_EQ(ndc_lh, ndc_rh);
+}
+
+TEST(UnitTestMatStandalone, MatOrthoLeftHandedZeroToOne)
+{
+    const auto ortho = mat_ortho_left_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+            -1.f, 1.f, -1.f, 1.f, 0.1f, 100.f);
+
+    // Near plane should map to z ~ 0
+    auto near_pt = ortho * mat_column_from_vector<float>({0, 0, 0.1f});
+    EXPECT_NEAR(near_pt.at(2, 0), 0.0f, 1e-4f);
+
+    // Far plane should map to z ~ 1
+    auto far_pt = ortho * mat_column_from_vector<float>({0, 0, 100.f});
+    EXPECT_NEAR(far_pt.at(2, 0), 1.0f, 1e-4f);
+}
+
+TEST(UnitTestMatStandalone, MatOrthoRightHandedZeroToOne)
+{
+    const auto ortho = mat_ortho_right_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+            -1.f, 1.f, -1.f, 1.f, 0.1f, 100.f);
+
+    // Near plane (negative z for RH) should map to z ~ 0
+    auto near_pt = ortho * mat_column_from_vector<float>({0, 0, -0.1f});
+    EXPECT_NEAR(near_pt.at(2, 0), 0.0f, 1e-4f);
+
+    // Far plane should map to z ~ 1
+    auto far_pt = ortho * mat_column_from_vector<float>({0, 0, -100.f});
+    EXPECT_NEAR(far_pt.at(2, 0), 1.0f, 1e-4f);
+}
+
+TEST(UnitTestMatStandalone, MatOrthoNegativeOneToOneDefault)
+{
+    // Verify explicit [-1, 1] matches default
+    const auto ortho_default = mat_ortho_left_handed(-1.f, 1.f, -1.f, 1.f, 0.1f, 100.f);
+    const auto ortho_explicit = mat_ortho_left_handed<float, MatStoreType::ROW_MAJOR,
+            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(-1.f, 1.f, -1.f, 1.f, 0.1f, 100.f);
+
+    EXPECT_EQ(ortho_default, ortho_explicit);
+}

tests/general/unit_test_pred_engine_trait.cpp

@@ -7,9 +7,12 @@
 using namespace omath;
 using namespace omath::source_engine;
 
+using Projectile = projectile_prediction::Projectile<float>;
+using Target     = projectile_prediction::Target<float>;
+
 TEST(PredEngineTrait, PredictProjectilePositionBasic)
 {
-    projectile_prediction::Projectile p;
+    Projectile p;
     p.m_origin = {0.f, 0.f, 0.f};
     p.m_launch_speed = 10.f;
     p.m_gravity_scale = 1.f;
@@ -23,7 +26,7 @@ TEST(PredEngineTrait, PredictProjectilePositionBasic)
 
 TEST(PredEngineTrait, PredictTargetPositionAirborne)
 {
-    projectile_prediction::Target t;
+    Target t;
     t.m_origin = {0.f, 0.f, 10.f};
     t.m_velocity = {1.f, 0.f, 0.f};
     t.m_is_airborne = true;
@@ -42,7 +45,7 @@ TEST(PredEngineTrait, CalcVector2dDistance)
 
 TEST(PredEngineTrait, CalcViewpointFromAngles)
 {
-    projectile_prediction::Projectile p;
+    Projectile p;
     p.m_origin = {0.f, 0.f, 0.f};
     p.m_launch_speed = 10.f;
 
@@ -55,7 +58,7 @@ TEST(PredEngineTrait, CalcViewpointFromAngles)
 
 TEST(PredEngineTrait, PredictProjectilePositionWithLaunchOffset)
 {
-    projectile_prediction::Projectile p;
+    Projectile p;
     p.m_origin = {0.f, 0.f, 0.f};
     p.m_launch_offset = {5.f, 3.f, -2.f};
     p.m_launch_speed = 10.f;
@@ -76,13 +79,13 @@ TEST(PredEngineTrait, PredictProjectilePositionWithLaunchOffset)
 
 TEST(PredEngineTrait, ZeroLaunchOffsetMatchesOriginalBehavior)
 {
-    projectile_prediction::Projectile p;
+    Projectile p;
     p.m_origin = {10.f, 20.f, 30.f};
     p.m_launch_offset = {0.f, 0.f, 0.f};
     p.m_launch_speed = 15.f;
     p.m_gravity_scale = 0.5f;
 
-    projectile_prediction::Projectile p_no_offset;
+    Projectile p_no_offset;
     p_no_offset.m_origin = {10.f, 20.f, 30.f};
     p_no_offset.m_launch_speed = 15.f;
     p_no_offset.m_gravity_scale = 0.5f;

tests/general/unit_test_prediction.cpp

@@ -1,14 +1,19 @@
 #include <gtest/gtest.h>
 #include <omath/projectile_prediction/proj_pred_engine_legacy.hpp>
 #include <omath/engines/source_engine/traits/camera_trait.hpp>
+
+using Projectile = omath::projectile_prediction::Projectile<float>;
+using Target     = omath::projectile_prediction::Target<float>;
+using Engine     = omath::projectile_prediction::ProjPredEngineLegacy<>;
+
 TEST(UnitTestPrediction, PredictionTest)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    constexpr omath::projectile_prediction::Projectile proj = {
+    constexpr Projectile proj = {
-            .m_origin = {3, 2, 1}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+            .m_origin = {3, 2, 1}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
     const auto viewPoint =
-            omath::projectile_prediction::ProjPredEngineLegacy(400, 1.f / 1000.f, 50, 5.f).maybe_calculate_aim_point(proj, target);
+            Engine(400.f, 1.f / 1000.f, 50.f, 5.f).maybe_calculate_aim_point(proj, target);
 
 
     const auto [pitch, yaw, _] =omath::source_engine::CameraTrait::calc_look_at_angle(proj.m_origin, viewPoint.value());
@@ -18,12 +23,12 @@ TEST(UnitTestPrediction, PredictionTest)
 }
 
 // Helper: verify aim_angles match angles derived from aim_point via CameraTrait
-static void expect_angles_match_aim_point(const omath::projectile_prediction::Projectile& proj,
+static void expect_angles_match_aim_point(const Projectile& proj,
-                                          const omath::projectile_prediction::Target& target,
+                                          const Target& target,
                                           float gravity, float step, float max_time, float tolerance,
                                           float angle_eps = 0.01f)
 {
-    const omath::projectile_prediction::ProjPredEngineLegacy engine(gravity, step, max_time, tolerance);
+    const Engine engine(gravity, step, max_time, tolerance);
 
     const auto aim_point = engine.maybe_calculate_aim_point(proj, target);
     const auto aim_angles = engine.maybe_calculate_aim_angles(proj, target);
@@ -45,30 +50,30 @@ static void expect_angles_match_aim_point(const omath::projectile_prediction::Pr
 
 TEST(UnitTestPrediction, AimAnglesMatchAimPoint_StaticTarget)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    constexpr omath::projectile_prediction::Projectile proj = {
+    constexpr Projectile proj = {
-            .m_origin = {3, 2, 1}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+            .m_origin = {3, 2, 1}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
 
     expect_angles_match_aim_point(proj, target, 400, 1.f / 1000.f, 50, 5.f);
 }
 
 TEST(UnitTestPrediction, AimAnglesMatchAimPoint_MovingTarget)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {500, 100, 0}, .m_velocity = {-50, 20, 0}, .m_is_airborne = false};
-    constexpr omath::projectile_prediction::Projectile proj = {
+    constexpr Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_speed = 3000, .m_gravity_scale = 1.0};
+            .m_origin = {0, 0, 0}, .m_launch_speed = 3000.f, .m_gravity_scale = 1.0f};
 
     expect_angles_match_aim_point(proj, target, 800, 1.f / 500.f, 30, 10.f);
 }
 
 TEST(UnitTestPrediction, AimAnglesMatchAimPoint_AirborneTarget)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {200, 50, 300}, .m_velocity = {10, -5, -20}, .m_is_airborne = true};
-    constexpr omath::projectile_prediction::Projectile proj = {
+    constexpr Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_speed = 4000, .m_gravity_scale = 0.5};
+            .m_origin = {0, 0, 0}, .m_launch_speed = 4000.f, .m_gravity_scale = 0.5f};
 
     expect_angles_match_aim_point(proj, target, 400, 1.f / 1000.f, 50, 10.f);
 }
@@ -76,10 +81,10 @@ TEST(UnitTestPrediction, AimAnglesMatchAimPoint_AirborneTarget)
 TEST(UnitTestPrediction, AimAnglesMatchAimPoint_HighArc)
 {
     // Target nearly directly above — high pitch angle
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {10, 0, 500}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    constexpr omath::projectile_prediction::Projectile proj = {
+    constexpr Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_speed = 5000, .m_gravity_scale = 0.3};
+            .m_origin = {0, 0, 0}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.3f};
 
     expect_angles_match_aim_point(proj, target, 400, 1.f / 1000.f, 50, 5.f);
 }
@@ -87,20 +92,20 @@ TEST(UnitTestPrediction, AimAnglesMatchAimPoint_HighArc)
 TEST(UnitTestPrediction, AimAnglesMatchAimPoint_NegativeYaw)
 {
     // Target behind and to the left — negative yaw quadrant
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {-200, -150, 10}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    constexpr omath::projectile_prediction::Projectile proj = {
+    constexpr Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+            .m_origin = {0, 0, 0}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
 
     expect_angles_match_aim_point(proj, target, 400, 1.f / 1000.f, 50, 5.f);
 }
 
 TEST(UnitTestPrediction, AimAnglesMatchAimPoint_WithLaunchOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {200, 0, 50}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    const omath::projectile_prediction::Projectile proj = {
+    const Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_offset = {5, 0, -3}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+            .m_origin = {0, 0, 0}, .m_launch_offset = {5, 0, -3}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
 
     expect_angles_match_aim_point(proj, target, 400, 1.f / 1000.f, 50, 5.f);
 }
@@ -108,13 +113,13 @@ TEST(UnitTestPrediction, AimAnglesMatchAimPoint_WithLaunchOffset)
 // Helper: simulate projectile flight using aim_angles and verify it reaches the target.
 // Steps the projectile forward in small increments, simultaneously predicts target position,
 // and checks that the minimum distance is within hit_tolerance.
-static void expect_projectile_hits_target(const omath::projectile_prediction::Projectile& proj,
+static void expect_projectile_hits_target(const Projectile& proj,
-                                          const omath::projectile_prediction::Target& target,
+                                          const Target& target,
                                           float gravity, float engine_step, float max_time, float engine_tolerance,
                                           float hit_tolerance, float sim_step = 1.f / 2000.f)
 {
     using Trait = omath::source_engine::PredEngineTrait;
-    const omath::projectile_prediction::ProjPredEngineLegacy engine(gravity, engine_step, max_time, engine_tolerance);
+    const Engine engine(gravity, engine_step, max_time, engine_tolerance);
 
     const auto aim_angles = engine.maybe_calculate_aim_angles(proj, target);
     ASSERT_TRUE(aim_angles.has_value()) << "engine must find a solution";
@@ -148,50 +153,50 @@ static void expect_projectile_hits_target(const omath::projectile_prediction::Pr
 
 TEST(ProjectileSimulation, HitsStaticTarget_NoOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    constexpr omath::projectile_prediction::Projectile proj = {
+    constexpr Projectile proj = {
-            .m_origin = {3, 2, 1}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+            .m_origin = {3, 2, 1}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
 
     expect_projectile_hits_target(proj, target, 400, 1.f / 1000.f, 50, 5.f, 10.f);
 }
 
 TEST(ProjectileSimulation, HitsMovingTarget_NoOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {500, 100, 0}, .m_velocity = {-50, 20, 0}, .m_is_airborne = false};
-    constexpr omath::projectile_prediction::Projectile proj = {
+    constexpr Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_speed = 3000, .m_gravity_scale = 1.0};
+            .m_origin = {0, 0, 0}, .m_launch_speed = 3000.f, .m_gravity_scale = 1.0f};
 
     expect_projectile_hits_target(proj, target, 800, 1.f / 500.f, 30, 10.f, 15.f);
 }
 
 TEST(ProjectileSimulation, HitsAirborneTarget_NoOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {200, 50, 300}, .m_velocity = {10, -5, -20}, .m_is_airborne = true};
-    constexpr omath::projectile_prediction::Projectile proj = {
+    constexpr Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_speed = 4000, .m_gravity_scale = 0.5};
+            .m_origin = {0, 0, 0}, .m_launch_speed = 4000.f, .m_gravity_scale = 0.5f};
 
     expect_projectile_hits_target(proj, target, 400, 1.f / 1000.f, 50, 10.f, 15.f);
 }
 
 TEST(ProjectileSimulation, HitsHighTarget_NoOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {10, 0, 500}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    constexpr omath::projectile_prediction::Projectile proj = {
+    constexpr Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_speed = 5000, .m_gravity_scale = 0.3};
+            .m_origin = {0, 0, 0}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.3f};
 
     expect_projectile_hits_target(proj, target, 400, 1.f / 1000.f, 50, 5.f, 10.f);
 }
 
 TEST(ProjectileSimulation, HitsNegativeYawTarget_NoOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {-200, -150, 10}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    constexpr omath::projectile_prediction::Projectile proj = {
+    constexpr Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+            .m_origin = {0, 0, 0}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
 
     expect_projectile_hits_target(proj, target, 400, 1.f / 1000.f, 50, 5.f, 10.f);
 }
@@ -200,92 +205,92 @@ TEST(ProjectileSimulation, HitsNegativeYawTarget_NoOffset)
 
 TEST(ProjectileSimulation, HitsStaticTarget_SmallOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {200, 0, 50}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    const omath::projectile_prediction::Projectile proj = {
+    const Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_offset = {5, 0, -3}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+            .m_origin = {0, 0, 0}, .m_launch_offset = {5, 0, -3}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
 
     expect_projectile_hits_target(proj, target, 400, 1.f / 1000.f, 50, 5.f, 10.f);
 }
 
 TEST(ProjectileSimulation, HitsStaticTarget_LargeXOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {300, 100, 0}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    const omath::projectile_prediction::Projectile proj = {
+    const Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_offset = {20, 0, 0}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+            .m_origin = {0, 0, 0}, .m_launch_offset = {20, 0, 0}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
 
     expect_projectile_hits_target(proj, target, 400, 1.f / 1000.f, 50, 5.f, 10.f);
 }
 
 TEST(ProjectileSimulation, HitsStaticTarget_LargeYOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {150, -200, 30}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    const omath::projectile_prediction::Projectile proj = {
+    const Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_offset = {0, 15, 0}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+            .m_origin = {0, 0, 0}, .m_launch_offset = {0, 15, 0}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
 
     expect_projectile_hits_target(proj, target, 400, 1.f / 1000.f, 50, 5.f, 10.f);
 }
 
 TEST(ProjectileSimulation, HitsStaticTarget_LargeZOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {100, 0, 200}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    const omath::projectile_prediction::Projectile proj = {
+    const Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_offset = {0, 0, -10}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+            .m_origin = {0, 0, 0}, .m_launch_offset = {0, 0, -10}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
 
     expect_projectile_hits_target(proj, target, 400, 1.f / 1000.f, 50, 5.f, 10.f);
 }
 
 TEST(ProjectileSimulation, HitsStaticTarget_AllAxesOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {250, 80, 60}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    const omath::projectile_prediction::Projectile proj = {
+    const Projectile proj = {
-            .m_origin = {10, 5, 20}, .m_launch_offset = {8, -4, -6}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+            .m_origin = {10, 5, 20}, .m_launch_offset = {8, -4, -6}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
 
     expect_projectile_hits_target(proj, target, 400, 1.f / 1000.f, 50, 5.f, 10.f);
 }
 
 TEST(ProjectileSimulation, HitsMovingTarget_WithOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {400, 0, 50}, .m_velocity = {-30, 10, 5}, .m_is_airborne = false};
-    const omath::projectile_prediction::Projectile proj = {
+    const Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_offset = {10, -5, 2}, .m_launch_speed = 3000, .m_gravity_scale = 0.8};
+            .m_origin = {0, 0, 0}, .m_launch_offset = {10, -5, 2}, .m_launch_speed = 3000.f, .m_gravity_scale = 0.8f};
 
     expect_projectile_hits_target(proj, target, 800, 1.f / 500.f, 30, 10.f, 15.f);
 }
 
 TEST(ProjectileSimulation, HitsAirborneTarget_WithOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {150, 80, 250}, .m_velocity = {5, -10, -30}, .m_is_airborne = true};
-    const omath::projectile_prediction::Projectile proj = {
+    const Projectile proj = {
-            .m_origin = {0, 0, 50}, .m_launch_offset = {3, 7, -5}, .m_launch_speed = 4000, .m_gravity_scale = 0.5};
+            .m_origin = {0, 0, 50}, .m_launch_offset = {3, 7, -5}, .m_launch_speed = 4000.f, .m_gravity_scale = 0.5f};
 
     expect_projectile_hits_target(proj, target, 400, 1.f / 1000.f, 50, 10.f, 15.f);
 }
 
 TEST(ProjectileSimulation, HitsNegativeYawTarget_WithOffset)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {-200, -150, 10}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    const omath::projectile_prediction::Projectile proj = {
+    const Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_offset = {-5, 3, 2}, .m_launch_speed = 5000, .m_gravity_scale = 0.4};
+            .m_origin = {0, 0, 0}, .m_launch_offset = {-5, 3, 2}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
 
     expect_projectile_hits_target(proj, target, 400, 1.f / 1000.f, 50, 5.f, 10.f);
 }
 
 TEST(UnitTestPrediction, AimAnglesReturnsNulloptWhenNoSolution)
 {
-    constexpr omath::projectile_prediction::Target target{
+    constexpr Target target{
             .m_origin = {100000, 0, 0}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    constexpr omath::projectile_prediction::Projectile proj = {
+    constexpr Projectile proj = {
-            .m_origin = {0, 0, 0}, .m_launch_speed = 1, .m_gravity_scale = 1};
+            .m_origin = {0, 0, 0}, .m_launch_speed = 1.f, .m_gravity_scale = 1.f};
 
-    const omath::projectile_prediction::ProjPredEngineLegacy engine(9.81f, 0.1f, 2.f, 5.f);
+    const Engine engine(9.81f, 0.1f, 2.f, 5.f);
 
     const auto aim_point = engine.maybe_calculate_aim_point(proj, target);
     const auto aim_angles = engine.maybe_calculate_aim_angles(proj, target);

tests/general/unit_test_proj_pred_engine_legacy_more.cpp

@@ -4,8 +4,8 @@
 #include <omath/projectile_prediction/target.hpp>
 #include <omath/linear_algebra/vector3.hpp>
 
-using omath::projectile_prediction::Projectile;
+using Projectile = omath::projectile_prediction::Projectile<float>;
-using omath::projectile_prediction::Target;
+using Target     = omath::projectile_prediction::Target<float>;
 using omath::Vector3;
 
 // Fake engine trait where gravity is effectively zero and projectile prediction always hits the target

tests/general/unit_test_projection.cpp

@@ -4,7 +4,14 @@
 #include "omath/engines/unity_engine/camera.hpp"
 #include <complex>
 #include <gtest/gtest.h>
+#include <omath/3d_primitives/aabb.hpp>
+#include <omath/engines/cry_engine/camera.hpp>
+#include <omath/engines/frostbite_engine/camera.hpp>
+#include <omath/engines/iw_engine/camera.hpp>
+#include <omath/engines/opengl_engine/camera.hpp>
 #include <omath/engines/source_engine/camera.hpp>
+#include <omath/engines/unreal_engine/camera.hpp>
+#include <omath/linear_algebra/triangle.hpp>
 #include <omath/projection/camera.hpp>
 #include <print>
 #include <random>
@@ -217,3 +224,965 @@ TEST(UnitTestProjection, ScreenToWorldBottomLeftCorner)
         EXPECT_NEAR(screen_cords->y, initial_screen_cords.y, 0.001f);
     }
 }
+
+TEST(UnitTestProjection, AabbInsideFrustumNotCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Small box directly in front of camera (Source Engine: +X forward, +Y left, +Z up)
+    const omath::primitives::Aabb<float> aabb{{90.f, -1.f, -1.f}, {110.f, 1.f, 1.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbBehindCameraCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Box entirely behind the camera
+    const omath::primitives::Aabb<float> aabb{{-200.f, -1.f, -1.f}, {-100.f, 1.f, 1.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbBeyondFarPlaneCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Box beyond far plane (1000)
+    const omath::primitives::Aabb<float> aabb{{1500.f, -1.f, -1.f}, {2000.f, 1.f, 1.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbFarLeftCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Box far to the side, outside the frustum
+    const omath::primitives::Aabb<float> aabb{{90.f, 4000.f, -1.f}, {110.f, 5000.f, 1.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbFarRightCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Box far to the other side, outside the frustum
+    const omath::primitives::Aabb<float> aabb{{90.f, -5000.f, -1.f}, {110.f, -4000.f, 1.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbAboveCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Box far above the frustum
+    const omath::primitives::Aabb<float> aabb{{90.f, -1.f, 5000.f}, {110.f, 1.f, 6000.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbPartiallyInsideNotCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Large box that straddles the frustum boundary — partially inside
+    const omath::primitives::Aabb<float> aabb{{50.f, -5000.f, -5000.f}, {500.f, 5000.f, 5000.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbStraddlesNearPlaneNotCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Box that straddles the near plane — partially in front
+    const omath::primitives::Aabb<float> aabb{{-5.f, -1.f, -1.f}, {5.f, 1.f, 1.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbStraddlesFarPlaneNotCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Box that straddles the far plane
+    const omath::primitives::Aabb<float> aabb{{900.f, -1.f, -1.f}, {1100.f, 1.f, 1.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbCulledUnityEngine)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.03f, 1000.f);
+
+    // Box in front — not culled
+    const omath::primitives::Aabb<float> inside{{-1.f, -1.f, 50.f}, {1.f, 1.f, 100.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(inside));
+
+    // Box behind — culled
+    const omath::primitives::Aabb<float> behind{{-1.f, -1.f, -200.f}, {1.f, 1.f, -100.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(behind));
+}
+
+TEST(UnitTestProjection, AabbBelowCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Box far below the frustum (Source Engine: +Z up)
+    const omath::primitives::Aabb<float> aabb{{90.f, -1.f, -6000.f}, {110.f, 1.f, -5000.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbEnclosesCameraNotCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Huge box that fully encloses the camera
+    const omath::primitives::Aabb<float> aabb{{-500.f, -500.f, -500.f}, {500.f, 500.f, 500.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbExactlyAtNearPlaneNotCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Box starting exactly at the near plane distance
+    const omath::primitives::Aabb<float> aabb{{0.01f, -1.f, -1.f}, {10.f, 1.f, 1.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbExactlyAtFarPlaneNotCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Box ending exactly at the far plane distance
+    const omath::primitives::Aabb<float> aabb{{990.f, -1.f, -1.f}, {1000.f, 1.f, 1.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbNarrowFovCulledAtEdge)
+{
+    // Narrow FOV — box that would be visible at 90 is culled at 30
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(30.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    const omath::primitives::Aabb<float> aabb{{100.f, 200.f, -1.f}, {110.f, 210.f, 1.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbWideFovNotCulledAtEdge)
+{
+    // Wide FOV — same box is visible
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(120.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    const omath::primitives::Aabb<float> aabb{{100.f, 200.f, -1.f}, {110.f, 210.f, 1.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbCameraOffOrigin)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({500.f, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f},
+                                                  fov, 0.01f, 1000.f);
+
+    // Box in front of shifted camera
+    const omath::primitives::Aabb<float> in_front{{600.f, -1.f, -1.f}, {700.f, 1.f, 1.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(in_front));
+
+    // Box behind shifted camera
+    const omath::primitives::Aabb<float> behind{{0.f, -1.f, -1.f}, {100.f, 1.f, 1.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(behind));
+}
+
+TEST(UnitTestProjection, AabbShortFarPlaneCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    // Very short far plane
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 50.f);
+
+    // Box at distance 100 — beyond the 50-unit far plane
+    const omath::primitives::Aabb<float> aabb{{90.f, -1.f, -1.f}, {110.f, 1.f, 1.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+
+    // Box at distance 30 — within range
+    const omath::primitives::Aabb<float> near_box{{25.f, -1.f, -1.f}, {35.f, 1.f, 1.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(near_box));
+}
+
+TEST(UnitTestProjection, AabbPointSizedInsideNotCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
+
+    // Degenerate zero-volume AABB (a point) inside the frustum
+    const omath::primitives::Aabb<float> aabb{{100.f, 0.f, 0.f}, {100.f, 0.f, 0.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbOpenGlEngineInsideNotCulled)
+{
+    // OpenGL: COLUMN_MAJOR, NEGATIVE_ONE_TO_ONE, inverted_z, forward = -Z
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    // Box in front of camera (OpenGL: -Z forward)
+    const omath::primitives::Aabb<float> aabb{{-1.f, -1.f, -110.f}, {1.f, 1.f, -90.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbOpenGlEngineBehindCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    // Box behind (OpenGL: +Z is behind the camera)
+    const omath::primitives::Aabb<float> aabb{{-1.f, -1.f, 100.f}, {1.f, 1.f, 200.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbOpenGlEngineBeyondFarCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    // Box beyond far plane along -Z
+    const omath::primitives::Aabb<float> aabb{{-1.f, -1.f, -2000.f}, {1.f, 1.f, -1500.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbOpenGlEngineSideCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::opengl_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    // Box far to the right (OpenGL: +X right)
+    const omath::primitives::Aabb<float> aabb{{4000.f, -1.f, -110.f}, {5000.f, 1.f, -90.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbUnityEngineBeyondFarCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.03f, 500.f);
+
+    // Box beyond 500-unit far plane (Unity: +Z forward)
+    const omath::primitives::Aabb<float> aabb{{-1.f, -1.f, 600.f}, {1.f, 1.f, 700.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbUnityEngineSideCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.03f, 1000.f);
+
+    // Box far above (Unity: +Y up)
+    const omath::primitives::Aabb<float> aabb{{-1.f, 5000.f, 50.f}, {1.f, 6000.f, 100.f}};
+    EXPECT_TRUE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, AabbUnityEngineStraddlesNearNotCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.03f, 1000.f);
+
+    // Box straddles near plane (Unity: +Z forward)
+    const omath::primitives::Aabb<float> aabb{{-1.f, -1.f, -5.f}, {1.f, 1.f, 5.f}};
+    EXPECT_FALSE(cam.is_aabb_culled_by_frustum(aabb));
+}
+
+TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_LookingForward)
+{
+    constexpr float k_eps = 1e-4f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(0.f),
+        omath::source_engine::YawAngle::from_degrees(0.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(result.pitch.as_degrees(), 0.f, k_eps);
+    EXPECT_NEAR(result.yaw.as_degrees(), 0.f, k_eps);
+}
+
+TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_PositivePitchAndYaw)
+{
+    constexpr float k_eps = 1e-4f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(30.f),
+        omath::source_engine::YawAngle::from_degrees(45.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(result.pitch.as_degrees(), 30.f, k_eps);
+    EXPECT_NEAR(result.yaw.as_degrees(), 45.f, k_eps);
+}
+
+TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_NegativePitchAndYaw)
+{
+    constexpr float k_eps = 1e-4f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(-45.f),
+        omath::source_engine::YawAngle::from_degrees(-90.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(result.pitch.as_degrees(), -45.f, k_eps);
+    EXPECT_NEAR(result.yaw.as_degrees(), -90.f, k_eps);
+}
+
+TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_OffOriginCameraIgnored)
+{
+    // The forward vector from the view matrix does not depend on camera origin,
+    // so the same angles should be recovered regardless of position.
+    constexpr float k_eps = 1e-4f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(20.f),
+        omath::source_engine::YawAngle::from_degrees(60.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto cam = omath::source_engine::Camera({100.f, 200.f, -50.f}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(result.pitch.as_degrees(), 20.f, k_eps);
+    EXPECT_NEAR(result.yaw.as_degrees(), 60.f, k_eps);
+}
+
+TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_RollAlwaysZero)
+{
+    // Roll cannot be encoded in the forward vector, so it is always 0 in the result.
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(10.f),
+        omath::source_engine::YawAngle::from_degrees(30.f),
+        omath::source_engine::RollAngle::from_degrees(15.f)
+    };
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_FLOAT_EQ(result.roll.as_degrees(), 0.f);
+}
+
+TEST(UnitTestProjection, CalcOriginFromViewMatrix_AtOrigin)
+{
+    constexpr float k_eps = 1e-4f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto origin = omath::source_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(origin.x, 0.f, k_eps);
+    EXPECT_NEAR(origin.y, 0.f, k_eps);
+    EXPECT_NEAR(origin.z, 0.f, k_eps);
+}
+
+TEST(UnitTestProjection, CalcOriginFromViewMatrix_ArbitraryPosition)
+{
+    constexpr float k_eps = 1e-3f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(0.f),
+        omath::source_engine::YawAngle::from_degrees(0.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto cam = omath::source_engine::Camera({100.f, 200.f, -50.f}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto origin = omath::source_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(origin.x, 100.f, k_eps);
+    EXPECT_NEAR(origin.y, 200.f, k_eps);
+    EXPECT_NEAR(origin.z, -50.f, k_eps);
+}
+
+TEST(UnitTestProjection, CalcOriginFromViewMatrix_WithRotation)
+{
+    // Origin recovery must work even when the camera is rotated.
+    constexpr float k_eps = 1e-3f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(30.f),
+        omath::source_engine::YawAngle::from_degrees(45.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto cam = omath::source_engine::Camera({300.f, -100.f, 75.f}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto origin = omath::source_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(origin.x, 300.f, k_eps);
+    EXPECT_NEAR(origin.y, -100.f, k_eps);
+    EXPECT_NEAR(origin.z, 75.f, k_eps);
+}
+
+TEST(UnitTestProjection, CalcOriginFromViewMatrix_IndependentOfAngles)
+{
+    // Same position, different orientations — should always recover the same origin.
+    constexpr float k_eps = 1e-3f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    constexpr omath::Vector3<float> expected_origin{50.f, 50.f, 50.f};
+
+    const omath::source_engine::ViewAngles angles_a{
+        omath::source_engine::PitchAngle::from_degrees(0.f),
+        omath::source_engine::YawAngle::from_degrees(0.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
+    const omath::source_engine::ViewAngles angles_b{
+        omath::source_engine::PitchAngle::from_degrees(-60.f),
+        omath::source_engine::YawAngle::from_degrees(135.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
+
+    const auto cam_a = omath::source_engine::Camera(expected_origin, angles_a, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+    const auto cam_b = omath::source_engine::Camera(expected_origin, angles_b, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto origin_a = omath::source_engine::Camera::calc_origin_from_view_matrix(cam_a.get_view_matrix());
+    const auto origin_b = omath::source_engine::Camera::calc_origin_from_view_matrix(cam_b.get_view_matrix());
+
+    EXPECT_NEAR(origin_a.x, expected_origin.x, k_eps);
+    EXPECT_NEAR(origin_a.y, expected_origin.y, k_eps);
+    EXPECT_NEAR(origin_a.z, expected_origin.z, k_eps);
+
+    EXPECT_NEAR(origin_b.x, expected_origin.x, k_eps);
+    EXPECT_NEAR(origin_b.y, expected_origin.y, k_eps);
+    EXPECT_NEAR(origin_b.z, expected_origin.z, k_eps);
+}
+
+// ---- Unity engine camera tests ----
+
+TEST(UnitTestProjection, Unity_CalcViewAnglesFromViewMatrix_LookingForward)
+{
+    constexpr float k_eps = 1e-4f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(0.f),
+        omath::unity_engine::YawAngle::from_degrees(0.f),
+        omath::unity_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto cam = omath::unity_engine::Camera({0, 0, 0}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f);
+
+    const auto result = omath::unity_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(result.pitch.as_degrees(), 0.f, k_eps);
+    EXPECT_NEAR(result.yaw.as_degrees(), 0.f, k_eps);
+}
+
+TEST(UnitTestProjection, Unity_CalcViewAnglesFromViewMatrix_PositivePitchAndYaw)
+{
+    constexpr float k_eps = 1e-4f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(30.f),
+        omath::unity_engine::YawAngle::from_degrees(45.f),
+        omath::unity_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto cam = omath::unity_engine::Camera({0, 0, 0}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f);
+
+    const auto result = omath::unity_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(result.pitch.as_degrees(), 30.f, k_eps);
+    EXPECT_NEAR(result.yaw.as_degrees(), 45.f, k_eps);
+}
+
+TEST(UnitTestProjection, Unity_CalcViewAnglesFromViewMatrix_NegativePitchAndYaw)
+{
+    constexpr float k_eps = 1e-4f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(-45.f),
+        omath::unity_engine::YawAngle::from_degrees(-90.f),
+        omath::unity_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto cam = omath::unity_engine::Camera({0, 0, 0}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f);
+
+    const auto result = omath::unity_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(result.pitch.as_degrees(), -45.f, k_eps);
+    EXPECT_NEAR(result.yaw.as_degrees(), -90.f, k_eps);
+}
+
+TEST(UnitTestProjection, Unity_CalcOriginFromViewMatrix_AtOrigin)
+{
+    constexpr float k_eps = 1e-4f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const auto cam = omath::unity_engine::Camera({0, 0, 0}, {}, {1280.f, 720.f}, fov, 0.03f, 1000.f);
+
+    const auto origin = omath::unity_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(origin.x, 0.f, k_eps);
+    EXPECT_NEAR(origin.y, 0.f, k_eps);
+    EXPECT_NEAR(origin.z, 0.f, k_eps);
+}
+
+TEST(UnitTestProjection, Unity_CalcOriginFromViewMatrix_ArbitraryPosition)
+{
+    constexpr float k_eps = 1e-3f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(0.f),
+        omath::unity_engine::YawAngle::from_degrees(0.f),
+        omath::unity_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto cam = omath::unity_engine::Camera({100.f, 200.f, -50.f}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f);
+
+    const auto origin = omath::unity_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(origin.x, 100.f, k_eps);
+    EXPECT_NEAR(origin.y, 200.f, k_eps);
+    EXPECT_NEAR(origin.z, -50.f, k_eps);
+}
+
+TEST(UnitTestProjection, Unity_CalcOriginFromViewMatrix_WithRotation)
+{
+    constexpr float k_eps = 1e-3f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(30.f),
+        omath::unity_engine::YawAngle::from_degrees(45.f),
+        omath::unity_engine::RollAngle::from_degrees(0.f)
+    };
+    const auto cam = omath::unity_engine::Camera({300.f, -100.f, 75.f}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f);
+
+    const auto origin = omath::unity_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix());
+
+    EXPECT_NEAR(origin.x, 300.f, k_eps);
+    EXPECT_NEAR(origin.y, -100.f, k_eps);
+    EXPECT_NEAR(origin.z, 75.f, k_eps);
+}
+// ---- Camera basis vectors at zero angles ----
+
+TEST(UnitTestProjection, SourceEngine_ZeroAngles_BasisVectors)
+{
+    constexpr float k_eps = 1e-5f;
+    const auto cam = omath::source_engine::Camera({}, {}, {1920.f, 1080.f},
+                                                  omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
+    const auto fwd   = cam.get_abs_forward();
+    const auto right = cam.get_abs_right();
+    const auto up    = cam.get_abs_up();
+
+    EXPECT_NEAR(fwd.x,   omath::source_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::source_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::source_engine::k_abs_forward.z, k_eps);
+
+    EXPECT_NEAR(right.x, omath::source_engine::k_abs_right.x, k_eps);
+    EXPECT_NEAR(right.y, omath::source_engine::k_abs_right.y, k_eps);
+    EXPECT_NEAR(right.z, omath::source_engine::k_abs_right.z, k_eps);
+
+    EXPECT_NEAR(up.x,    omath::source_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::source_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::source_engine::k_abs_up.z, k_eps);
+}
+
+TEST(UnitTestProjection, UnityEngine_ZeroAngles_BasisVectors)
+{
+    constexpr float k_eps = 1e-5f;
+    const auto cam = omath::unity_engine::Camera({}, {}, {1280.f, 720.f},
+                                                 omath::projection::FieldOfView::from_degrees(60.f), 0.03f, 1000.f);
+    const auto fwd   = cam.get_abs_forward();
+    const auto right = cam.get_abs_right();
+    const auto up    = cam.get_abs_up();
+
+    EXPECT_NEAR(fwd.x,   omath::unity_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::unity_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::unity_engine::k_abs_forward.z, k_eps);
+
+    EXPECT_NEAR(right.x, omath::unity_engine::k_abs_right.x, k_eps);
+    EXPECT_NEAR(right.y, omath::unity_engine::k_abs_right.y, k_eps);
+    EXPECT_NEAR(right.z, omath::unity_engine::k_abs_right.z, k_eps);
+
+    EXPECT_NEAR(up.x,    omath::unity_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::unity_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::unity_engine::k_abs_up.z, k_eps);
+}
+
+TEST(UnitTestProjection, OpenGLEngine_ZeroAngles_BasisVectors)
+{
+    constexpr float k_eps = 1e-5f;
+    const auto cam = omath::opengl_engine::Camera({}, {}, {1920.f, 1080.f},
+                                                  omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
+    const auto fwd   = cam.get_abs_forward();
+    const auto right = cam.get_abs_right();
+    const auto up    = cam.get_abs_up();
+
+    EXPECT_NEAR(fwd.x,   omath::opengl_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::opengl_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::opengl_engine::k_abs_forward.z, k_eps);
+
+    EXPECT_NEAR(right.x, omath::opengl_engine::k_abs_right.x, k_eps);
+    EXPECT_NEAR(right.y, omath::opengl_engine::k_abs_right.y, k_eps);
+    EXPECT_NEAR(right.z, omath::opengl_engine::k_abs_right.z, k_eps);
+
+    EXPECT_NEAR(up.x,    omath::opengl_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::opengl_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::opengl_engine::k_abs_up.z, k_eps);
+}
+
+TEST(UnitTestProjection, UnrealEngine_ZeroAngles_BasisVectors)
+{
+    constexpr float k_eps = 1e-5f;
+    const auto cam = omath::unreal_engine::Camera({}, {}, {1920.f, 1080.f},
+                                                  omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
+    const auto fwd   = cam.get_abs_forward();
+    const auto right = cam.get_abs_right();
+    const auto up    = cam.get_abs_up();
+
+    EXPECT_NEAR(fwd.x,   omath::unreal_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::unreal_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::unreal_engine::k_abs_forward.z, k_eps);
+
+    EXPECT_NEAR(right.x, omath::unreal_engine::k_abs_right.x, k_eps);
+    EXPECT_NEAR(right.y, omath::unreal_engine::k_abs_right.y, k_eps);
+    EXPECT_NEAR(right.z, omath::unreal_engine::k_abs_right.z, k_eps);
+
+    EXPECT_NEAR(up.x,    omath::unreal_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::unreal_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::unreal_engine::k_abs_up.z, k_eps);
+}
+
+TEST(UnitTestProjection, FrostbiteEngine_ZeroAngles_BasisVectors)
+{
+    constexpr float k_eps = 1e-5f;
+    const auto cam = omath::frostbite_engine::Camera({}, {}, {1920.f, 1080.f},
+                                                     omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
+    const auto fwd   = cam.get_abs_forward();
+    const auto right = cam.get_abs_right();
+    const auto up    = cam.get_abs_up();
+
+    EXPECT_NEAR(fwd.x,   omath::frostbite_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::frostbite_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::frostbite_engine::k_abs_forward.z, k_eps);
+
+    EXPECT_NEAR(right.x, omath::frostbite_engine::k_abs_right.x, k_eps);
+    EXPECT_NEAR(right.y, omath::frostbite_engine::k_abs_right.y, k_eps);
+    EXPECT_NEAR(right.z, omath::frostbite_engine::k_abs_right.z, k_eps);
+
+    EXPECT_NEAR(up.x,    omath::frostbite_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::frostbite_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::frostbite_engine::k_abs_up.z, k_eps);
+}
+
+TEST(UnitTestProjection, CryEngine_ZeroAngles_BasisVectors)
+{
+    constexpr float k_eps = 1e-5f;
+    const auto cam = omath::cry_engine::Camera({}, {}, {1920.f, 1080.f},
+                                               omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
+    const auto fwd   = cam.get_abs_forward();
+    const auto right = cam.get_abs_right();
+    const auto up    = cam.get_abs_up();
+
+    EXPECT_NEAR(fwd.x,   omath::cry_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::cry_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::cry_engine::k_abs_forward.z, k_eps);
+
+    EXPECT_NEAR(right.x, omath::cry_engine::k_abs_right.x, k_eps);
+    EXPECT_NEAR(right.y, omath::cry_engine::k_abs_right.y, k_eps);
+    EXPECT_NEAR(right.z, omath::cry_engine::k_abs_right.z, k_eps);
+
+    EXPECT_NEAR(up.x,    omath::cry_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::cry_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::cry_engine::k_abs_up.z, k_eps);
+}
+
+TEST(UnitTestProjection, IWEngine_ZeroAngles_BasisVectors)
+{
+    constexpr float k_eps = 1e-5f;
+    const auto cam = omath::iw_engine::Camera({}, {}, {1920.f, 1080.f},
+                                              omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
+    const auto fwd   = cam.get_abs_forward();
+    const auto right = cam.get_abs_right();
+    const auto up    = cam.get_abs_up();
+
+    EXPECT_NEAR(fwd.x,   omath::iw_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::iw_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::iw_engine::k_abs_forward.z, k_eps);
+
+    EXPECT_NEAR(right.x, omath::iw_engine::k_abs_right.x, k_eps);
+    EXPECT_NEAR(right.y, omath::iw_engine::k_abs_right.y, k_eps);
+    EXPECT_NEAR(right.z, omath::iw_engine::k_abs_right.z, k_eps);
+
+    EXPECT_NEAR(up.x,    omath::iw_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::iw_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::iw_engine::k_abs_up.z, k_eps);
+}
+
+// ---- extract_projection_params ----
+
+TEST(UnitTestProjection, ExtractProjectionParams_FovRoundTrip)
+{
+    // Source engine applies a 0.75 scale factor to its projection matrix, so
+    // extract_projection_params (standard formula) does not round-trip with it.
+    // Use Unity engine, which uses a standard projection matrix.
+    constexpr float k_eps = 1e-4f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(75.f);
+    const auto cam = omath::unity_engine::Camera({}, {}, {1280.f, 720.f}, fov, 0.03f, 1000.f);
+
+    const auto params = omath::unity_engine::Camera::extract_projection_params(cam.get_projection_matrix());
+
+    EXPECT_NEAR(params.fov.as_degrees(), 75.f, k_eps);
+}
+
+TEST(UnitTestProjection, ExtractProjectionParams_AspectRatioRoundTrip)
+{
+    constexpr float k_eps = 1e-4f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto params = omath::source_engine::Camera::extract_projection_params(cam.get_projection_matrix());
+
+    EXPECT_NEAR(params.aspect_ratio, 1920.f / 1080.f, k_eps);
+}
+
+TEST(UnitTestProjection, ExtractProjectionParams_UnityEngine)
+{
+    constexpr float k_eps = 1e-4f;
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
+    const auto cam = omath::unity_engine::Camera({}, {}, {1280.f, 720.f}, fov, 0.03f, 1000.f);
+
+    const auto params = omath::unity_engine::Camera::extract_projection_params(cam.get_projection_matrix());
+
+    EXPECT_NEAR(params.fov.as_degrees(), 60.f, k_eps);
+    EXPECT_NEAR(params.aspect_ratio, 1280.f / 720.f, k_eps);
+}
+
+// ---- Accessors ----
+
+TEST(UnitTestProjection, Accessors_GetFovNearFarOrigin)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const omath::Vector3<float> origin{10.f, 20.f, 30.f};
+    const auto cam = omath::source_engine::Camera(origin, {}, {1920.f, 1080.f}, fov, 0.1f, 500.f);
+
+    EXPECT_NEAR(cam.get_field_of_view().as_degrees(), 90.f, 1e-4f);
+    EXPECT_FLOAT_EQ(cam.get_near_plane(), 0.1f);
+    EXPECT_FLOAT_EQ(cam.get_far_plane(), 500.f);
+    EXPECT_FLOAT_EQ(cam.get_origin().x, 10.f);
+    EXPECT_FLOAT_EQ(cam.get_origin().y, 20.f);
+    EXPECT_FLOAT_EQ(cam.get_origin().z, 30.f);
+}
+
+// ---- Setters + cache invalidation ----
+
+TEST(UnitTestProjection, SetFieldOfView_InvalidatesProjection)
+{
+    constexpr auto fov_a = omath::projection::FieldOfView::from_degrees(90.f);
+    constexpr auto fov_b = omath::projection::FieldOfView::from_degrees(45.f);
+    auto cam = omath::source_engine::Camera({}, {}, {1920.f, 1080.f}, fov_a, 0.01f, 1000.f);
+
+    const auto proj_before = cam.get_projection_matrix();
+    cam.set_field_of_view(fov_b);
+    const auto proj_after = cam.get_projection_matrix();
+
+    EXPECT_NE(proj_before.at(0, 0), proj_after.at(0, 0));
+    EXPECT_NEAR(cam.get_field_of_view().as_degrees(), 45.f, 1e-4f);
+}
+
+TEST(UnitTestProjection, SetNearPlane_InvalidatesProjection)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::source_engine::Camera({}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto proj_before = cam.get_projection_matrix();
+    cam.set_near_plane(1.f);
+    const auto proj_after = cam.get_projection_matrix();
+
+    EXPECT_FLOAT_EQ(cam.get_near_plane(), 1.f);
+    EXPECT_NE(proj_before.at(2, 2), proj_after.at(2, 2));
+}
+
+TEST(UnitTestProjection, SetFarPlane_InvalidatesProjection)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::source_engine::Camera({}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto proj_before = cam.get_projection_matrix();
+    cam.set_far_plane(100.f);
+    const auto proj_after = cam.get_projection_matrix();
+
+    EXPECT_FLOAT_EQ(cam.get_far_plane(), 100.f);
+    EXPECT_NE(proj_before.at(2, 2), proj_after.at(2, 2));
+}
+
+TEST(UnitTestProjection, SetOrigin_InvalidatesViewMatrix)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    // Target is off to the side — stays at the same world position while camera
+    // moves laterally, so the projected X must change.
+    const auto screen_before = cam.world_to_screen({500.f, 100.f, 0.f});
+    cam.set_origin({0.f, 100.f, 0.f}); // lateral shift
+    const auto screen_after = cam.world_to_screen({500.f, 100.f, 0.f});
+
+    ASSERT_TRUE(screen_before.has_value());
+    ASSERT_TRUE(screen_after.has_value());
+    EXPECT_NE(screen_before->x, screen_after->x);
+    EXPECT_FLOAT_EQ(cam.get_origin().y, 100.f);
+}
+
+TEST(UnitTestProjection, SetViewPort_InvalidatesProjection)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::source_engine::Camera({}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto proj_before = cam.get_projection_matrix();
+    // 1280x800 is 8:5, different aspect ratio from 1920x1080 (16:9)
+    cam.set_view_port({1280.f, 800.f});
+    const auto proj_after = cam.get_projection_matrix();
+
+    EXPECT_NE(proj_before.at(0, 0), proj_after.at(0, 0));
+}
+
+TEST(UnitTestProjection, SetViewAngles_InvalidatesViewMatrix)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::source_engine::Camera({}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto view_before = cam.get_view_matrix();
+    const omath::source_engine::ViewAngles rotated{
+        omath::source_engine::PitchAngle::from_degrees(30.f),
+        omath::source_engine::YawAngle::from_degrees(45.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
+    cam.set_view_angles(rotated);
+    const auto view_after = cam.get_view_matrix();
+
+    EXPECT_NE(view_before.at(0, 0), view_after.at(0, 0));
+}
+
+// ---- calc_look_at_angles / look_at ----
+
+TEST(UnitTestProjection, CalcLookAtAngles_ForwardTarget)
+{
+    // Source engine: +X is forward. Camera at origin, target on +X axis.
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    const auto angles = cam.calc_look_at_angles({100.f, 0.f, 0.f});
+
+    EXPECT_NEAR(angles.pitch.as_degrees(), 0.f, 1e-4f);
+    EXPECT_NEAR(angles.yaw.as_degrees(),   0.f, 1e-4f);
+}
+
+TEST(UnitTestProjection, LookAt_ForwardVectorPointsAtTarget)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    cam.look_at({200.f, 0.f, 0.f});
+    const auto fwd = cam.get_abs_forward();
+
+    // After pointing at +X target the forward vector should be ~(1,0,0)
+    EXPECT_NEAR(fwd.x, 1.f, 1e-4f);
+    EXPECT_NEAR(fwd.y, 0.f, 1e-4f);
+    EXPECT_NEAR(fwd.z, 0.f, 1e-4f);
+}
+
+// ---- is_culled_by_frustum (triangle) ----
+
+TEST(UnitTestProjection, TriangleInsideFrustumNotCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    // Small triangle directly in front (Source: +X forward)
+    const omath::Triangle<omath::Vector3<float>> tri{
+        {100.f,  0.f,  1.f},
+        {100.f,  1.f, -1.f},
+        {100.f, -1.f, -1.f}
+    };
+    EXPECT_FALSE(cam.is_culled_by_frustum(tri));
+}
+
+TEST(UnitTestProjection, TriangleBehindCameraCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    // Triangle entirely behind the camera (-X)
+    const omath::Triangle<omath::Vector3<float>> tri{
+        {-100.f,  0.f,  1.f},
+        {-100.f,  1.f, -1.f},
+        {-100.f, -1.f, -1.f}
+    };
+    EXPECT_TRUE(cam.is_culled_by_frustum(tri));
+}
+
+TEST(UnitTestProjection, TriangleBeyondFarPlaneCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    // Triangle beyond the 1000-unit far plane
+    const omath::Triangle<omath::Vector3<float>> tri{
+        {2000.f,  0.f,  1.f},
+        {2000.f,  1.f, -1.f},
+        {2000.f, -1.f, -1.f}
+    };
+    EXPECT_TRUE(cam.is_culled_by_frustum(tri));
+}
+
+TEST(UnitTestProjection, TriangleFarToSideCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    // Triangle far outside the side frustum planes
+    const omath::Triangle<omath::Vector3<float>> tri{
+        {100.f, 5000.f,  0.f},
+        {100.f, 5001.f,  1.f},
+        {100.f, 5001.f, -1.f}
+    };
+    EXPECT_TRUE(cam.is_culled_by_frustum(tri));
+}
+
+TEST(UnitTestProjection, TriangleStraddlingFrustumNotCulled)
+{
+    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
+    const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+
+    // Large triangle with vertices on both sides of the frustum — should not be culled
+    const omath::Triangle<omath::Vector3<float>> tri{
+        { 100.f,    0.f,   0.f},
+        { 100.f, 5000.f,   0.f},
+        { 100.f,    0.f, 5000.f}
+    };
+    EXPECT_FALSE(cam.is_culled_by_frustum(tri));
+}

tests/general/unit_test_reverse_enineering.cpp

@@ -30,6 +30,7 @@ inline const void* get_vtable_entry(const void* obj, const std::size_t index)
 class BaseA
 {
 public:
+    int m_field_a{42};
     [[nodiscard]] virtual int get_a() const { return 10; }
     [[nodiscard]] virtual int get_a2() const { return 11; }
 };
@@ -37,6 +38,8 @@ public:
 class BaseB
 {
 public:
+    float m_field_b{3.14f};
+    double m_field_b2{2.71};
     [[nodiscard]] virtual int get_b() const { return 20; }
     [[nodiscard]] virtual int get_b2() const { return 21; }
 };
@@ -44,26 +47,31 @@ public:
 class MultiPlayer final : public BaseA, public BaseB
 {
 public:
+    int m_own_field{999};
     [[nodiscard]] int get_a() const override { return 100; }
     [[nodiscard]] int get_a2() const override { return 101; }
     [[nodiscard]] int get_b() const override { return 200; }
     [[nodiscard]] int get_b2() const override { return 201; }
 };
 
+// BaseA layout: [vptr_a][m_field_a(int)] — sizeof(BaseA) gives the full subobject size
+// BaseB starts right after BaseA in MultiPlayer's layout
+constexpr std::ptrdiff_t BASE_B_OFFSET = static_cast<std::ptrdiff_t>(sizeof(BaseA));
+
 class RevMultiPlayer final : omath::rev_eng::InternalReverseEngineeredObject
 {
 public:
-    // Table 0 (BaseA vtable): index 0 = get_a, 1 = get_a2
+    // Table at offset 0 (BaseA vtable): index 0 = get_a, 1 = get_a2
     [[nodiscard]] int rev_get_a() const { return call_virtual_method<0, 0, int>(); }
     [[nodiscard]] int rev_get_a2() const { return call_virtual_method<0, 1, int>(); }
 
-    // Table 1 (BaseB vtable): index 0 = get_b, 1 = get_b2
+    // Table at BaseB offset (BaseB vtable): index 0 = get_b, 1 = get_b2
-    [[nodiscard]] int rev_get_b() const { return call_virtual_method<1, 0, int>(); }
+    [[nodiscard]] int rev_get_b() const { return call_virtual_method<BASE_B_OFFSET, 0, int>(); }
-    [[nodiscard]] int rev_get_b2() const { return call_virtual_method<1, 1, int>(); }
+    [[nodiscard]] int rev_get_b2() const { return call_virtual_method<BASE_B_OFFSET, 1, int>(); }
 
     // Non-const versions
     int rev_get_a_mut() { return call_virtual_method<0, 0, int>(); }
-    int rev_get_b_mut() { return call_virtual_method<1, 0, int>(); }
+    int rev_get_b_mut() { return call_virtual_method<BASE_B_OFFSET, 0, int>(); }
 };
 
 class RevPlayer final : omath::rev_eng::InternalReverseEngineeredObject
@@ -158,6 +166,15 @@ TEST(unit_test_reverse_enineering, call_virtual_method_delegates_to_call_method)
     EXPECT_EQ(2, rev->rev_bar_const());
 }
 
+TEST(unit_test_reverse_enineering, multi_player_base_b_offset_is_correct)
+{
+    // Verify our compile-time offset matches the actual layout
+    MultiPlayer mp;
+    const auto* mp_addr = reinterpret_cast<const char*>(&mp);
+    const auto* b_addr = reinterpret_cast<const char*>(static_cast<const BaseB*>(&mp));
+    EXPECT_EQ(b_addr - mp_addr, BASE_B_OFFSET);
+}
+
 TEST(unit_test_reverse_enineering, call_virtual_method_table_index_first_table)
 {
     MultiPlayer mp;
@@ -171,7 +188,7 @@ TEST(unit_test_reverse_enineering, call_virtual_method_table_index_first_table)
 
 TEST(unit_test_reverse_enineering, call_virtual_method_table_index_second_table)
 {
-    MultiPlayer mp;
+    constexpr MultiPlayer mp;
     const auto* rev = reinterpret_cast<const RevMultiPlayer*>(&mp);
 
     EXPECT_EQ(mp.get_b(), rev->rev_get_b());
@@ -192,7 +209,7 @@ TEST(unit_test_reverse_enineering, call_virtual_method_table_index_non_const)
 TEST(unit_test_reverse_enineering, call_virtual_method_table_zero_matches_default)
 {
     // Table 0 with the TableIndex overload should match the original non-TableIndex overload
-    MultiPlayer mp;
+    constexpr MultiPlayer mp;
     const auto* rev = reinterpret_cast<const RevMultiPlayer*>(&mp);
 
     // Both access table 0, method index 1 — should return the same value

tests/general/unit_test_vector2.cpp

@@ -368,6 +368,64 @@ TEST_F(UnitTestVector2, GreaterEqualOperator)
 }
 
 
+// ── Cast operator tests ──────────────────────────────────────────────────────
+
+TEST(Vector2Cast, FloatToDouble)
+{
+    constexpr Vector2<float> v{1.5f, -2.5f};
+    constexpr auto result = static_cast<Vector2<double>>(v);
+    EXPECT_DOUBLE_EQ(result.x, 1.5);
+    EXPECT_DOUBLE_EQ(result.y, -2.5);
+}
+
+TEST(Vector2Cast, DoubleToFloat)
+{
+    constexpr Vector2<double> v{1.25, -3.75};
+    constexpr auto result = static_cast<Vector2<float>>(v);
+    EXPECT_FLOAT_EQ(result.x, 1.25f);
+    EXPECT_FLOAT_EQ(result.y, -3.75f);
+}
+
+TEST(Vector2Cast, FloatToInt_Truncates)
+{
+    constexpr Vector2<float> v{3.9f, -2.1f};
+    constexpr auto result = static_cast<Vector2<int>>(v);
+    EXPECT_EQ(result.x, 3);
+    EXPECT_EQ(result.y, -2);
+}
+
+TEST(Vector2Cast, IntToFloat_Exact)
+{
+    constexpr Vector2<int> v{7, -4};
+    constexpr auto result = static_cast<Vector2<float>>(v);
+    EXPECT_FLOAT_EQ(result.x, 7.f);
+    EXPECT_FLOAT_EQ(result.y, -4.f);
+}
+
+TEST(Vector2Cast, ZeroPreserved)
+{
+    constexpr Vector2<float> v{0.f, 0.f};
+    constexpr auto result = static_cast<Vector2<double>>(v);
+    EXPECT_DOUBLE_EQ(result.x, 0.0);
+    EXPECT_DOUBLE_EQ(result.y, 0.0);
+}
+
+TEST(Vector2Cast, NegativeValues)
+{
+    constexpr Vector2<double> v{-100.0, -200.0};
+    constexpr auto result = static_cast<Vector2<float>>(v);
+    EXPECT_FLOAT_EQ(result.x, -100.f);
+    EXPECT_FLOAT_EQ(result.y, -200.f);
+}
+
+TEST(Vector2Cast, SameTypeRoundtrip)
+{
+    constexpr Vector2<float> v{1.f, 2.f};
+    constexpr auto result = static_cast<Vector2<float>>(v);
+    EXPECT_FLOAT_EQ(result.x, v.x);
+    EXPECT_FLOAT_EQ(result.y, v.y);
+}
+
 // Static assertions (compile-time checks)
 static_assert(Vector2(1.0f, 2.0f).length_sqr() == 5.0f, "LengthSqr should be 5");
 static_assert(Vector2(1.0f, 2.0f).dot(Vector2(4.0f, 5.0f)) == 14.0f, "Dot product should be 14");

tests/general/unit_test_vector3.cpp

@@ -480,6 +480,71 @@ TEST_F(UnitTestVector3, GreaterEqualOperator)
     EXPECT_TRUE(omath::Vector3(1.f, 1.f, 1.f) >= omath::Vector3<float>{});
 }
 
+// ── Cast operator tests ──────────────────────────────────────────────────────
+
+TEST(Vector3Cast, FloatToDouble)
+{
+    constexpr Vector3<float> v{1.5f, -2.5f, 3.0f};
+    constexpr auto result = static_cast<Vector3<double>>(v);
+    EXPECT_DOUBLE_EQ(result.x, 1.5);
+    EXPECT_DOUBLE_EQ(result.y, -2.5);
+    EXPECT_DOUBLE_EQ(result.z, 3.0);
+}
+
+TEST(Vector3Cast, DoubleToFloat)
+{
+    constexpr Vector3<double> v{1.25, -3.75, 0.5};
+    constexpr auto result = static_cast<Vector3<float>>(v);
+    EXPECT_FLOAT_EQ(result.x, 1.25f);
+    EXPECT_FLOAT_EQ(result.y, -3.75f);
+    EXPECT_FLOAT_EQ(result.z, 0.5f);
+}
+
+TEST(Vector3Cast, FloatToInt_Truncates)
+{
+    constexpr Vector3<float> v{3.9f, -2.1f, 7.7f};
+    constexpr auto result = static_cast<Vector3<int>>(v);
+    EXPECT_EQ(result.x, 3);
+    EXPECT_EQ(result.y, -2);
+    EXPECT_EQ(result.z, 7);
+}
+
+TEST(Vector3Cast, IntToFloat_Exact)
+{
+    constexpr Vector3<int> v{7, -4, 0};
+    constexpr auto result = static_cast<Vector3<float>>(v);
+    EXPECT_FLOAT_EQ(result.x, 7.f);
+    EXPECT_FLOAT_EQ(result.y, -4.f);
+    EXPECT_FLOAT_EQ(result.z, 0.f);
+}
+
+TEST(Vector3Cast, ZeroPreserved)
+{
+    constexpr Vector3<float> v{0.f, 0.f, 0.f};
+    constexpr auto result = static_cast<Vector3<double>>(v);
+    EXPECT_DOUBLE_EQ(result.x, 0.0);
+    EXPECT_DOUBLE_EQ(result.y, 0.0);
+    EXPECT_DOUBLE_EQ(result.z, 0.0);
+}
+
+TEST(Vector3Cast, NegativeValues)
+{
+    constexpr Vector3<double> v{-100.0, -200.0, -300.0};
+    constexpr auto result = static_cast<Vector3<float>>(v);
+    EXPECT_FLOAT_EQ(result.x, -100.f);
+    EXPECT_FLOAT_EQ(result.y, -200.f);
+    EXPECT_FLOAT_EQ(result.z, -300.f);
+}
+
+TEST(Vector3Cast, SameTypeRoundtrip)
+{
+    constexpr Vector3<float> v{1.f, 2.f, 3.f};
+    constexpr auto result = static_cast<Vector3<float>>(v);
+    EXPECT_FLOAT_EQ(result.x, v.x);
+    EXPECT_FLOAT_EQ(result.y, v.y);
+    EXPECT_FLOAT_EQ(result.z, v.z);
+}
+
 // Static assertions (compile-time checks)
 static_assert(Vector3(1.0f, 2.0f, 3.0f).length_sqr() == 14.0f, "LengthSqr should be 14");
 static_assert(Vector3(1.0f, 2.0f, 3.0f).dot(Vector3(4.0f, 5.0f, 6.0f)) == 32.0f, "Dot product should be 32");

tests/general/unit_test_vector4.cpp

@@ -261,3 +261,77 @@ TEST_F(UnitTestVector4, GreaterEqualOperator)
     EXPECT_TRUE(omath::Vector4<float>{} >= omath::Vector4<float>{});
     EXPECT_TRUE(omath::Vector4(1.f, 1.f, 1.f, 1.f) >= omath::Vector4<float>{});
 }
+
+// ── Cast operator tests ──────────────────────────────────────────────────────
+
+using namespace omath;
+
+TEST(Vector4Cast, FloatToDouble)
+{
+    constexpr Vector4<float> v{1.5f, -2.5f, 3.0f, 4.25f};
+    constexpr auto result = static_cast<Vector4<double>>(v);
+    EXPECT_DOUBLE_EQ(result.x, 1.5);
+    EXPECT_DOUBLE_EQ(result.y, -2.5);
+    EXPECT_DOUBLE_EQ(result.z, 3.0);
+    EXPECT_DOUBLE_EQ(result.w, 4.25);
+}
+
+TEST(Vector4Cast, DoubleToFloat)
+{
+    constexpr Vector4<double> v{1.25, -3.75, 0.5, -0.125};
+    constexpr auto result = static_cast<Vector4<float>>(v);
+    EXPECT_FLOAT_EQ(result.x, 1.25f);
+    EXPECT_FLOAT_EQ(result.y, -3.75f);
+    EXPECT_FLOAT_EQ(result.z, 0.5f);
+    EXPECT_FLOAT_EQ(result.w, -0.125f);
+}
+
+TEST(Vector4Cast, FloatToInt_Truncates)
+{
+    constexpr Vector4<float> v{3.9f, -2.1f, 7.7f, -0.9f};
+    constexpr auto result = static_cast<Vector4<int>>(v);
+    EXPECT_EQ(result.x, 3);
+    EXPECT_EQ(result.y, -2);
+    EXPECT_EQ(result.z, 7);
+    EXPECT_EQ(result.w, 0);
+}
+
+TEST(Vector4Cast, IntToFloat_Exact)
+{
+    constexpr Vector4<int> v{7, -4, 0, 1};
+    constexpr auto result = static_cast<Vector4<float>>(v);
+    EXPECT_FLOAT_EQ(result.x, 7.f);
+    EXPECT_FLOAT_EQ(result.y, -4.f);
+    EXPECT_FLOAT_EQ(result.z, 0.f);
+    EXPECT_FLOAT_EQ(result.w, 1.f);
+}
+
+TEST(Vector4Cast, ZeroPreserved)
+{
+    constexpr Vector4<float> v{0.f, 0.f, 0.f, 0.f};
+    constexpr auto result = static_cast<Vector4<double>>(v);
+    EXPECT_DOUBLE_EQ(result.x, 0.0);
+    EXPECT_DOUBLE_EQ(result.y, 0.0);
+    EXPECT_DOUBLE_EQ(result.z, 0.0);
+    EXPECT_DOUBLE_EQ(result.w, 0.0);
+}
+
+TEST(Vector4Cast, NegativeValues)
+{
+    constexpr Vector4<double> v{-100.0, -200.0, -300.0, -400.0};
+    constexpr auto result = static_cast<Vector4<float>>(v);
+    EXPECT_FLOAT_EQ(result.x, -100.f);
+    EXPECT_FLOAT_EQ(result.y, -200.f);
+    EXPECT_FLOAT_EQ(result.z, -300.f);
+    EXPECT_FLOAT_EQ(result.w, -400.f);
+}
+
+TEST(Vector4Cast, SameTypeRoundtrip)
+{
+    constexpr Vector4<float> v{1.f, 2.f, 3.f, 4.f};
+    constexpr auto result = static_cast<Vector4<float>>(v);
+    EXPECT_FLOAT_EQ(result.x, v.x);
+    EXPECT_FLOAT_EQ(result.y, v.y);
+    EXPECT_FLOAT_EQ(result.z, v.z);
+    EXPECT_FLOAT_EQ(result.w, v.w);
+}

tests/general/unit_test_walk_bot.cpp

@@ -0,0 +1,640 @@
+// Unit tests for omath::pathfinding::WalkBot
+// Covers all status transitions, callback behaviour, and a full walk simulation.
+#include <gtest/gtest.h>
+#include "omath/pathfinding/walk_bot.hpp"
+#include "omath/pathfinding/navigation_mesh.hpp"
+
+using namespace omath;
+using namespace omath::pathfinding;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+// Build a simple bidirectional linear chain:
+//   (0,0,0) <-> (1,0,0) <-> (2,0,0) <-> ... <-> (n-1,0,0)
+static std::shared_ptr<NavigationMesh> make_linear_mesh(int n)
+{
+    auto mesh = std::make_shared<NavigationMesh>();
+    for (int i = 0; i < n; ++i)
+    {
+        const Vector3<float> v{static_cast<float>(i), 0.f, 0.f};
+        std::vector<Vector3<float>> neighbors;
+        if (i > 0)
+            neighbors.push_back(Vector3<float>{static_cast<float>(i - 1), 0.f, 0.f});
+        if (i + 1 < n)
+            neighbors.push_back(Vector3<float>{static_cast<float>(i + 1), 0.f, 0.f});
+        mesh->m_vertex_map[v] = neighbors;
+    }
+    return mesh;
+}
+
+// Collect every status update fired during one update() call.
+static auto make_status_recorder(std::vector<WalkBotStatus>& out)
+{
+    return [&out](WalkBotStatus s) { out.push_back(s); };
+}
+
+// Collect every "next node" hint fired during one update() call.
+static auto make_node_recorder(std::vector<Vector3<float>>& out)
+{
+    return [&out](const Vector3<float>& v) { out.push_back(v); };
+}
+
+// ---------------------------------------------------------------------------
+// Construction
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotTests, DefaultConstructedBotIsInert)
+{
+    // A default-constructed bot with no mesh, no target, and no callbacks must
+    // not crash.
+    WalkBot bot;
+    EXPECT_NO_THROW(bot.update({0.f, 0.f, 0.f}));
+}
+
+TEST(WalkBotTests, ConstructWithMeshAndDistance)
+{
+    auto mesh = make_linear_mesh(3);
+    EXPECT_NO_THROW(WalkBot bot(mesh, 0.5f));
+}
+
+// ---------------------------------------------------------------------------
+// Status: FINISHED
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotTests, FiresFinishedWhenBotIsAtTarget)
+{
+    auto mesh = make_linear_mesh(3);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({2.f, 0.f, 0.f});
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+
+    // bot_position == target_position -> distance == 0, well within threshold
+    bot.update({2.f, 0.f, 0.f});
+
+    ASSERT_FALSE(statuses.empty());
+    EXPECT_EQ(statuses.front(), WalkBotStatus::FINISHED);
+}
+
+TEST(WalkBotTests, FiresFinishedWhenBotIsWithinMinDistance)
+{
+    auto mesh = make_linear_mesh(3);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({0.4f, 0.f, 0.f});
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+
+    // distance between (0,0,0) and (0.4,0,0) is 0.4 < 0.5 threshold
+    bot.update({0.f, 0.f, 0.f});
+
+    ASSERT_FALSE(statuses.empty());
+    EXPECT_EQ(statuses.front(), WalkBotStatus::FINISHED);
+}
+
+TEST(WalkBotTests, NoFinishedWhenOutsideMinDistance)
+{
+    auto mesh = make_linear_mesh(5);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({4.f, 0.f, 0.f});
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+
+    // Attach path callback so we get further status updates
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    bot.update({0.f, 0.f, 0.f});
+
+    // FINISHED must NOT appear in the status list
+    for (auto s : statuses)
+        EXPECT_NE(s, WalkBotStatus::FINISHED);
+}
+
+TEST(WalkBotTests, FinishedFiredEvenWithoutPathCallback)
+{
+    // FINISHED is emitted before the on_path guard, so it fires regardless.
+    auto mesh = make_linear_mesh(2);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({1.f, 0.f, 0.f});
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+    // Intentionally do NOT register on_path callback.
+
+    bot.update({1.f, 0.f, 0.f});
+
+    ASSERT_EQ(statuses.size(), 1u);
+    EXPECT_EQ(statuses[0], WalkBotStatus::FINISHED);
+}
+
+TEST(WalkBotTests, FinishedDoesNotFallThroughToPathing)
+{
+    // update() must return after FINISHED — PATHING must not fire on the same tick.
+    auto mesh = make_linear_mesh(3);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({1.f, 0.f, 0.f});
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    bot.update({1.f, 0.f, 0.f}); // bot is at target
+
+    ASSERT_EQ(statuses.size(), 1u);
+    EXPECT_EQ(statuses[0], WalkBotStatus::FINISHED);
+    EXPECT_TRUE(nodes.empty());
+}
+
+// ---------------------------------------------------------------------------
+// No target set
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotTests, NoUpdateWithoutTarget)
+{
+    auto mesh = make_linear_mesh(3);
+    WalkBot bot(mesh, 0.5f);
+    // Intentionally do NOT call set_target()
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    bot.update({0.f, 0.f, 0.f});
+
+    EXPECT_TRUE(statuses.empty());
+    EXPECT_TRUE(nodes.empty());
+}
+
+// ---------------------------------------------------------------------------
+// Status: IDLE — no path callback registered
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotTests, NoPathCallbackMeansNoPathingStatus)
+{
+    auto mesh = make_linear_mesh(4);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({3.f, 0.f, 0.f});
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+    // No on_path registered -> update returns early after FINISHED check
+
+    bot.update({0.f, 0.f, 0.f});
+
+    EXPECT_TRUE(statuses.empty());
+}
+
+// ---------------------------------------------------------------------------
+// Status: IDLE — null/expired navigation mesh
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotTests, FiresIdleWhenNavMeshIsNull)
+{
+    WalkBot bot; // no mesh assigned
+    bot.set_target({5.f, 0.f, 0.f});
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    bot.update({0.f, 0.f, 0.f});
+
+    ASSERT_FALSE(statuses.empty());
+    EXPECT_EQ(statuses.back(), WalkBotStatus::IDLE);
+    EXPECT_TRUE(nodes.empty());
+}
+
+TEST(WalkBotTests, FiresIdleWhenNavMeshExpires)
+{
+    auto mesh = make_linear_mesh(4);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({3.f, 0.f, 0.f});
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    // Let the shared_ptr expire — WalkBot holds only a weak_ptr.
+    mesh.reset();
+
+    bot.update({0.f, 0.f, 0.f});
+
+    ASSERT_FALSE(statuses.empty());
+    EXPECT_EQ(statuses.back(), WalkBotStatus::IDLE);
+    EXPECT_TRUE(nodes.empty());
+}
+
+TEST(WalkBotTests, SetNavMeshRestoresPathing)
+{
+    WalkBot bot; // starts with no mesh
+    bot.set_target({3.f, 0.f, 0.f});
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    // First call — no mesh -> IDLE
+    bot.update({0.f, 0.f, 0.f});
+    ASSERT_EQ(statuses.back(), WalkBotStatus::IDLE);
+
+    // Assign a mesh and call again. Keep the shared_ptr alive so the
+    // weak_ptr inside WalkBot does not expire before update() is called.
+    statuses.clear();
+    nodes.clear();
+    auto new_mesh = make_linear_mesh(4);
+    bot.set_nav_mesh(new_mesh);
+    bot.set_min_node_distance(0.5f);
+    bot.update({0.f, 0.f, 0.f});
+
+    ASSERT_FALSE(statuses.empty());
+    EXPECT_EQ(statuses.back(), WalkBotStatus::PATHING);
+    EXPECT_FALSE(nodes.empty());
+}
+
+// ---------------------------------------------------------------------------
+// Status: IDLE — A* finds no path
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotTests, FiresIdleWhenNoPathExists)
+{
+    // Disconnected graph: two isolated vertices
+    auto mesh = std::make_shared<NavigationMesh>();
+    mesh->m_vertex_map[{0.f, 0.f, 0.f}] = {};
+    mesh->m_vertex_map[{10.f, 0.f, 0.f}] = {};
+
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({10.f, 0.f, 0.f});
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    bot.update({0.f, 0.f, 0.f});
+
+    ASSERT_FALSE(statuses.empty());
+    EXPECT_EQ(statuses.back(), WalkBotStatus::IDLE);
+    EXPECT_TRUE(nodes.empty());
+}
+
+// ---------------------------------------------------------------------------
+// Status: PATHING — normal routing
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotTests, FiresPathingAndProvidesNextNode)
+{
+    auto mesh = make_linear_mesh(4);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({3.f, 0.f, 0.f});
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    bot.update({0.f, 0.f, 0.f});
+
+    ASSERT_FALSE(statuses.empty());
+    EXPECT_EQ(statuses.back(), WalkBotStatus::PATHING);
+    ASSERT_FALSE(nodes.empty());
+}
+
+TEST(WalkBotTests, NextNodeIsOnThePath)
+{
+    auto mesh = make_linear_mesh(5);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({4.f, 0.f, 0.f});
+
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    bot.update({0.f, 0.f, 0.f});
+
+    // The suggested node must be a mesh vertex (x in [0..4], y=0, z=0)
+    ASSERT_FALSE(nodes.empty());
+    const auto& hint = nodes.front();
+    EXPECT_GE(hint.x, 0.f);
+    EXPECT_LE(hint.x, 4.f);
+    EXPECT_FLOAT_EQ(hint.y, 0.f);
+    EXPECT_FLOAT_EQ(hint.z, 0.f);
+}
+
+// ---------------------------------------------------------------------------
+// set_min_node_distance
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotTests, MinNodeDistanceAffectsFinishedThreshold)
+{
+    auto mesh = make_linear_mesh(3);
+    WalkBot bot(mesh, 0.1f); // very tight threshold
+    bot.set_target({1.f, 0.f, 0.f});
+
+    std::vector<WalkBotStatus> statuses;
+    bot.on_status(make_status_recorder(statuses));
+
+    // distance 0.4 — outside 0.1 threshold
+    bot.update({0.6f, 0.f, 0.f});
+    EXPECT_TRUE(statuses.empty() ||
+                std::find(statuses.begin(), statuses.end(), WalkBotStatus::FINISHED) == statuses.end());
+
+    statuses.clear();
+    bot.set_min_node_distance(0.5f); // widen threshold
+    bot.update({0.6f, 0.f, 0.f});   // now 0.4 < 0.5 -> FINISHED
+
+    ASSERT_FALSE(statuses.empty());
+    EXPECT_EQ(statuses.front(), WalkBotStatus::FINISHED);
+}
+
+// ---------------------------------------------------------------------------
+// reset()
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotTests, ResetClearsLastVisited)
+{
+    auto mesh = make_linear_mesh(3);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({2.f, 0.f, 0.f});
+
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    // Tick 1: mark node 0 visited -> hint is node 1
+    bot.update({0.05f, 0.f, 0.f});
+    ASSERT_FALSE(nodes.empty());
+    EXPECT_FLOAT_EQ(nodes.back().x, 1.f);
+
+    // Without reset, a second tick from the same position also gives node 1.
+    nodes.clear();
+    bot.reset();
+
+    // After reset, m_last_visited is cleared. The nearest node is 0 again,
+    // it is within threshold so it gets marked visited and we advance to 1.
+    // The hint should still be node 1 (same outcome, but state was cleanly reset).
+    bot.update({0.05f, 0.f, 0.f});
+    ASSERT_FALSE(nodes.empty());
+    // Confirm the bot still routes correctly after reset.
+    EXPECT_GE(nodes.back().x, 0.f);
+}
+
+// ---------------------------------------------------------------------------
+// Node advancement — visited node causes skip to next
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotTests, AdvancesWhenNearestNodeAlreadyVisited)
+{
+    // Chain: (0,0,0) -> (1,0,0) -> (2,0,0)
+    auto mesh = make_linear_mesh(3);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({2.f, 0.f, 0.f});
+
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    // Tick 1: bot is very close to node 0 -> node 0 marked visited -> hint is node 1.
+    bot.update({0.05f, 0.f, 0.f});
+    ASSERT_FALSE(nodes.empty());
+    EXPECT_FLOAT_EQ(nodes.back().x, 1.f);
+
+    nodes.clear();
+
+    // Tick 2: bot has moved to near node 1 -> node 1 marked visited -> hint advances to node 2.
+    bot.update({1.05f, 0.f, 0.f});
+    ASSERT_FALSE(nodes.empty());
+    EXPECT_GT(nodes.back().x, 1.f);
+}
+
+// ---------------------------------------------------------------------------
+// Displacement recovery — bot knocked back to unvisited node
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotTests, RecoverAfterDisplacementToUnvisitedNode)
+{
+    // Chain: 0 -> 1 -> 2 -> 3 -> 4
+    auto mesh = make_linear_mesh(5);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({4.f, 0.f, 0.f});
+
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    // Walk forward through nodes 0-3 to build visited state.
+    for (int i = 0; i <= 3; ++i)
+    {
+        nodes.clear();
+        bot.update(Vector3<float>{static_cast<float>(i) + 0.1f, 0.f, 0.f});
+    }
+
+    // Displace the bot back to near node 1. The bot should route toward node 1
+    // first rather than skipping ahead to node 4.
+    nodes.clear();
+    bot.update({1.1f, 0.f, 0.f});
+
+    ASSERT_FALSE(nodes.empty());
+    EXPECT_LE(nodes.back().x, 3.f);
+}
+
+// ---------------------------------------------------------------------------
+// Callback wiring
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotTests, ReplacingPathCallbackTakesEffect)
+{
+    auto mesh = make_linear_mesh(4);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({3.f, 0.f, 0.f});
+
+    int first_cb_calls = 0;
+    int second_cb_calls = 0;
+
+    bot.on_path([&](const Vector3<float>&) { ++first_cb_calls; });
+    bot.update({0.f, 0.f, 0.f});
+
+    bot.on_path([&](const Vector3<float>&) { ++second_cb_calls; });
+    bot.update({0.f, 0.f, 0.f});
+
+    EXPECT_EQ(first_cb_calls, 1);
+    EXPECT_EQ(second_cb_calls, 1);
+}
+
+TEST(WalkBotTests, ReplacingStatusCallbackTakesEffect)
+{
+    auto mesh = make_linear_mesh(4);
+    WalkBot bot(mesh, 0.5f);
+    bot.set_target({3.f, 0.f, 0.f});
+
+    std::vector<Vector3<float>> nodes;
+    bot.on_path(make_node_recorder(nodes));
+
+    int cb1 = 0, cb2 = 0;
+    bot.on_status([&](WalkBotStatus) { ++cb1; });
+    bot.update({0.f, 0.f, 0.f});
+
+    bot.on_status([&](WalkBotStatus) { ++cb2; });
+    bot.update({0.f, 0.f, 0.f});
+
+    EXPECT_EQ(cb1, 1);
+    EXPECT_EQ(cb2, 1);
+}
+
+// ---------------------------------------------------------------------------
+// Full walk simulation — bot traverses a linear mesh step by step
+// ---------------------------------------------------------------------------
+
+// Simulates one game-loop tick and immediately "teleports" the bot to the
+// suggested node so the next tick starts from there.
+struct WalkSimulator
+{
+    WalkBot bot;
+    Vector3<float> position;
+    std::vector<Vector3<float>> visited_nodes;
+    std::vector<WalkBotStatus> status_history;
+    bool finished{false};
+
+    WalkSimulator(const std::shared_ptr<NavigationMesh>& mesh,
+                  const Vector3<float>& start,
+                  const Vector3<float>& goal,
+                  float threshold)
+        : position(start)
+    {
+        bot = WalkBot(mesh, threshold);
+        bot.set_target(goal);
+        bot.on_path([this](const Vector3<float>& next) {
+            visited_nodes.push_back(next);
+            position = next; // teleport to the suggested node
+        });
+        bot.on_status([this](WalkBotStatus s) {
+            status_history.push_back(s);
+            if (s == WalkBotStatus::FINISHED)
+                finished = true;
+        });
+    }
+
+    void run(int max_ticks = 100)
+    {
+        for (int tick = 0; tick < max_ticks && !finished; ++tick)
+            bot.update(position);
+    }
+};
+
+TEST(WalkBotSimulation, BotReachesTargetOnLinearMesh)
+{
+    auto mesh = make_linear_mesh(5);
+    WalkSimulator sim(mesh, {0.f, 0.f, 0.f}, {4.f, 0.f, 0.f}, 0.5f);
+    sim.run(50);
+
+    EXPECT_TRUE(sim.finished);
+}
+
+TEST(WalkBotSimulation, StatusTransitionSequenceIsCorrect)
+{
+    // Expect: one or more PATHING updates, then exactly FINISHED at the end.
+    auto mesh = make_linear_mesh(4);
+    WalkSimulator sim(mesh, {0.f, 0.f, 0.f}, {3.f, 0.f, 0.f}, 0.5f);
+    sim.run(50);
+
+    ASSERT_TRUE(sim.finished);
+    ASSERT_FALSE(sim.status_history.empty());
+
+    // All entries before the last must be PATHING
+    for (std::size_t i = 0; i + 1 < sim.status_history.size(); ++i)
+        EXPECT_EQ(sim.status_history[i], WalkBotStatus::PATHING);
+
+    EXPECT_EQ(sim.status_history.back(), WalkBotStatus::FINISHED);
+}
+
+TEST(WalkBotSimulation, BotVisitsNodesInForwardOrder)
+{
+    auto mesh = make_linear_mesh(5);
+    WalkSimulator sim(mesh, {0.f, 0.f, 0.f}, {4.f, 0.f, 0.f}, 0.5f);
+    sim.run(50);
+
+    ASSERT_FALSE(sim.visited_nodes.empty());
+
+    // Verify that x-coordinates are non-decreasing (forward progress only).
+    for (std::size_t i = 1; i < sim.visited_nodes.size(); ++i)
+        EXPECT_GE(sim.visited_nodes[i].x, sim.visited_nodes[i - 1].x - 1e-3f);
+}
+
+TEST(WalkBotSimulation, TwoNodePathReachesGoal)
+{
+    auto mesh = make_linear_mesh(2); // (0,0,0) <-> (1,0,0)
+    WalkSimulator sim(mesh, {0.f, 0.f, 0.f}, {1.f, 0.f, 0.f}, 0.5f);
+    sim.run(10);
+
+    EXPECT_TRUE(sim.finished);
+}
+
+TEST(WalkBotSimulation, LongChainEventuallyFinishes)
+{
+    constexpr int kLength = 20;
+    auto mesh = make_linear_mesh(kLength);
+    WalkSimulator sim(mesh,
+                      {0.f, 0.f, 0.f},
+                      {static_cast<float>(kLength - 1), 0.f, 0.f},
+                      0.5f);
+    sim.run(200);
+
+    EXPECT_TRUE(sim.finished);
+}
+
+TEST(WalkBotSimulation, StartAlreadyAtTargetFinishesImmediately)
+{
+    auto mesh = make_linear_mesh(3);
+    WalkSimulator sim(mesh, {1.f, 0.f, 0.f}, {1.f, 0.f, 0.f}, 0.5f);
+    sim.run(5);
+
+    EXPECT_TRUE(sim.finished);
+    EXPECT_EQ(sim.status_history.front(), WalkBotStatus::FINISHED);
+    EXPECT_EQ(sim.status_history.size(), 1u);
+}
+
+TEST(WalkBotSimulation, NoIdleEmittedDuringSuccessfulWalk)
+{
+    auto mesh = make_linear_mesh(4);
+    WalkSimulator sim(mesh, {0.f, 0.f, 0.f}, {3.f, 0.f, 0.f}, 0.5f);
+    sim.run(50);
+
+    for (auto s : sim.status_history)
+        EXPECT_NE(s, WalkBotStatus::IDLE);
+}
+
+// ---------------------------------------------------------------------------
+// Walk simulation on a branching mesh
+// ---------------------------------------------------------------------------
+
+TEST(WalkBotSimulation, BotNavigatesBranchingMesh)
+{
+    // Diamond topology:
+    //        (1,1,0)
+    //       /       \
+    // (0,0,0)       (2,0,0)
+    //       \       /
+    //        (1,-1,0)
+    auto mesh = std::make_shared<NavigationMesh>();
+    const Vector3<float> start{0.f, 0.f, 0.f};
+    const Vector3<float> top{1.f, 1.f, 0.f};
+    const Vector3<float> bot_node{1.f, -1.f, 0.f};
+    const Vector3<float> goal{2.f, 0.f, 0.f};
+
+    mesh->m_vertex_map[start]    = {top, bot_node};
+    mesh->m_vertex_map[top]      = {start, goal};
+    mesh->m_vertex_map[bot_node] = {start, goal};
+    mesh->m_vertex_map[goal]     = {top, bot_node};
+
+    WalkSimulator sim(mesh, start, goal, 0.5f);
+    sim.run(20);
+
+    EXPECT_TRUE(sim.finished);
+}