updated version

Feature/hooking

.github/workflows/cmake-multi-platform.yml

@@ -370,6 +370,8 @@ jobs:
         shell: bash
         run: |
           cmake --preset ${{ matrix.preset }} \
+            -DCMAKE_C_COMPILER=$(xcrun --find clang) \
+            -DCMAKE_CXX_COMPILER=$(xcrun --find clang++) \
             -DOMATH_BUILD_TESTS=ON \
             -DOMATH_BUILD_BENCHMARK=OFF \
             -DOMATH_ENABLE_COVERAGE=${{ matrix.coverage == true && 'ON' || 'OFF' }} \
@@ -380,6 +382,7 @@ jobs:
         run: cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
 
       - name: Run unit_tests
+        if: ${{ matrix.coverage != true }}
         shell: bash
         run: ./out/Release/unit_tests
 

.github/workflows/docs.yml

@@ -0,0 +1,62 @@
+name: Documentation
+
+on:
+  push:
+    branches: [ main ]
+    paths:
+      - 'docs/**'
+      - 'mkdocs.yml'
+      - '.github/workflows/docs.yml'
+  pull_request:
+    branches: [ main ]
+    paths:
+      - 'docs/**'
+      - 'mkdocs.yml'
+      - '.github/workflows/docs.yml'
+
+concurrency:
+  group: docs-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+jobs:
+  build:
+    name: Build Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Install mkdocs and dependencies
+        run: pip install mkdocs mkdocs-bootswatch
+
+      - name: Build documentation
+        run: mkdocs build --strict
+
+      - name: Upload artifact
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: site/
+
+  deploy:
+    name: Deploy to GitHub Pages
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

.github/workflows/release.yml

@@ -12,6 +12,35 @@ permissions:
   contents: write
 
 jobs:
+  ##############################################################################
+  # 0)  Documentation  –  MkDocs
+  ##############################################################################
+  docs-release:
+    name: Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Install mkdocs and dependencies
+        run: pip install mkdocs mkdocs-bootswatch
+
+      - name: Build documentation
+        run: mkdocs build --strict
+
+      - name: Package
+        run: tar -czf omath-docs.tar.gz -C site .
+
+      - name: Upload release asset
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: gh release upload "${{ github.event.release.tag_name }}" omath-docs.tar.gz --clobber
+
   ##############################################################################
   # 1)  Linux  –  Clang / Ninja
   ##############################################################################

.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" />

CMakeLists.txt

@@ -1,5 +1,4 @@
 cmake_minimum_required(VERSION 3.26)
-
 file(READ VERSION OMATH_VERSION)
 project(omath VERSION ${OMATH_VERSION} LANGUAGES CXX)
 
@@ -31,9 +30,10 @@ option(OMATH_SUPRESS_SAFETY_CHECKS
 option(OMATH_ENABLE_COVERAGE "Enable coverage" OFF)
 option(OMATH_ENABLE_FORCE_INLINE
        "Will for compiler to make some functions to be force inlined no matter what" ON)
-
 option(OMATH_ENABLE_LUA
         "omath bindings for lua" OFF)
+option(OMATH_ENABLE_HOOKING "omath will HooksManager that can hook DirectX automatically" OFF)
+
 if(VCPKG_MANIFEST_FEATURES)
     foreach(omath_feature IN LISTS VCPKG_MANIFEST_FEATURES)
         if(omath_feature STREQUAL "imgui")
@@ -48,6 +48,8 @@ if(VCPKG_MANIFEST_FEATURES)
             set(OMATH_BUILD_EXAMPLES ON)
         elseif(omath_feature STREQUAL "lua")
             set(OMATH_ENABLE_LUA ON)
+        elseif(omath_feature STREQUAL "hooking")
+            set(OMATH_ENABLE_HOOKING ON)
         endif()
 
     endforeach()
@@ -80,6 +82,10 @@ if(${PROJECT_IS_TOP_LEVEL})
     message(STATUS "[${PROJECT_NAME}]: Lua feature status ${OMATH_ENABLE_LUA}")
 endif()
 
+if(OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
+    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>" CACHE STRING "" FORCE)
+endif()
+
 file(GLOB_RECURSE OMATH_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp")
 file(GLOB_RECURSE OMATH_HEADERS CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp")
 
@@ -100,6 +106,17 @@ if (OMATH_ENABLE_LUA)
     target_include_directories(${PROJECT_NAME} PRIVATE ${SOL2_INCLUDE_DIRS})
 endif ()
 
+if (OMATH_ENABLE_HOOKING)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_HOOKING)
+
+    find_package(safetyhook CONFIG REQUIRED)
+    target_link_libraries(${PROJECT_NAME} PRIVATE safetyhook::safetyhook)
+
+    if (WIN32)
+        target_link_libraries(${PROJECT_NAME} PRIVATE d3d9 d3d11 d3d12 dxgi)
+    endif ()
+endif ()
+
 add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
 
 target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_VERSION="${PROJECT_VERSION}")
@@ -147,10 +164,6 @@ set_target_properties(
                CXX_STANDARD 23
                CXX_STANDARD_REQUIRED ON)
 
-if(OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
-    set_target_properties(${PROJECT_NAME} PROPERTIES MSVC_RUNTIME_LIBRARY
-                                                     "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-endif()
 
 if(OMATH_USE_AVX2)
     if(MSVC)

CMakePresets.json

@@ -56,7 +56,9 @@
       "hidden": true,
       "inherits": ["windows-base", "vcpkg-base"],
       "cacheVariables": {
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples"
+        "VCPKG_TARGET_TRIPLET": "x64-windows-static",
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;hooking",
+        "OMATH_STATIC_MSVC_RUNTIME_LIBRARY": "ON"
       }
     },
     {
@@ -89,9 +91,10 @@
         "strategy": "external"
       },
       "cacheVariables": {
-        "VCPKG_TARGET_TRIPLET": "x86-windows",
+        "VCPKG_TARGET_TRIPLET": "x86-windows-static",
         "VCPKG_HOST_TRIPLET": "x64-windows",
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples"
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples",
+        "OMATH_STATIC_MSVC_RUNTIME_LIBRARY": "ON"
       }
     },
     {
@@ -114,9 +117,10 @@
         "strategy": "external"
       },
       "cacheVariables": {
-        "VCPKG_TARGET_TRIPLET": "arm64-windows",
+        "VCPKG_TARGET_TRIPLET": "arm64-windows-static",
-        "VCPKG_HOST_TRIPLET": "arm64-windows",
+        "VCPKG_HOST_TRIPLET": "arm64-windows-static",
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;examples"
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;examples",
+        "OMATH_STATIC_MSVC_RUNTIME_LIBRARY": "ON"
       }
     },
     {

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.

CREDITS.md

@@ -3,7 +3,6 @@
 Thanks to everyone who made this possible, including:
 
 - Saikari aka luadebug for VCPKG port and awesome new initial logo design.
-- AmbushedRaccoon for telegram post about omath to boost repository activity.
 - Billy O'Neal aka BillyONeal for fixing compilation issues due to C math library compatibility.
 - Alex2772 for reference of AUI declarative interface design for omath::hud
 

INSTALL.md

@@ -28,6 +28,29 @@ target("...")
     add_packages("omath")
 ```
 
+## <img width="28px" src="https://conan.io/favicon.png" /> Using Conan
+**Note**: Support Conan for package management
+1. Install [Conan](https://conan.io/downloads)
+2. Run the following command to install the omath package:
+```
+conan install --requires="omath/[*]" --build=missing
+```
+conanfile.txt
+```ini
+[requires]
+omath/[*]
+
+[generators]
+CMakeDeps
+CMakeToolchain
+```
+CMakeLists.txt
+```cmake
+find_package(omath CONFIG REQUIRED)
+target_link_libraries(main PRIVATE omath::omath)
+```
+For more details, see the [Conan documentation](https://docs.conan.io/2/).
+
 ## <img width="28px" src="https://github.githubassets.com/favicons/favicon.svg" /> Using prebuilt binaries (GitHub Releases)
 
 **Note**: This is the fastest option if you don’t want to build from source.

VERSION

@@ -1 +1 @@
-5.0.0
+5.2.0

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);
 }
 

docs/install.md

@@ -1,6 +1,6 @@
-# Installation
+# Installation Guide
 
-## <img width="28px" src="https://vcpkg.io/assets/mark/mark.svg" /> Using vcpkg
+## <img width="28px" src="https://vcpkg.io/assets/mark/mark.svg" /> Using vcpkg (recomended)
 **Note**: Support vcpkg for package management
 1. Install [vcpkg](https://github.com/microsoft/vcpkg)
 2. Run the following command to install the orange-math package:
@@ -28,6 +28,69 @@ target("...")
     add_packages("omath")
 ```
 
+## <img width="28px" src="https://conan.io/favicon.png" /> Using Conan
+**Note**: Support Conan for package management
+1. Install [Conan](https://conan.io/downloads)
+2. Run the following command to install the omath package:
+```
+conan install --requires="omath/[*]" --build=missing
+```
+conanfile.txt
+```ini
+[requires]
+omath/[*]
+
+[generators]
+CMakeDeps
+CMakeToolchain
+```
+CMakeLists.txt
+```cmake
+find_package(omath CONFIG REQUIRED)
+target_link_libraries(main PRIVATE omath::omath)
+```
+For more details, see the [Conan documentation](https://docs.conan.io/2/).
+
+## <img width="28px" src="https://github.githubassets.com/favicons/favicon.svg" /> Using prebuilt binaries (GitHub Releases)
+
+**Note**: This is the fastest option if you don’t want to build from source.
+
+1. **Go to the Releases page**
+    - Open the project’s GitHub **Releases** page and choose the latest version.
+
+2. **Download the correct asset for your platform**
+    - Pick the archive that matches your OS and architecture (for example: Windows x64 / Linux x64 / macOS arm64).
+
+3. **Extract the archive**
+    - You should end up with something like:
+        - `include/` (headers)
+        - `lib/` or `bin/` (library files / DLLs)
+        - sometimes `cmake/` (CMake package config)
+
+4. **Use it in your project**
+
+   ### Option A: CMake package (recommended if the release includes CMake config files)
+   If the extracted folder contains something like `lib/cmake/omath` or `cmake/omath`, you can point CMake to it:
+
+   ```cmake
+   # Example: set this to the extracted prebuilt folder
+   list(APPEND CMAKE_PREFIX_PATH "path/to/omath-prebuilt")
+
+   find_package(omath CONFIG REQUIRED)
+   target_link_libraries(main PRIVATE omath::omath)
+   ```
+   ### Option B: Manual include + link (works with any layout)
+   If there’s no CMake package config, link it manually:
+   ```cmake
+   target_include_directories(main PRIVATE "path/to/omath-prebuilt/include")
+
+    # Choose ONE depending on what you downloaded:
+    # - Static library: .lib / .a
+    # - Shared library: .dll + .lib import (Windows), .so (Linux), .dylib (macOS)
+    
+    target_link_directories(main PRIVATE "path/to/omath-prebuilt/lib")
+    target_link_libraries(main PRIVATE omath)  # or the actual library filename
+    ```
 ## <img width="28px" src="https://upload.wikimedia.org/wikipedia/commons/e/ef/CMake_logo.svg?" /> Build from source using CMake
 1. **Preparation**
 
@@ -62,7 +125,7 @@ target("...")
    Use **\<platform\>-\<build configuration\>** preset to build suitable version for yourself. Like **windows-release** or **linux-release**.
 
    | Platform Name | Build Config  |
-          |---------------|---------------|
+       |---------------|---------------|
    | windows       | release/debug |
    | linux         | release/debug |
    | darwin        | release/debug |

examples/CMakeLists.txt

@@ -4,6 +4,19 @@ add_subdirectory(example_proj_mat_builder)
 add_subdirectory(example_signature_scan)
 add_subdirectory(example_hud)
 
+if(OMATH_ENABLE_HOOKING AND WIN32)
+    # Requires imgui with dx9-binding, dx11-binding, dx12-binding, win32-binding.
+    # Install via: vcpkg install imgui[dx9-binding,dx11-binding,dx12-binding,win32-binding]
+    find_package(imgui CONFIG QUIET)
+    if(imgui_FOUND)
+        add_subdirectory(example_dx9_hook)
+        add_subdirectory(example_dx11_hook)
+        add_subdirectory(example_dx12_hook)
+    else()
+        message(STATUS "[omath] imgui not found — DX hook examples skipped")
+    endif()
+endif()
+
 if(OMATH_ENABLE_VALGRIND)
     omath_setup_valgrind(example_projection_matrix_builder)
     omath_setup_valgrind(example_signature_scan)

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_dx11_hook/CMakeLists.txt

@@ -0,0 +1,13 @@
+project(example_dx11_hook)
+
+add_library(${PROJECT_NAME} SHARED dllmain.cpp)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    CXX_STANDARD 23
+    MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
+    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}")
+
+find_package(imgui CONFIG REQUIRED)
+target_link_libraries(${PROJECT_NAME} PRIVATE omath::omath imgui::imgui d3d11 dxgi)

examples/example_dx11_hook/dllmain.cpp

@@ -0,0 +1,138 @@
+#include <Windows.h>
+#include <d3d11.h>
+#include <dxgi.h>
+#include <imgui.h>
+#include <imgui_impl_dx11.h>
+#include <imgui_impl_win32.h>
+
+#include "omath/hooks/hooks_manager.hpp"
+
+extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND, UINT, WPARAM, LPARAM);
+
+namespace
+{
+    bool g_initialized    = false;
+    bool g_init_attempted = false;
+
+    ID3D11Device*            g_device             = nullptr;
+    ID3D11DeviceContext*     g_context             = nullptr;
+    ID3D11RenderTargetView*  g_render_target_view  = nullptr;
+
+    void create_render_target(IDXGISwapChain* swap_chain)
+    {
+        ID3D11Texture2D* back_buffer = nullptr;
+        if (FAILED(swap_chain->GetBuffer(0, IID_PPV_ARGS(&back_buffer))))
+            return;
+        g_device->CreateRenderTargetView(back_buffer, nullptr, &g_render_target_view);
+        back_buffer->Release();
+    }
+
+    void init(IDXGISwapChain* swap_chain)
+    {
+        g_init_attempted = true;
+
+        if (FAILED(swap_chain->GetDevice(IID_PPV_ARGS(&g_device))))
+            return;
+
+        g_device->GetImmediateContext(&g_context);
+
+        DXGI_SWAP_CHAIN_DESC desc{};
+        swap_chain->GetDesc(&desc);
+
+        create_render_target(swap_chain);
+
+        ImGui::CreateContext();
+        ImGui::StyleColorsDark();
+        ImGui::GetIO().IniFilename = nullptr;
+        ImGui::GetIO().LogFilename = nullptr;
+        ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange;
+
+        ImGui_ImplWin32_Init(desc.OutputWindow);
+        ImGui_ImplDX11_Init(g_device, g_context);
+
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.set_on_wnd_proc([](HWND h, UINT msg, WPARAM wp, LPARAM lp) -> std::optional<LRESULT> {
+            if (ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp))
+                return 0;
+            return std::nullopt;
+        });
+        mgr.hook_wnd_proc(desc.OutputWindow);
+
+        g_initialized = true;
+    }
+
+    void on_present(IDXGISwapChain* swap_chain, UINT, UINT)
+    {
+        if (!g_initialized)
+        {
+            if (!g_init_attempted)
+                init(swap_chain);
+            return;
+        }
+
+        if (!g_render_target_view)
+            create_render_target(swap_chain);
+
+        g_context->OMSetRenderTargets(1, &g_render_target_view, nullptr);
+
+        ImGui_ImplDX11_NewFrame();
+        ImGui_ImplWin32_NewFrame();
+        ImGui::NewFrame();
+
+        ImGui::SetNextWindowSize({300.f, 80.f}, ImGuiCond_Once);
+        ImGui::SetNextWindowPos({10.f, 10.f}, ImGuiCond_Once);
+        ImGui::Begin("omath | DX11 hook");
+        ImGui::Text("Hook active");
+        ImGui::Text("FPS: %.1f", ImGui::GetIO().Framerate);
+        ImGui::End();
+
+        ImGui::Render();
+        ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
+    }
+
+    void on_resize_buffers(IDXGISwapChain*, UINT, UINT, UINT, DXGI_FORMAT, UINT)
+    {
+        if (g_render_target_view)
+        {
+            g_render_target_view->Release();
+            g_render_target_view = nullptr;
+        }
+    }
+} // namespace
+
+BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
+{
+    if (reason == DLL_PROCESS_ATTACH)
+    {
+        DisableThreadLibraryCalls(h_instance);
+        CreateThread(nullptr, 0, [](LPVOID) -> DWORD
+        {
+            while (!GetModuleHandle("d3d11.dll"))
+                Sleep(100);
+
+            auto& mgr = omath::hooks::HooksManager::get();
+            mgr.set_on_present(on_present);
+            mgr.set_on_resize_buffers(on_resize_buffers);
+            mgr.hook_dx11();
+            return 0;
+        }, nullptr, 0, nullptr);
+    }
+    else if (reason == DLL_PROCESS_DETACH)
+    {
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.unhook_wnd_proc();
+        mgr.unhook_dx11();
+
+        if (g_initialized)
+        {
+            ImGui_ImplDX11_Shutdown();
+            ImGui_ImplWin32_Shutdown();
+            ImGui::DestroyContext();
+        }
+
+        if (g_render_target_view) { g_render_target_view->Release(); g_render_target_view = nullptr; }
+        if (g_context)            { g_context->Release();            g_context            = nullptr; }
+        if (g_device)             { g_device->Release();             g_device             = nullptr; }
+    }
+    return TRUE;
+}

examples/example_dx12_hook/CMakeLists.txt

@@ -0,0 +1,13 @@
+project(example_dx12_hook)
+
+add_library(${PROJECT_NAME} MODULE dllmain.cpp)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    CXX_STANDARD 23
+    MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
+    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}")
+
+find_package(imgui CONFIG REQUIRED)
+target_link_libraries(${PROJECT_NAME} PRIVATE omath::omath imgui::imgui d3d12 dxgi)

examples/example_dx12_hook/dllmain.cpp

@@ -0,0 +1,254 @@
+#include "omath/hooks/hooks_manager.hpp"
+#include <Windows.h>
+#include <d3d12.h>
+#include <dxgi1_4.h>
+#include <imgui.h>
+#include <imgui_impl_dx12.h>
+#include <imgui_impl_win32.h>
+#include <tuple>
+#include <vector>
+
+extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND, UINT, WPARAM, LPARAM);
+bool show_menu = true;
+
+namespace
+{
+    struct frame_context
+    {
+        ID3D12Resource* render_target = nullptr;
+        D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = {};
+    };
+
+    bool g_initialized = false;
+    bool g_init_attempted = false;
+
+    ID3D12Device* g_device = nullptr;
+    ID3D12CommandQueue* g_command_queue = nullptr;
+    IDXGISwapChain3* g_swap_chain = nullptr;
+    ID3D12DescriptorHeap* g_rtv_heap = nullptr;
+    ID3D12DescriptorHeap* g_srv_heap = nullptr;
+    ID3D12GraphicsCommandList* g_command_list = nullptr;
+    ID3D12CommandAllocator* g_command_allocator = nullptr;
+    std::vector<frame_context> g_frames;
+
+    void init(IDXGISwapChain* swap_chain)
+    {
+        g_init_attempted = true;
+
+        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&g_swap_chain))))
+            return;
+
+        if (FAILED(swap_chain->GetDevice(IID_PPV_ARGS(&g_device))))
+            return;
+
+        DXGI_SWAP_CHAIN_DESC desc{};
+        swap_chain->GetDesc(&desc);
+        const UINT buffer_count = desc.BufferCount;
+
+        {
+            D3D12_DESCRIPTOR_HEAP_DESC heap_desc{};
+            heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
+            heap_desc.NumDescriptors = buffer_count;
+            heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
+            if (FAILED(g_device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&g_srv_heap))))
+                return;
+        }
+        {
+            D3D12_DESCRIPTOR_HEAP_DESC heap_desc{};
+            heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
+            heap_desc.NumDescriptors = buffer_count;
+            heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
+            heap_desc.NodeMask = 1;
+            if (FAILED(g_device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&g_rtv_heap))))
+                return;
+        }
+
+        if (FAILED(g_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
+                                                    IID_PPV_ARGS(&g_command_allocator))))
+            return;
+
+        g_frames.resize(buffer_count);
+        const UINT rtv_size = g_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+        D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = g_rtv_heap->GetCPUDescriptorHandleForHeapStart();
+
+        for (UINT i = 0; i < buffer_count; ++i)
+        {
+            g_frames[i].rtv_handle = rtv_handle;
+            if (FAILED(swap_chain->GetBuffer(i, IID_PPV_ARGS(&g_frames[i].render_target))))
+                return;
+            g_device->CreateRenderTargetView(g_frames[i].render_target, nullptr, rtv_handle);
+            rtv_handle.ptr += rtv_size;
+        }
+
+        if (FAILED(g_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, g_command_allocator, nullptr,
+                                               IID_PPV_ARGS(&g_command_list))))
+            return;
+        g_command_list->Close();
+
+        ImGui::CreateContext();
+        ImGui::StyleColorsDark();
+        ImGui::GetIO().IniFilename = nullptr;
+        ImGui::GetIO().LogFilename = nullptr;
+        ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
+
+        ImGui_ImplWin32_Init(desc.OutputWindow);
+        ImGui_ImplDX12_Init(g_device, static_cast<int>(buffer_count), desc.BufferDesc.Format, g_srv_heap,
+                            g_srv_heap->GetCPUDescriptorHandleForHeapStart(),
+                            g_srv_heap->GetGPUDescriptorHandleForHeapStart());
+        ImGui_ImplDX12_CreateDeviceObjects();
+
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.set_on_wnd_proc(
+                [](HWND h, UINT msg, WPARAM wp, LPARAM lp) -> std::optional<LRESULT>
+                {
+                    if (!show_menu)
+                        return std::nullopt;
+
+                    ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp);
+                    return true;
+                });
+        std::ignore = mgr.hook_wnd_proc(desc.OutputWindow);
+
+        g_initialized = true;
+    }
+
+    void on_execute_command_lists(ID3D12CommandQueue* queue, UINT, ID3D12CommandList* const*)
+    {
+        if (!g_command_queue)
+            g_command_queue = queue;
+    }
+
+    void on_present(IDXGISwapChain* swap_chain, UINT, UINT)
+    {
+        if (!g_initialized)
+        {
+            if (!g_init_attempted && g_command_queue)
+                init(swap_chain);
+            return;
+        }
+
+        if (!g_command_queue)
+            return;
+
+        if (GetAsyncKeyState(VK_INSERT) & 1)
+            show_menu = !show_menu;
+
+        if (!show_menu)
+            return;
+
+        ImGui_ImplDX12_NewFrame();
+        ImGui_ImplWin32_NewFrame();
+        ImGui::NewFrame();
+        ImGui::GetIO().MouseDrawCursor = true;
+        ImGui::ShowDemoWindow();
+        ImGui::EndFrame();
+
+        const UINT buf_idx = g_swap_chain->GetCurrentBackBufferIndex();
+        auto& fc = g_frames[buf_idx];
+
+        g_command_allocator->Reset();
+        g_command_list->Reset(g_command_allocator, nullptr);
+
+        D3D12_RESOURCE_BARRIER barrier{};
+        barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
+        barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
+        barrier.Transition.pResource = fc.render_target;
+        barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
+        barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
+        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
+        g_command_list->ResourceBarrier(1, &barrier);
+        g_command_list->OMSetRenderTargets(1, &fc.rtv_handle, FALSE, nullptr);
+        g_command_list->SetDescriptorHeaps(1, &g_srv_heap);
+
+        ImGui::Render();
+        ImGui_ImplDX12_RenderDrawData(ImGui::GetDrawData(), g_command_list);
+
+        barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
+        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT;
+        g_command_list->ResourceBarrier(1, &barrier);
+        g_command_list->Close();
+
+        ID3D12CommandList* cmd_lists[] = {g_command_list};
+        g_command_queue->ExecuteCommandLists(1, cmd_lists);
+    }
+
+    void release_dx12_resources()
+    {
+        for (auto& fc : g_frames)
+        {
+            if (fc.render_target)
+            {
+                fc.render_target->Release();
+                fc.render_target = nullptr;
+            }
+        }
+        g_frames.clear();
+        if (g_command_allocator)
+        {
+            g_command_allocator->Release();
+            g_command_allocator = nullptr;
+        }
+        if (g_command_list)
+        {
+            g_command_list->Release();
+            g_command_list = nullptr;
+        }
+        if (g_srv_heap)
+        {
+            g_srv_heap->Release();
+            g_srv_heap = nullptr;
+        }
+        if (g_rtv_heap)
+        {
+            g_rtv_heap->Release();
+            g_rtv_heap = nullptr;
+        }
+        if (g_swap_chain)
+        {
+            g_swap_chain->Release();
+            g_swap_chain = nullptr;
+        }
+        if (g_device)
+        {
+            g_device->Release();
+            g_device = nullptr;
+        }
+    }
+} // namespace
+
+BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
+{
+    if (reason == DLL_PROCESS_ATTACH)
+    {
+        DisableThreadLibraryCalls(h_instance);
+        CreateThread(
+                nullptr, 0,
+                [](LPVOID) -> DWORD
+                {
+                    while (!GetModuleHandle("d3d12.dll"))
+                        Sleep(100);
+
+                    auto& mgr = omath::hooks::HooksManager::get();
+                    mgr.set_on_present(on_present);
+                    mgr.set_on_execute_command_lists(on_execute_command_lists);
+                    std::ignore = mgr.hook_dx12();
+                    return 0;
+                },
+                nullptr, 0, nullptr);
+    }
+    else if (reason == DLL_PROCESS_DETACH)
+    {
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.unhook_wnd_proc();
+        mgr.unhook_dx12();
+
+        if (g_initialized)
+        {
+            ImGui_ImplDX12_Shutdown();
+            ImGui_ImplWin32_Shutdown();
+            ImGui::DestroyContext();
+        }
+        release_dx12_resources();
+    }
+    return TRUE;
+}

examples/example_dx9_hook/CMakeLists.txt

@@ -0,0 +1,13 @@
+project(example_dx9_hook)
+
+add_library(${PROJECT_NAME} MODULE dllmain.cpp)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+    CXX_STANDARD 23
+    MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
+    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}")
+
+find_package(imgui CONFIG REQUIRED)
+target_link_libraries(${PROJECT_NAME} PRIVATE omath::omath imgui::imgui d3d9)

examples/example_dx9_hook/dllmain.cpp

@@ -0,0 +1,107 @@
+#include <Windows.h>
+#include <d3d9.h>
+#include <imgui.h>
+#include <imgui_impl_dx9.h>
+#include <imgui_impl_win32.h>
+
+#include "omath/hooks/hooks_manager.hpp"
+
+extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND, UINT, WPARAM, LPARAM);
+
+namespace
+{
+    bool g_initialized    = false;
+    bool g_init_attempted = false;
+
+    void init(IDirect3DDevice9* device)
+    {
+        g_init_attempted = true;
+
+        D3DDEVICE_CREATION_PARAMETERS params{};
+        if (FAILED(device->GetCreationParameters(&params)))
+            return;
+
+        ImGui::CreateContext();
+        ImGui::StyleColorsDark();
+        ImGui::GetIO().IniFilename = nullptr;
+        ImGui::GetIO().LogFilename = nullptr;
+        ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange;
+
+        ImGui_ImplWin32_Init(params.hFocusWindow);
+        ImGui_ImplDX9_Init(device);
+
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.set_on_wnd_proc([](HWND h, UINT msg, WPARAM wp, LPARAM lp) -> std::optional<LRESULT> {
+            if (ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp))
+                return 0;
+            return std::nullopt;
+        });
+        mgr.hook_wnd_proc(params.hFocusWindow);
+
+        g_initialized = true;
+    }
+
+    void on_present(IDirect3DDevice9* device, const RECT*, const RECT*, HWND, const RGNDATA*)
+    {
+        if (!g_initialized)
+        {
+            if (!g_init_attempted)
+                init(device);
+            return;
+        }
+
+        ImGui_ImplDX9_NewFrame();
+        ImGui_ImplWin32_NewFrame();
+        ImGui::NewFrame();
+
+        ImGui::SetNextWindowSize({300.f, 80.f}, ImGuiCond_Once);
+        ImGui::SetNextWindowPos({10.f, 10.f}, ImGuiCond_Once);
+        ImGui::Begin("omath | DX9 hook");
+        ImGui::Text("Hook active");
+        ImGui::Text("FPS: %.1f", ImGui::GetIO().Framerate);
+        ImGui::End();
+
+        ImGui::EndFrame();
+        ImGui::Render();
+        ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());
+    }
+
+    void on_reset(IDirect3DDevice9*, D3DPRESENT_PARAMETERS*)
+    {
+        if (g_initialized)
+            ImGui_ImplDX9_InvalidateDeviceObjects();
+    }
+} // namespace
+
+BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
+{
+    if (reason == DLL_PROCESS_ATTACH)
+    {
+        DisableThreadLibraryCalls(h_instance);
+        CreateThread(nullptr, 0, [](LPVOID) -> DWORD
+        {
+            while (!GetModuleHandle("d3d9.dll"))
+                Sleep(100);
+
+            auto& mgr = omath::hooks::HooksManager::get();
+            mgr.set_on_dx9_present(on_present);
+            mgr.set_on_dx9_reset(on_reset);
+            mgr.hook_dx9();
+            return 0;
+        }, nullptr, 0, nullptr);
+    }
+    else if (reason == DLL_PROCESS_DETACH)
+    {
+        auto& mgr = omath::hooks::HooksManager::get();
+        mgr.unhook_wnd_proc();
+        mgr.unhook_dx9();
+
+        if (g_initialized)
+        {
+            ImGui_ImplDX9_Shutdown();
+            ImGui_ImplWin32_Shutdown();
+            ImGui::DestroyContext();
+        }
+    }
+    return TRUE;
+}

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;

examples/example_hud/gui/main_window.cpp

@@ -138,6 +138,43 @@ namespace imgui_desktop::gui
             ImGui::SliderFloat("Thick##skel", &m_skel_thickness, 0.5f, 5.f);
         }
 
+        if (ImGui::CollapsingHeader("Progress Ring"))
+        {
+            ImGui::Checkbox("Show##ring", &m_show_ring);
+            ImGui::ColorEdit4("Color##ring", reinterpret_cast<float*>(&m_ring_color), ImGuiColorEditFlags_NoInputs);
+            ImGui::ColorEdit4("BG##ring", reinterpret_cast<float*>(&m_ring_bg), ImGuiColorEditFlags_NoInputs);
+            ImGui::SliderFloat("Radius##ring", &m_ring_radius, 4.f, 30.f);
+            ImGui::SliderFloat("Value##ring", &m_ring_ratio, 0.f, 1.f);
+            ImGui::SliderFloat("Thick##ring", &m_ring_thickness, 0.5f, 6.f);
+            ImGui::SliderFloat("Offset##ring", &m_ring_offset, 0.f, 15.f);
+        }
+
+        if (ImGui::CollapsingHeader("Scan Marker"))
+        {
+            ImGui::Checkbox("Show##scan", &m_show_scan);
+            ImGui::ColorEdit4("Fill##scan", reinterpret_cast<float*>(&m_scan_color), ImGuiColorEditFlags_NoInputs);
+            ImGui::ColorEdit4("Outline##scan", reinterpret_cast<float*>(&m_scan_outline), ImGuiColorEditFlags_NoInputs);
+            ImGui::SliderFloat("Thick##scan", &m_scan_outline_thickness, 0.5f, 5.f);
+        }
+
+        if (ImGui::CollapsingHeader("Aim Dot"))
+        {
+            ImGui::Checkbox("Show##aim", &m_show_aim);
+            ImGui::ColorEdit4("Color##aim", reinterpret_cast<float*>(&m_aim_color), ImGuiColorEditFlags_NoInputs);
+            ImGui::SliderFloat("Radius##aim", &m_aim_radius, 1.f, 10.f);
+        }
+
+        if (ImGui::CollapsingHeader("Projectile Aim"))
+        {
+            ImGui::Checkbox("Show##proj", &m_show_proj);
+            ImGui::ColorEdit4("Color##proj", reinterpret_cast<float*>(&m_proj_color), ImGuiColorEditFlags_NoInputs);
+            ImGui::SliderFloat("Size##proj", &m_proj_size, 1.f, 30.f);
+            ImGui::SliderFloat("Line width##proj", &m_proj_line_width, 0.5f, 5.f);
+            ImGui::SliderFloat("Pos X##proj", &m_proj_pos_x, 0.f, vp->Size.x);
+            ImGui::SliderFloat("Pos Y##proj", &m_proj_pos_y, 0.f, vp->Size.y);
+            ImGui::Combo("Figure##proj", &m_proj_figure, "Circle\0Square\0");
+        }
+
         if (ImGui::CollapsingHeader("Snap Line"))
         {
             ImGui::Checkbox("Show##snap", &m_show_snap);
@@ -166,7 +203,6 @@ namespace imgui_desktop::gui
                         when(m_show_cornered_box, CorneredBox{omath::Color::from_rgba(255, 0, 255, 255), m_box_fill,
                                                               m_corner_ratio, m_box_thickness}),
                         when(m_show_dashed_box, DashedBox{m_dash_color, m_dash_len, m_dash_gap, m_dash_thickness}),
-
                         RightSide{
                                 when(m_show_right_bar, bar),
                                 when(m_show_right_dashed_bar, dbar),
@@ -176,6 +212,10 @@ namespace imgui_desktop::gui
                                      Label{{1.f, 0.f, 0.f, 1.f}, m_label_offset, m_outlined, "Shield: 125/125"}),
                                 when(m_show_right_labels,
                                      Label{{1.f, 0.f, 1.f, 1.f}, m_label_offset, m_outlined, "*LOCKED*"}),
+
+                            SpaceVertical{10},
+                                when(m_show_ring, ProgressRing{m_ring_color, m_ring_bg, m_ring_radius, m_ring_ratio,
+                                                               m_ring_thickness, m_ring_offset}),
                         },
                         LeftSide{
                                 when(m_show_left_bar, bar),
@@ -203,7 +243,10 @@ namespace imgui_desktop::gui
                                 when(m_show_bottom_labels, Label{omath::Color::from_rgba(200, 200, 0, 255),
                                                                  m_label_offset, m_outlined, "42m"}),
                         },
+                        when(m_show_aim, AimDot{{m_entity_x, m_entity_top_y+40.f}, m_aim_color, m_aim_radius}),
+                        when(m_show_scan, ScanMarker{m_scan_color, m_scan_outline, m_scan_outline_thickness}),
                         when(m_show_skeleton, Skeleton{m_skel_color, m_skel_thickness}),
+                        when(m_show_proj, ProjectileAim{{m_proj_pos_x, m_proj_pos_y}, m_proj_color, m_proj_size, m_proj_line_width, static_cast<ProjectileAim::Figure>(m_proj_figure)}),
                         when(m_show_snap, SnapLine{{vp->Size.x / 2.f, vp->Size.y}, m_snap_color, m_snap_width}));
     }
 

examples/example_hud/gui/main_window.hpp

@@ -61,9 +61,34 @@ namespace imgui_desktop::gui
         float m_skel_thickness = 1.f;
         bool m_show_skeleton = false;
 
+        // Progress ring
+        omath::Color m_ring_color = omath::Color::from_rgba(0, 200, 255, 255);
+        omath::Color m_ring_bg{0.3f, 0.3f, 0.3f, 0.5f};
+        float m_ring_radius = 10.f, m_ring_ratio = 0.65f, m_ring_thickness = 2.5f, m_ring_offset = 5.f;
+        bool m_show_ring = false;
+
+        // Scan marker
+        omath::Color m_scan_color = omath::Color::from_rgba(255, 200, 0, 150);
+        omath::Color m_scan_outline = omath::Color::from_rgba(255, 200, 0, 255);
+        float m_scan_outline_thickness = 2.f;
+        bool m_show_scan = false;
+
+        // Aim dot
+        omath::Color m_aim_color = omath::Color::from_rgba(255, 0, 0, 255);
+        float m_aim_radius = 3.f;
+        bool m_show_aim = false;
+
         // Snap line
         omath::Color m_snap_color = omath::Color::from_rgba(255, 50, 50, 255);
         float m_snap_width = 1.5f;
         bool m_show_snap = true;
+
+        // Projectile aim
+        omath::Color m_proj_color = omath::Color::from_rgba(255, 50, 50, 255);
+        float m_proj_size = 10.f;
+        float m_proj_line_width = 1.5f;
+        float m_proj_pos_x = 300.f, m_proj_pos_y = 30.f;
+        int m_proj_figure = 1; // 0=circle, 1=square
+        bool m_show_proj = true;
     };
 } // namespace imgui_desktop::gui

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

@@ -0,0 +1,98 @@
+//
+// Created by Vladislav on 19.03.2026.
+//
+
+#pragma once
+#include "omath/linear_algebra/vector3.hpp"
+#include <functional>
+#include <iterator>
+#include <optional>
+#include <ranges>
+
+namespace omath::algorithm
+{
+    template<class CameraType, std::input_or_output_iterator IteratorType, class FilterT>
+    requires std::is_invocable_r_v<bool, std::function<FilterT>, std::iter_reference_t<IteratorType>>
+    [[nodiscard]]
+    IteratorType get_closest_target_by_fov(const IteratorType& begin, const IteratorType& end, const CameraType& camera,
+                                           auto get_position,
+                                           const std::optional<std::function<FilterT>>& filter_func = std::nullopt)
+    {
+        auto best_target = end;
+        const auto& camera_angles = camera.get_view_angles();
+        const Vector2<float> camera_angles_vec = {camera_angles.pitch.as_degrees(), camera_angles.yaw.as_degrees()};
+
+        for (auto current = begin; current != end; current = std::next(current))
+        {
+            if (filter_func && !filter_func.value()(*current))
+                continue;
+
+            if (best_target == end)
+            {
+                best_target = current;
+                continue;
+            }
+            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 auto current_target_distance = camera_angles_vec.distance_to(current_target_angles.as_vector3());
+            const auto best_target_distance = camera_angles.as_vector3().distance_to(best_target_angles.as_vector3());
+            if (current_target_distance < best_target_distance)
+                best_target = current;
+        }
+        return best_target;
+    }
+
+    template<class CameraType, std::ranges::range RangeType, class FilterT>
+    requires std::is_invocable_r_v<bool, std::function<FilterT>,
+                                   std::ranges::range_reference_t<const RangeType>>
+    [[nodiscard]]
+    auto get_closest_target_by_fov(const RangeType& range, const CameraType& camera,
+                                   auto get_position,
+                                   const std::optional<std::function<FilterT>>& filter_func = std::nullopt)
+    {
+        return get_closest_target_by_fov<CameraType, decltype(std::ranges::begin(range)), FilterT>(
+                std::ranges::begin(range), std::ranges::end(range), camera, get_position, filter_func);
+    }
+
+    // ── By world-space distance ───────────────────────────────────────────────
+
+    template<std::input_or_output_iterator IteratorType, class FilterT>
+    requires std::is_invocable_r_v<bool, std::function<FilterT>, std::iter_reference_t<IteratorType>>
+    [[nodiscard]]
+    IteratorType get_closest_target_by_distance(const IteratorType& begin, const IteratorType& end,
+                                                const Vector3<float>& origin, auto get_position,
+                                                const std::optional<std::function<FilterT>>& filter_func = std::nullopt)
+    {
+        auto best_target = end;
+
+        for (auto current = begin; current != end; current = std::next(current))
+        {
+            if (filter_func && !filter_func.value()(*current))
+                continue;
+
+            if (best_target == end)
+            {
+                best_target = current;
+                continue;
+            }
+
+            if (origin.distance_to(get_position(*current)) < origin.distance_to(get_position(*best_target)))
+                best_target = current;
+        }
+        return best_target;
+    }
+
+    template<std::ranges::range RangeType, class FilterT>
+    requires std::is_invocable_r_v<bool, std::function<FilterT>,
+                                   std::ranges::range_reference_t<const RangeType>>
+    [[nodiscard]]
+    auto get_closest_target_by_distance(const RangeType& range, const Vector3<float>& origin,
+                                        auto get_position,
+                                        const std::optional<std::function<FilterT>>& filter_func = std::nullopt)
+    {
+        return get_closest_target_by_distance<decltype(std::ranges::begin(range)), FilterT>(
+                std::ranges::begin(range), std::ranges::end(range), origin, get_position, filter_func);
+    }
+
+} // namespace omath::algorithm

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,11 +12,12 @@ 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
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;
@@ -25,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;
@@ -48,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,11 +12,12 @@ 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
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;
@@ -25,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;
@@ -48,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,11 +13,12 @@ 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
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;
@@ -26,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;
@@ -49,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,11 +12,12 @@ 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
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;
@@ -25,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;
@@ -48,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,11 +13,12 @@ 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
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;
@@ -26,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;
@@ -49,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,11 +12,12 @@ 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
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;
@@ -25,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;
@@ -48,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,66 +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
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
-                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
+            const auto fwd_d = forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
-                                                 RollAngle::from_degrees(0)})
+                                               RollAngle::from_degrees(0)});
+            auto current_pos = launch_pos
+                               + Vector3<double>{fwd_d.x, fwd_d.y, fwd_d.z}
                                          * 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/hooks/hooks_manager.hpp

@@ -0,0 +1,135 @@
+#pragma once
+
+#ifdef OMATH_ENABLE_HOOKING
+#include <functional>
+#include <optional>
+#include <shared_mutex>
+#include <cstdint>
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <Windows.h>
+#include <dxgi.h>
+#include <d3d9.h>
+#include <d3d12.h>
+#include <safetyhook.hpp>
+
+namespace omath::hooks
+{
+    class HooksManager final
+    {
+        HooksManager() = default;
+    public:
+        // IDXGISwapChain callbacks — shared between DX11 and DX12 (same interface, same signature).
+        using present_callback               = std::function<void(IDXGISwapChain*, UINT, UINT)>;
+        using resize_buffers_callback        = std::function<void(IDXGISwapChain*, UINT, UINT, UINT, DXGI_FORMAT, UINT)>;
+        using execute_command_lists_callback = std::function<void(ID3D12CommandQueue*, UINT, ID3D12CommandList* const*)>;
+
+        // IDirect3DDevice9 callbacks — DX9 only.
+        using dx9_present_callback   = std::function<void(IDirect3DDevice9*, const RECT*, const RECT*, HWND, const RGNDATA*)>;
+        using dx9_reset_callback     = std::function<void(IDirect3DDevice9*, D3DPRESENT_PARAMETERS*)>;
+        using dx9_end_scene_callback = std::function<void(IDirect3DDevice9*)>;
+
+        // Return nullopt to pass the message to the original WndProc; return a value to intercept it.
+        using wnd_proc_callback = std::function<std::optional<LRESULT>(HWND, UINT, WPARAM, LPARAM)>;
+
+        [[nodiscard]] static HooksManager& get();
+        HooksManager(const HooksManager&)            = delete;
+        HooksManager& operator=(const HooksManager&) = delete;
+        ~HooksManager();
+
+        [[nodiscard]] bool hook_dx9();
+        void unhook_dx9();
+        void set_on_dx9_present(dx9_present_callback callback);
+        void set_on_dx9_reset(dx9_reset_callback callback);
+        void set_on_dx9_end_scene(dx9_end_scene_callback callback);
+
+        [[nodiscard]] bool hook_dx11();
+        void unhook_dx11();
+
+        [[nodiscard]] bool hook_dx12();
+        void unhook_dx12();
+
+        // Present and ResizeBuffers callbacks fire for whichever of DX11/DX12 is hooked.
+        void set_on_present(present_callback callback);
+        void set_on_resize_buffers(resize_buffers_callback callback);
+        void set_on_execute_command_lists(execute_command_lists_callback callback);
+
+        [[nodiscard]] bool hook_wnd_proc(HWND hwnd);
+        void unhook_wnd_proc();
+        void set_on_wnd_proc(wnd_proc_callback callback);
+
+    private:
+        static HRESULT __stdcall dx9_present_detour(IDirect3DDevice9* p_device, const RECT* p_source_rect,
+                                                    const RECT* p_dest_rect, HWND h_dest_window_override,
+                                                    const RGNDATA* p_dirty_region);
+        static HRESULT __stdcall dx9_reset_detour(IDirect3DDevice9* p_device,
+                                                  D3DPRESENT_PARAMETERS* p_presentation_parameters);
+        static HRESULT __stdcall dx9_end_scene_detour(IDirect3DDevice9* p_device);
+
+        static HRESULT __stdcall dx11_present_detour(IDXGISwapChain* p_swap_chain, UINT sync_interval, UINT flags);
+        static HRESULT __stdcall dx11_resize_buffers_detour(IDXGISwapChain* p_swap_chain, UINT buffer_count,
+                                                            UINT width, UINT height, DXGI_FORMAT new_format,
+                                                            UINT swap_chain_flags);
+
+        static HRESULT __stdcall dx12_present_detour(IDXGISwapChain* p_swap_chain, UINT sync_interval, UINT flags);
+        static HRESULT __stdcall dx12_resize_buffers_detour(IDXGISwapChain* p_swap_chain, UINT buffer_count,
+                                                            UINT width, UINT height, DXGI_FORMAT new_format,
+                                                            UINT swap_chain_flags);
+        static void __stdcall dx12_execute_command_lists_detour(ID3D12CommandQueue* p_command_queue,
+                                                                UINT num_command_lists,
+                                                                ID3D12CommandList* const* pp_command_lists);
+
+        static LRESULT __stdcall wnd_proc_detour(HWND hwnd, UINT msg, WPARAM w_param, LPARAM l_param);
+
+        mutable std::shared_mutex m_mutex;
+
+        bool m_is_dx9_hooked      = false;
+        bool m_is_dx11_hooked     = false;
+        bool m_is_dx12_hooked     = false;
+        bool m_is_wnd_proc_hooked = false;
+
+        HWND    m_hooked_hwnd      = nullptr;
+        WNDPROC m_original_wndproc = nullptr;
+
+        safetyhook::InlineHook m_dx9_present_hook;
+        safetyhook::InlineHook m_dx9_reset_hook;
+        safetyhook::InlineHook m_dx9_end_scene_hook;
+
+        safetyhook::InlineHook m_dx11_present_hook;
+        safetyhook::InlineHook m_dx11_resize_buffers_hook;
+
+        safetyhook::InlineHook m_dx12_present_hook;
+        safetyhook::InlineHook m_dx12_resize_buffers_hook;
+        safetyhook::InlineHook m_dx12_execute_command_lists_hook;
+
+        dx9_present_callback   m_dx9_present_cb;
+        dx9_reset_callback     m_dx9_reset_cb;
+        dx9_end_scene_callback m_dx9_end_scene_cb;
+
+        present_callback               m_present_cb;
+        resize_buffers_callback        m_resize_buffers_cb;
+        execute_command_lists_callback m_execute_command_lists_cb;
+        wnd_proc_callback              m_wnd_proc_cb;
+    };
+}
+
+#else // !OMATH_ENABLE_HOOKING
+
+namespace omath::hooks
+{
+    class HooksManager final
+    {
+        HooksManager() = default;
+    public:
+        [[nodiscard]] static HooksManager& get();
+        HooksManager(const HooksManager&) = delete;
+        ~HooksManager();
+    };
+}
+
+#endif

include/omath/hud/entity_overlay.hpp

@@ -118,6 +118,36 @@ namespace omath::hud
                                              std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
         }
 
+        // ── Spacers ─────────────────────────────────────────────────────
+        EntityOverlay& add_right_space_vertical(float size);
+        EntityOverlay& add_right_space_horizontal(float size);
+        EntityOverlay& add_left_space_vertical(float size);
+        EntityOverlay& add_left_space_horizontal(float size);
+        EntityOverlay& add_top_space_vertical(float size);
+        EntityOverlay& add_top_space_horizontal(float size);
+        EntityOverlay& add_bottom_space_vertical(float size);
+        EntityOverlay& add_bottom_space_horizontal(float size);
+
+        // ── Progress rings ──────────────────────────────────────────────
+        EntityOverlay& add_right_progress_ring(const Color& color, const Color& bg, float radius, float ratio,
+                                               float thickness = 2.f, float offset = 5.f, int segments = 0);
+        EntityOverlay& add_left_progress_ring(const Color& color, const Color& bg, float radius, float ratio,
+                                              float thickness = 2.f, float offset = 5.f, int segments = 0);
+        EntityOverlay& add_top_progress_ring(const Color& color, const Color& bg, float radius, float ratio,
+                                             float thickness = 2.f, float offset = 5.f, int segments = 0);
+        EntityOverlay& add_bottom_progress_ring(const Color& color, const Color& bg, float radius, float ratio,
+                                                float thickness = 2.f, float offset = 5.f, int segments = 0);
+
+        // ── Icons ────────────────────────────────────────────────────────
+        EntityOverlay& add_right_icon(const std::any& texture_id, float width, float height,
+                                      const Color& tint = Color{1.f, 1.f, 1.f, 1.f}, float offset = 5.f);
+        EntityOverlay& add_left_icon(const std::any& texture_id, float width, float height,
+                                     const Color& tint = Color{1.f, 1.f, 1.f, 1.f}, float offset = 5.f);
+        EntityOverlay& add_top_icon(const std::any& texture_id, float width, float height,
+                                    const Color& tint = Color{1.f, 1.f, 1.f, 1.f}, float offset = 5.f);
+        EntityOverlay& add_bottom_icon(const std::any& texture_id, float width, float height,
+                                       const Color& tint = Color{1.f, 1.f, 1.f, 1.f}, float offset = 5.f);
+
         // ── Misc ─────────────────────────────────────────────────────────
         EntityOverlay& add_snap_line(const Vector2<float>& start_pos, const Color& color, float width);
 
@@ -151,6 +181,10 @@ namespace omath::hud
         void dispatch(const widget::BottomSide& bottom_side);
         void dispatch(const widget::Skeleton& skeleton);
         void dispatch(const widget::SnapLine& snap_line);
+        void dispatch(const widget::ScanMarker& scan_marker);
+        void dispatch(const widget::AimDot& aim_dot);
+        void dispatch(const widget::ProjectileAim& proj_widget);
+        void draw_progress_ring(const Vector2<float>& center, const widget::ProgressRing& ring);
         void draw_outlined_text(const Vector2<float>& position, const Color& color, const std::string_view& text);
         void draw_dashed_line(const Vector2<float>& from, const Vector2<float>& to, const Color& color, float dash_len,
                               float gap_len, float thickness) const;

include/omath/hud/entity_overlay_widgets.hpp

@@ -4,6 +4,7 @@
 #pragma once
 #include "omath/linear_algebra/vector2.hpp"
 #include "omath/utility/color.hpp"
+#include <any>
 #include <initializer_list>
 #include <optional>
 #include <string_view>
@@ -56,6 +57,35 @@ namespace omath::hud::widget
         float width;
     };
 
+    struct ScanMarker
+    {
+        Color color;
+        Color outline{0.f, 0.f, 0.f, 0.f};
+        float outline_thickness = 1.f;
+    };
+
+    /// Dot at an absolute screen position.
+    struct AimDot
+    {
+        Vector2<float> position;
+        Color color;
+        float radius = 3.f;
+    };
+    struct ProjectileAim
+    {
+        enum class Figure
+        {
+            CIRCLE,
+            SQUARE,
+        };
+        Vector2<float> position;
+        Color color;
+        float size = 3.f;
+        float line_size = 1.f;
+        Figure figure = Figure::SQUARE;
+    };
+
+
     // ── Side-agnostic widgets (used inside XxxSide containers) ────────────────
 
     /// A filled bar. `size` is width for left/right sides, height for top/bottom.
@@ -99,11 +129,44 @@ namespace omath::hud::widget
     template<typename W>
     Centered(W) -> Centered<W>;
 
+    /// Empty vertical gap that advances the Y cursor without drawing.
+    struct SpaceVertical
+    {
+        float size;
+    };
+
+    /// Empty horizontal gap that advances the X cursor without drawing.
+    struct SpaceHorizontal
+    {
+        float size;
+    };
+
+    struct ProgressRing
+    {
+        Color color;
+        Color bg{0.3f, 0.3f, 0.3f, 0.5f};
+        float radius = 12.f;
+        float ratio;
+        float thickness = 2.f;
+        float offset = 5.f;
+        int segments = 32;
+    };
+
+    struct Icon
+    {
+        std::any texture_id;
+        float width;
+        float height;
+        Color tint{1.f, 1.f, 1.f, 1.f};
+        float offset = 5.f;
+    };
+
     // ── Side widget variant ───────────────────────────────────────────────────
     struct None
     {
     }; ///< No-op placeholder — used by widget::when for disabled elements.
-    using SideWidget = std::variant<None, Bar, DashedBar, Label, Centered<Label>>;
+    using SideWidget =
+            std::variant<None, Bar, DashedBar, Label, Centered<Label>, SpaceVertical, SpaceHorizontal, ProgressRing, Icon>;
 
     // ── Side containers ───────────────────────────────────────────────────────
     // Storing std::initializer_list<SideWidget> is safe here: the backing array

include/omath/hud/hud_renderer_interface.hpp

@@ -4,6 +4,7 @@
 #pragma once
 #include "omath/linear_algebra/vector2.hpp"
 #include "omath/utility/color.hpp"
+#include <any>
 #include <span>
 
 namespace omath::hud
@@ -24,6 +25,20 @@ namespace omath::hud
 
         virtual void add_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) = 0;
 
+        virtual void add_circle(const Vector2<float>& center, float radius, const Color& color, float thickness,
+                                int segments = 0) = 0;
+
+        virtual void add_filled_circle(const Vector2<float>& center, float radius, const Color& color,
+                                       int segments = 0) = 0;
+
+        /// Draw an arc (partial circle outline). Angles in radians, 0 = right (+X), counter-clockwise.
+        virtual void add_arc(const Vector2<float>& center, float radius, float a_min, float a_max, const Color& color,
+                             float thickness, int segments = 0) = 0;
+
+        /// Draw a textured quad. texture_id is renderer-specific (e.g. ImTextureID for ImGui).
+        virtual void add_image(const std::any& texture_id, const Vector2<float>& min, const Vector2<float>& max,
+                               const Color& tint = Color{1.f, 1.f, 1.f, 1.f}) = 0;
+
         virtual void add_text(const Vector2<float>& position, const Color& color, const std::string_view& text) = 0;
 
         [[nodiscard]]

include/omath/hud/renderer_realizations/imgui_renderer.hpp

@@ -17,6 +17,14 @@ namespace omath::hud
         void add_filled_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color) override;
         void add_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) override;
         void add_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) override;
+        void add_circle(const Vector2<float>& center, float radius, const Color& color, float thickness,
+                        int segments = 0) override;
+        void add_filled_circle(const Vector2<float>& center, float radius, const Color& color,
+                               int segments = 0) override;
+        void add_arc(const Vector2<float>& center, float radius, float a_min, float a_max, const Color& color,
+                     float thickness, int segments = 0) override;
+        void add_image(const std::any& texture_id, const Vector2<float>& min, const Vector2<float>& max,
+                       const Color& tint = Color{1.f, 1.f, 1.f, 1.f}) override;
         void add_text(const Vector2<float>& position, const Color& color, const std::string_view& text) override;
         [[nodiscard]]
         virtual Vector2<float> calc_text_size(const std::string_view& text) override;

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,56 +664,151 @@ 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
     {
-        return
+        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)},
+                { static_cast<Type>(2) / (right - left), 0.f,       0.f,    -(right + left) / (right - left)},
-            { 0.f,      0.f,       static_cast<Type>(2) / (far - near), -(far + near) / (far - near)    },
+                { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,    -(top + bottom) / (top - bottom)},
-            { 0.f,      0.f,       0.f,                                 1.f                             }
+                { 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)},
+                { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,    -(top + bottom) / (top - bottom)},
+                { 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
     {
-        return
+        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)},
+                    { static_cast<Type>(2) / (right - left), 0.f,       0.f,     -(right + left) / (right - left)},
-                { 0.f,      0.f,       -static_cast<Type>(2) / (far - near), -(far + near) / (far - near)    },
+                    { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,     -(top + bottom) / (top - bottom)},
-                { 0.f,      0.f,       0.f,                                  1.f                             }
+                    { 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)},
+                    { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,     -(top + bottom) / (top - bottom)},
+                    { 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,12 +8,25 @@
 
 namespace omath::projectile_prediction
 {
+    template<class ArithmeticType = float>
+    struct AimAngles
+    {
+        ArithmeticType pitch{};
+        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<ArithmeticType>> maybe_calculate_aim_angles(
+            const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target) const = 0;
+
         virtual ~ProjPredEngineInterface() = default;
     };
 } // namespace omath::projectile_prediction

include/omath/projectile_prediction/proj_pred_engine_avx2.hpp

@@ -6,11 +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<float>>
+        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;
@@ -18,7 +21,7 @@ namespace omath::projectile_prediction
     private:
         [[nodiscard]] static std::optional<float> calculate_pitch(const Vector3<float>& proj_origin,
                                                                   const Vector3<float>& target_pos,
-                                                                  float bullet_gravity, float v0, float time) ;
+                                                                  float bullet_gravity, float v0, float time);
 
         // We use [[maybe_unused]] here since AVX2 is not available for ARM and ARM64 CPU
         [[maybe_unused]] const float m_gravity_constant;

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,23 +38,59 @@ 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
         {
-            for (float time = 0.f; time < m_maximum_simulation_time; time += m_simulation_time_step)
+            const auto solution = find_solution(projectile, target);
+            if (!solution)
+                return std::nullopt;
+
+            return EngineTrait::calc_viewpoint_from_angles(projectile, solution->predicted_target_position,
+                                                           solution->pitch);
+        }
+
+        [[nodiscard]]
+        std::optional<AimAngles<ArithmeticType>> maybe_calculate_aim_angles(
+            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);
+            return AimAngles<ArithmeticType>{solution->pitch, yaw};
+        }
+
+    private:
+        struct Solution
+        {
+            Vector3<ArithmeticType> predicted_target_position;
+            ArithmeticType pitch;
+        };
+
+        [[nodiscard]]
+        std::optional<Solution> find_solution(const Projectile<ArithmeticType>& projectile,
+                                              const Target<ArithmeticType>& target) const
+        {
+            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);
@@ -70,16 +105,15 @@ namespace omath::projectile_prediction
                                                   time))
                     continue;
 
-                return EngineTrait::calc_viewpoint_from_angles(projectile, predicted_target_position, projectile_pitch);
+                return Solution{predicted_target_position, projectile_pitch.value()};
             }
             return std::nullopt;
         }
 
-    private:
+        const ArithmeticType m_gravity_constant;
-        const float m_gravity_constant;
+        const ArithmeticType m_simulation_time_step;
-        const float m_simulation_time_step;
+        const ArithmeticType m_maximum_simulation_time;
-        const float m_maximum_simulation_time;
+        const ArithmeticType m_distance_tolerance;
-        const float 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
@@ -94,39 +128,45 @@ 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;
 
-            if (bullet_gravity == 0.f)
+            const auto launch_origin = projectile.m_origin + projectile.m_launch_offset;
-                return EngineTrait::calc_direct_pitch_angle(projectile.m_origin, target_position);
 
-            const auto delta = target_position - projectile.m_origin;
+            if (bullet_gravity == ArithmeticType{0})
+                return EngineTrait::calc_direct_pitch_angle(launch_origin, target_position);
+
+            const auto delta = target_position - launch_origin;
 
             const auto distance2d = EngineTrait::calc_vector_2d_distance(delta);
             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
-                                   * (bullet_gravity * distance2d_sqr
+                                            * (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, 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,11 +7,13 @@
 
 namespace omath::projectile_prediction
 {
+    template <class ArithmeticType = float>
     class Projectile final
     {
     public:
-        Vector3<float> m_origin;
+        Vector3<ArithmeticType> m_origin;
-        float m_launch_speed{};
+        Vector3<ArithmeticType> m_launch_offset{};
-        float m_gravity_scale{};
+        ArithmeticType m_launch_speed{};
+        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
+} // 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"
@@ -36,24 +37,37 @@ namespace omath::projection
         }
     };
     using FieldOfView = Angle<float, 0.f, 180.f, AngleFlags::Clamped>;
+    enum class ViewPortClipping
+    {
+        AUTO,
+        MANUAL,
+    };
+    struct CameraAxes
+    {
+        bool inverted_forward = false;
+        bool inverted_right = false;
+    };
 
-    template<class T, class MatType, class ViewAnglesType>
+    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
@@ -69,43 +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<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
         {
@@ -125,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();
         }
@@ -138,16 +219,16 @@ namespace omath::projection
             m_projection_matrix = std::nullopt;
         }
 
-        void set_near_plane(const float near) noexcept
+        void set_near_plane(const NumericType near_plane) noexcept
         {
-            m_near_plane_distance = near;
+            m_near_plane_distance = near_plane;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
 
-        void set_far_plane(const float far) noexcept
+        void set_far_plane(const NumericType far_plane) noexcept
         {
-            m_far_plane_distance = far;
+            m_far_plane_distance = far_plane;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
@@ -159,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;
@@ -177,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;
         }
@@ -192,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);
 
@@ -213,15 +294,31 @@ namespace omath::projection
             else
                 std::unreachable();
         }
+        template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
+        [[nodiscard]] std::expected<Vector3<NumericType>, Error>
+        world_to_screen_unclipped(const Vector3<NumericType>& world_position) const noexcept
+        {
+            const auto normalized_cords = world_to_view_port(world_position, ViewPortClipping::MANUAL);
 
-        [[nodiscard]] bool is_culled_by_frustum(const Triangle<Vector3<float>>& triangle) const noexcept
+            if (!normalized_cords.has_value())
+                return std::unexpected{normalized_cords.error()};
+
+            if constexpr (screen_start == ScreenStart::TOP_LEFT_CORNER)
+                return ndc_to_screen_position_from_top_left_corner(*normalized_cords);
+            else if constexpr (screen_start == ScreenStart::BOTTOM_LEFT_CORNER)
+                return ndc_to_screen_position_from_bottom_left_corner(*normalized_cords);
+            else
+                std::unreachable();
+        }
+
+        [[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
@@ -234,52 +331,141 @@ 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 noexcept
+        {
+            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);
-            if (w <= std::numeric_limits<float>::epsilon())
+            constexpr auto eps = std::numeric_limits<NumericType>::epsilon();
-                return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
+            if (w <= eps)
+                return std::unexpected(Error::PERSPECTIVE_DIVIDER_LESS_EQ_ZERO);
 
             projected /= w;
 
-            if (is_ndc_out_of_bounds(projected))
+            // ReSharper disable once CppTooWideScope
+            const auto clipped_automatically = clipping == ViewPortClipping::AUTO && is_ndc_out_of_bounds(projected);
+            if (clipped_automatically)
                 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)};
+            // ReSharper disable once CppTooWideScope
+            constexpr auto z_min = depth_range == NDCDepthRange::ZERO_TO_ONE ? NumericType{0} : -NumericType{1};
+            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<NumericType>{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)};
         }
         [[nodiscard]]
-        std::expected<Vector3<float>, Error> view_port_to_screen(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();
 
@@ -287,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)};
+                                        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_screen(screen_to_ndc<screen_start>(screen_pos));
+            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:
@@ -351,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
         {
             /*
             +------------------------>
@@ -365,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
         {
             /*
              ^
@@ -382,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/projection/error_codes.hpp

@@ -11,5 +11,6 @@ namespace omath::projection
     {
         WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS,
         INV_VIEW_PROJ_MAT_DET_EQ_ZERO,
+        PERSPECTIVE_DIVIDER_LESS_EQ_ZERO,
     };
 }

include/omath/rev_eng/internal_rev_object.hpp

@@ -3,11 +3,43 @@
 //
 
 #pragma once
+#include <cassert>
 #include <cstddef>
 #include <cstdint>
+#include <string_view>
+
+#ifdef _WIN32
+#include "omath/utility/pe_pattern_scan.hpp"
+#include <windows.h>
+#elif defined(__APPLE__)
+#include "omath/utility/macho_pattern_scan.hpp"
+#include <mach-o/dyld.h>
+#else
+#include "omath/utility/elf_pattern_scan.hpp"
+#include <link.h>
+#endif
 
 namespace omath::rev_eng
 {
+    template<std::size_t N>
+    struct FixedString final
+    {
+        char data[N]{};
+        // ReSharper disable once CppNonExplicitConvertingConstructor
+        constexpr FixedString(const char (&str)[N]) noexcept // NOLINT(*-explicit-constructor)
+        {
+            for (std::size_t i = 0; i < N; ++i)
+                data[i] = str[i];
+        }
+        // ReSharper disable once CppNonExplicitConversionOperator
+        constexpr operator std::string_view() const noexcept // NOLINT(*-explicit-constructor)
+        {
+            return {data, N - 1};
+        }
+    };
+    template<std::size_t N>
+    FixedString(const char (&)[N]) -> FixedString<N>;
+
     class InternalReverseEngineeredObject
     {
     protected:
@@ -23,26 +55,150 @@ namespace omath::rev_eng
             return *reinterpret_cast<Type*>(reinterpret_cast<std::uintptr_t>(this) + offset);
         }
 
-        template<std::size_t id, class ReturnType>
+        template<class ReturnType>
+        ReturnType call_method(const void* ptr, auto... arg_list)
+        {
+#ifdef _MSC_VER
+            using MethodType = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
+#else
+            using MethodType = ReturnType (*)(void*, decltype(arg_list)...);
+#endif
+            return reinterpret_cast<MethodType>(const_cast<void*>(ptr))(this, arg_list...);
+        }
+        template<class ReturnType>
+        ReturnType call_method(const void* ptr, auto... arg_list) const
+        {
+#ifdef _MSC_VER
+            using MethodType = ReturnType(__thiscall*)(const void*, decltype(arg_list)...);
+#else
+            using MethodType = ReturnType (*)(const void*, decltype(arg_list)...);
+#endif
+            return reinterpret_cast<MethodType>(const_cast<void*>(ptr))(this, arg_list...);
+        }
+
+        template<FixedString ModuleName, FixedString Pattern, class ReturnType>
+        ReturnType call_method(auto... arg_list)
+        {
+            static const auto* address = resolve_pattern(ModuleName, Pattern);
+            return call_method<ReturnType>(address, arg_list...);
+        }
+
+        template<FixedString ModuleName, FixedString Pattern, class ReturnType>
+        ReturnType call_method(auto... arg_list) const
+        {
+            static const auto* address = resolve_pattern(ModuleName, Pattern);
+            return call_method<ReturnType>(address, arg_list...);
+        }
+
+        template<class ReturnType>
+        ReturnType call_method(const std::string_view& module_name,const std::string_view& pattern, auto... arg_list)
+        {
+            static const auto* address = resolve_pattern(module_name, pattern);
+            return call_method<ReturnType>(address, arg_list...);
+        }
+
+        template<class ReturnType>
+        ReturnType call_method(const std::string_view& module_name,const std::string_view& pattern, auto... arg_list) const
+        {
+            static const auto* address = resolve_pattern(module_name, pattern);
+            return call_method<ReturnType>(address, arg_list...);
+        }
+        template<std::size_t Id, class ReturnType>
         ReturnType call_virtual_method(auto... arg_list)
         {
-#ifdef _MSC_VER
+            const auto vtable = *reinterpret_cast<void***>(this);
-            using VirtualMethodType = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
+            return call_method<ReturnType>(vtable[Id], arg_list...);
-#else
-            using VirtualMethodType = ReturnType (*)(void*, decltype(arg_list)...);
-#endif
-            return (*reinterpret_cast<VirtualMethodType**>(this))[id](this, arg_list...);
         }
-        template<std::size_t id, class ReturnType>
+        template<std::size_t Id, class ReturnType>
         ReturnType call_virtual_method(auto... arg_list) const
         {
+            const auto vtable = *reinterpret_cast<void* const* const*>(this);
+            return call_method<ReturnType>(vtable[Id], arg_list...);
+        }
+
+        template<std::ptrdiff_t TableOffset, std::size_t Id, class ReturnType>
+        ReturnType call_virtual_method(auto... arg_list)
+        {
+            auto sub_this = reinterpret_cast<void*>(
+                reinterpret_cast<std::uintptr_t>(this) + TableOffset);
+            const auto vtable = *reinterpret_cast<void***>(sub_this);
 #ifdef _MSC_VER
-            using VirtualMethodType = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
+            using Fn = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
 #else
-            using VirtualMethodType = ReturnType (*)(void*, decltype(arg_list)...);
+            using Fn = ReturnType(*)(void*, decltype(arg_list)...);
+#endif
+            return reinterpret_cast<Fn>(vtable[Id])(sub_this, arg_list...);
+        }
+        template<std::ptrdiff_t TableOffset, std::size_t Id, class ReturnType>
+        ReturnType call_virtual_method(auto... arg_list) const
+        {
+            auto sub_this = reinterpret_cast<const void*>(
+                reinterpret_cast<std::uintptr_t>(this) + TableOffset);
+            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:
+        [[nodiscard]]
+        static const void* resolve_pattern(const std::string_view module_name, const std::string_view pattern)
+        {
+            const auto* base = get_module_base(module_name);
+            assert(base && "Failed to find module");
+
+#ifdef _WIN32
+            const auto result = PePatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+#elif defined(__APPLE__)
+            const auto result = MachOPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+#else
+            const auto result = ElfPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+#endif
+            assert(result.has_value() && "Pattern scan failed");
+            return reinterpret_cast<const void*>(*result);
+        }
+
+        [[nodiscard]]
+        static const void* get_module_base(const std::string_view module_name)
+        {
+#ifdef _WIN32
+            return GetModuleHandleA(module_name.data());
+#elif defined(__APPLE__)
+            // On macOS, iterate loaded images to find the module by name
+            const auto count = _dyld_image_count();
+            for (std::uint32_t i = 0; i < count; ++i)
+            {
+                const auto* name = _dyld_get_image_name(i);
+                if (name && std::string_view{name}.find(module_name) != std::string_view::npos)
+                    return static_cast<const void*>(_dyld_get_image_header(i));
+            }
+            return nullptr;
+#else
+            // On Linux, use dl_iterate_phdr to find loaded module by name
+            struct CallbackData
+            {
+                std::string_view name;
+                const void* base;
+            } cb_data{module_name, nullptr};
+
+            dl_iterate_phdr(
+                    [](dl_phdr_info* info, std::size_t, void* data) -> int
+                    {
+                        auto* cb = static_cast<CallbackData*>(data);
+                        if (info->dlpi_name
+                            && std::string_view{info->dlpi_name}.find(cb->name) != std::string_view::npos)
+                        {
+                            cb->base = reinterpret_cast<const void*>(info->dlpi_addr);
+                            return 1;
+                        }
+                        return 0;
+                    },
+                    &cb_data);
+            return cb_data.base;
 #endif
-            return (*static_cast<VirtualMethodType**>((void*)(this)))[id](
-                    const_cast<void*>(static_cast<const void*>(this)), arg_list...);
         }
     };
 } // namespace omath::rev_eng

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/coverage-llvm.sh

@@ -16,15 +16,42 @@ echo "[*] Output dir: ${OUTPUT_DIR}"
 # Find llvm tools - handle versioned names (Linux) and xcrun (macOS)
 find_llvm_tool() {
     local tool_name="$1"
-    
+
-    # macOS: use xcrun
+    # First priority: derive from the actual compiler used by cmake (CMakeCache.txt).
+    # This guarantees the profraw format version matches the instrumented binary.
+    local cache_file="${BINARY_DIR}/CMakeCache.txt"
+    if [[ -f "$cache_file" ]]; then
+        local cmake_cxx
+        cmake_cxx=$(grep '^CMAKE_CXX_COMPILER:' "$cache_file" | cut -d= -f2)
+        if [[ -n "$cmake_cxx" && -x "$cmake_cxx" ]]; then
+            local tool_path
+            tool_path="$(dirname "$cmake_cxx")/${tool_name}"
+            if [[ -x "$tool_path" ]]; then
+                echo "$tool_path"
+                return 0
+            fi
+        fi
+    fi
+
+    # macOS: derive from xcrun clang as fallback
     if [[ "$(uname)" == "Darwin" ]]; then
+        local clang_path
+        clang_path=$(xcrun --find clang 2>/dev/null)
+        if [[ -n "$clang_path" ]]; then
+            local tool_path
+            tool_path="$(dirname "$clang_path")/${tool_name}"
+            if [[ -x "$tool_path" ]]; then
+                echo "$tool_path"
+                return 0
+            fi
+        fi
+        # Fallback: xcrun
         if xcrun --find "${tool_name}" &>/dev/null; then
             echo "xcrun ${tool_name}"
             return 0
         fi
     fi
-    
+
     # Try versioned names (Linux with LLVM 21, 20, 19, etc.)
     for version in 21 20 19 18 17 ""; do
         local versioned_name="${tool_name}${version:+-$version}"
@@ -33,7 +60,7 @@ find_llvm_tool() {
             return 0
         fi
     done
-    
+
     echo ""
     return 1
 }
@@ -51,6 +78,18 @@ fi
 echo "[*] Using: ${LLVM_PROFDATA}"
 echo "[*] Using: ${LLVM_COV}"
 
+# Print version info for debugging version mismatches
+if [[ "$(uname)" == "Darwin" ]]; then
+    echo "[*] Default clang: $(xcrun clang --version 2>&1 | head -1)"
+    # Show actual compiler used by the build (from CMakeCache.txt if available)
+    CACHE_FILE="${BINARY_DIR}/CMakeCache.txt"
+    if [[ -f "$CACHE_FILE" ]]; then
+        ACTUAL_CXX=$(grep '^CMAKE_CXX_COMPILER:' "$CACHE_FILE" | cut -d= -f2)
+        echo "[*] Build compiler: ${ACTUAL_CXX} ($(${ACTUAL_CXX} --version 2>&1 | head -1))"
+    fi
+    echo "[*] profdata: $(${LLVM_PROFDATA} show --version 2>&1 | head -1 || true)"
+fi
+
 # Find test binary
 if [[ -z "${TEST_BINARY}" ]]; then
     for path in \

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,24 @@ 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 auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, 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},
+                    vertical_fov, 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>(
-        };
+                    vertical_fov, 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)};
     }
@@ -28,7 +28,7 @@ namespace omath::opengl_engine
     }
     Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
     {
-        return mat_look_at_right_handed(cam_origin, cam_origin+forward_vector(angles), up_vector(angles));
+        return mat_look_at_right_handed(cam_origin, cam_origin + forward_vector(angles), up_vector(angles));
     }
     Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
     {
@@ -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,24 @@ 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 auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, 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},
+                    vertical_fov, 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>(
-        };
+                    vertical_fov, 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/hooks/hooks_manager.cpp

@@ -0,0 +1,588 @@
+#include "omath/hooks/hooks_manager.hpp"
+
+#ifdef OMATH_ENABLE_HOOKING
+#include <d3d11.h>
+
+namespace
+{
+    class DummyWindow final
+    {
+        WNDCLASSEX m_window_class{};
+        HWND m_window_handle = nullptr;
+
+    public:
+        DummyWindow()
+        {
+            m_window_class.cbSize        = sizeof(WNDCLASSEX);
+            m_window_class.style         = CS_HREDRAW | CS_VREDRAW;
+            m_window_class.lpfnWndProc   = DefWindowProc;
+            m_window_class.hInstance     = GetModuleHandle(nullptr);
+            m_window_class.lpszClassName = "OM";
+            RegisterClassEx(&m_window_class);
+            m_window_handle = CreateWindow(m_window_class.lpszClassName, "Dummy", WS_OVERLAPPEDWINDOW,
+                                           0, 0, 100, 100, nullptr, nullptr, m_window_class.hInstance, nullptr);
+        }
+        ~DummyWindow()
+        {
+            if (m_window_handle)
+                DestroyWindow(m_window_handle);
+            UnregisterClass(m_window_class.lpszClassName, m_window_class.hInstance);
+        }
+        [[nodiscard]] HWND handle() const { return m_window_handle; }
+        [[nodiscard]] bool valid()  const { return m_window_handle != nullptr; }
+    };
+
+    void* vtable_fn(void* com_obj, std::size_t index)
+    {
+        return (*reinterpret_cast<void***>(com_obj))[index];
+    }
+
+    struct dx12_vtable_fns
+    {
+        void* present;
+        void* resize_buffers;
+        void* execute_command_lists;
+    };
+
+    // RAII wrapper so all early-return paths release COM objects automatically.
+    struct dx12_com_objects
+    {
+        IDXGIFactory*              factory           = nullptr;
+        ID3D12Device*              device            = nullptr;
+        ID3D12CommandQueue*        command_queue     = nullptr;
+        ID3D12CommandAllocator*    command_allocator = nullptr;
+        ID3D12GraphicsCommandList* command_list      = nullptr;
+        IDXGISwapChain*            swap_chain        = nullptr;
+
+        dx12_com_objects() = default;
+        dx12_com_objects(const dx12_com_objects&)            = delete;
+        dx12_com_objects& operator=(const dx12_com_objects&) = delete;
+
+        ~dx12_com_objects()
+        {
+            if (swap_chain)        swap_chain->Release();
+            if (command_list)      command_list->Release();
+            if (command_allocator) command_allocator->Release();
+            if (command_queue)     command_queue->Release();
+            if (device)            device->Release();
+            if (factory)           factory->Release();
+        }
+    };
+
+    std::optional<dx12_vtable_fns> read_dx12_vtable_fns(HWND hwnd)
+    {
+        using create_dxgi_factory_fn = HRESULT(__stdcall*)(REFIID, void**);
+        using d3d12_create_device_fn = HRESULT(__stdcall*)(IUnknown*, D3D_FEATURE_LEVEL, REFIID, void**);
+
+        const HMODULE d3d12_module = GetModuleHandle("d3d12.dll");
+        const HMODULE dxgi_module  = GetModuleHandle("dxgi.dll");
+        if (!d3d12_module || !dxgi_module)
+            return std::nullopt;
+
+        const auto create_dxgi_factory = reinterpret_cast<create_dxgi_factory_fn>(
+            GetProcAddress(dxgi_module, "CreateDXGIFactory"));
+        const auto d3d12_create_device = reinterpret_cast<d3d12_create_device_fn>(
+            GetProcAddress(d3d12_module, "D3D12CreateDevice"));
+
+        if (!create_dxgi_factory || !d3d12_create_device)
+            return std::nullopt;
+
+        dx12_com_objects objs;
+
+        if (FAILED(create_dxgi_factory(__uuidof(IDXGIFactory), reinterpret_cast<void**>(&objs.factory))))
+            return std::nullopt;
+
+        IDXGIAdapter* adapter = nullptr;
+        if (objs.factory->EnumAdapters(0, &adapter) == DXGI_ERROR_NOT_FOUND)
+            return std::nullopt;
+
+        const HRESULT device_hr = d3d12_create_device(adapter, D3D_FEATURE_LEVEL_11_0,
+                                                       __uuidof(ID3D12Device),
+                                                       reinterpret_cast<void**>(&objs.device));
+        adapter->Release();
+        if (FAILED(device_hr))
+            return std::nullopt;
+
+        D3D12_COMMAND_QUEUE_DESC queue_desc{};
+        queue_desc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
+
+        if (FAILED(objs.device->CreateCommandQueue(&queue_desc, __uuidof(ID3D12CommandQueue),
+                                                   reinterpret_cast<void**>(&objs.command_queue))))
+            return std::nullopt;
+
+        if (FAILED(objs.device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
+                                                        __uuidof(ID3D12CommandAllocator),
+                                                        reinterpret_cast<void**>(&objs.command_allocator))))
+            return std::nullopt;
+
+        if (FAILED(objs.device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, objs.command_allocator,
+                                                   nullptr, __uuidof(ID3D12GraphicsCommandList),
+                                                   reinterpret_cast<void**>(&objs.command_list))))
+            return std::nullopt;
+
+        DXGI_SWAP_CHAIN_DESC swap_chain_desc{};
+        swap_chain_desc.BufferDesc.Width       = 100;
+        swap_chain_desc.BufferDesc.Height      = 100;
+        swap_chain_desc.BufferDesc.RefreshRate = {60, 1};
+        swap_chain_desc.BufferDesc.Format      = DXGI_FORMAT_R8G8B8A8_UNORM;
+        swap_chain_desc.SampleDesc             = {1, 0};
+        swap_chain_desc.BufferUsage            = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+        swap_chain_desc.BufferCount            = 2;
+        swap_chain_desc.OutputWindow           = hwnd;
+        swap_chain_desc.Windowed               = TRUE;
+        swap_chain_desc.SwapEffect             = DXGI_SWAP_EFFECT_FLIP_DISCARD;
+        swap_chain_desc.Flags                  = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
+
+        if (FAILED(objs.factory->CreateSwapChain(objs.command_queue, &swap_chain_desc, &objs.swap_chain)))
+            return std::nullopt;
+
+        // objs destructor releases all COM objects after we capture the addresses.
+        return dx12_vtable_fns{
+            vtable_fn(objs.swap_chain, 8),    // IDXGISwapChain::Present
+            vtable_fn(objs.swap_chain, 13),   // IDXGISwapChain::ResizeBuffers
+            vtable_fn(objs.command_queue, 10), // ID3D12CommandQueue::ExecuteCommandLists
+        };
+    }
+} // namespace
+
+namespace omath::hooks
+{
+    HooksManager& HooksManager::get()
+    {
+        static HooksManager obj;
+        return obj;
+    }
+
+    HooksManager::~HooksManager()
+    {
+        unhook_wnd_proc();
+        unhook_dx9();
+        unhook_dx11();
+        unhook_dx12();
+    }
+
+    bool HooksManager::hook_dx9()
+    {
+        std::unique_lock lock(m_mutex);
+        if (m_is_dx9_hooked)
+            return true;
+
+        const DummyWindow window;
+        if (!window.valid())
+            return false;
+
+        const HMODULE d3d9_module = GetModuleHandle("d3d9.dll");
+        if (!d3d9_module)
+            return false;
+
+        using direct3d_create9_fn = IDirect3D9*(__stdcall*)(UINT);
+        const auto direct3d_create9 = reinterpret_cast<direct3d_create9_fn>(
+            GetProcAddress(d3d9_module, "Direct3DCreate9"));
+        if (!direct3d_create9)
+            return false;
+
+        IDirect3D9* d3d9 = direct3d_create9(D3D_SDK_VERSION);
+        if (!d3d9)
+            return false;
+
+        D3DPRESENT_PARAMETERS pp{};
+        pp.SwapEffect    = D3DSWAPEFFECT_DISCARD;
+        pp.hDeviceWindow = window.handle();
+        pp.Windowed      = TRUE;
+
+        IDirect3DDevice9* device = nullptr;
+        if (FAILED(d3d9->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window.handle(),
+                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING, &pp, &device)))
+        {
+            d3d9->Release();
+            return false;
+        }
+
+        // IDirect3DDevice9 vtable indices (from IUnknown base):
+        //   Reset    = 16
+        //   Present  = 17
+        //   EndScene = 42
+        m_dx9_present_hook = safetyhook::create_inline(
+            vtable_fn(device, 17),
+            reinterpret_cast<void*>(&dx9_present_detour));
+
+        m_dx9_reset_hook = safetyhook::create_inline(
+            vtable_fn(device, 16),
+            reinterpret_cast<void*>(&dx9_reset_detour));
+
+        m_dx9_end_scene_hook = safetyhook::create_inline(
+            vtable_fn(device, 42),
+            reinterpret_cast<void*>(&dx9_end_scene_detour));
+
+        device->Release();
+        d3d9->Release();
+
+        if (!m_dx9_present_hook || !m_dx9_reset_hook || !m_dx9_end_scene_hook)
+        {
+            m_dx9_present_hook   = {};
+            m_dx9_reset_hook     = {};
+            m_dx9_end_scene_hook = {};
+            return false;
+        }
+
+        m_is_dx9_hooked = true;
+        return true;
+    }
+
+    void HooksManager::unhook_dx9()
+    {
+        std::unique_lock lock(m_mutex);
+        m_dx9_present_hook   = {};
+        m_dx9_reset_hook     = {};
+        m_dx9_end_scene_hook = {};
+        m_is_dx9_hooked = false;
+    }
+
+    void HooksManager::set_on_dx9_present(dx9_present_callback callback)
+    {
+        std::unique_lock lock(m_mutex);
+        m_dx9_present_cb = std::move(callback);
+    }
+
+    void HooksManager::set_on_dx9_reset(dx9_reset_callback callback)
+    {
+        std::unique_lock lock(m_mutex);
+        m_dx9_reset_cb = std::move(callback);
+    }
+
+    void HooksManager::set_on_dx9_end_scene(dx9_end_scene_callback callback)
+    {
+        std::unique_lock lock(m_mutex);
+        m_dx9_end_scene_cb = std::move(callback);
+    }
+
+    bool HooksManager::hook_dx11()
+    {
+        std::unique_lock lock(m_mutex);
+        if (m_is_dx11_hooked)
+            return true;
+
+        const DummyWindow window;
+        if (!window.valid())
+            return false;
+
+        const HMODULE d3d11_module = GetModuleHandle("d3d11.dll");
+        if (!d3d11_module)
+            return false;
+
+        using d3d11_create_device_and_swap_chain_fn =
+            HRESULT(__stdcall*)(IDXGIAdapter*, D3D_DRIVER_TYPE, HMODULE, UINT,
+                                const D3D_FEATURE_LEVEL*, UINT, UINT,
+                                const DXGI_SWAP_CHAIN_DESC*, IDXGISwapChain**,
+                                ID3D11Device**, D3D_FEATURE_LEVEL*, ID3D11DeviceContext**);
+
+        const auto create_device_and_swap_chain = reinterpret_cast<d3d11_create_device_and_swap_chain_fn>(
+            GetProcAddress(d3d11_module, "D3D11CreateDeviceAndSwapChain"));
+        if (!create_device_and_swap_chain)
+            return false;
+
+        DXGI_SWAP_CHAIN_DESC swap_chain_desc{};
+        swap_chain_desc.BufferDesc.Width       = 100;
+        swap_chain_desc.BufferDesc.Height      = 100;
+        swap_chain_desc.BufferDesc.RefreshRate = {60, 1};
+        swap_chain_desc.BufferDesc.Format      = DXGI_FORMAT_R8G8B8A8_UNORM;
+        swap_chain_desc.SampleDesc             = {1, 0};
+        swap_chain_desc.BufferUsage            = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+        swap_chain_desc.BufferCount            = 1;
+        swap_chain_desc.OutputWindow           = window.handle();
+        swap_chain_desc.Windowed               = TRUE;
+        swap_chain_desc.SwapEffect             = DXGI_SWAP_EFFECT_DISCARD;
+
+        constexpr D3D_FEATURE_LEVEL feature_levels[] = {D3D_FEATURE_LEVEL_11_0};
+        ID3D11Device*        device         = nullptr;
+        ID3D11DeviceContext* device_context = nullptr;
+        IDXGISwapChain*      swap_chain     = nullptr;
+
+        if (FAILED(create_device_and_swap_chain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0,
+                                                feature_levels, 1, D3D11_SDK_VERSION,
+                                                &swap_chain_desc, &swap_chain,
+                                                &device, nullptr, &device_context)))
+            return false;
+
+        m_dx11_present_hook = safetyhook::create_inline(
+            vtable_fn(swap_chain, 8),   // IDXGISwapChain::Present
+            reinterpret_cast<void*>(&dx11_present_detour));
+
+        m_dx11_resize_buffers_hook = safetyhook::create_inline(
+            vtable_fn(swap_chain, 13),  // IDXGISwapChain::ResizeBuffers
+            reinterpret_cast<void*>(&dx11_resize_buffers_detour));
+
+        swap_chain->Release();
+        device_context->Release();
+        device->Release();
+
+        if (!m_dx11_present_hook || !m_dx11_resize_buffers_hook)
+        {
+            m_dx11_present_hook        = {};
+            m_dx11_resize_buffers_hook = {};
+            return false;
+        }
+
+        m_is_dx11_hooked = true;
+        return true;
+    }
+
+    void HooksManager::unhook_dx11()
+    {
+        std::unique_lock lock(m_mutex);
+        m_dx11_present_hook        = {};
+        m_dx11_resize_buffers_hook = {};
+        m_is_dx11_hooked = false;
+    }
+
+    bool HooksManager::hook_dx12()
+    {
+        std::unique_lock lock(m_mutex);
+        if (m_is_dx12_hooked)
+            return true;
+
+        const DummyWindow window;
+        if (!window.valid())
+            return false;
+
+        const auto fns = read_dx12_vtable_fns(window.handle());
+        if (!fns)
+            return false;
+
+        m_dx12_present_hook = safetyhook::create_inline(
+            fns->present,
+            reinterpret_cast<void*>(&dx12_present_detour));
+
+        m_dx12_resize_buffers_hook = safetyhook::create_inline(
+            fns->resize_buffers,
+            reinterpret_cast<void*>(&dx12_resize_buffers_detour));
+
+        m_dx12_execute_command_lists_hook = safetyhook::create_inline(
+            fns->execute_command_lists,
+            reinterpret_cast<void*>(&dx12_execute_command_lists_detour));
+
+        if (!m_dx12_present_hook || !m_dx12_resize_buffers_hook || !m_dx12_execute_command_lists_hook)
+        {
+            m_dx12_present_hook               = {};
+            m_dx12_resize_buffers_hook        = {};
+            m_dx12_execute_command_lists_hook = {};
+            return false;
+        }
+
+        m_is_dx12_hooked = true;
+        return true;
+    }
+
+    void HooksManager::unhook_dx12()
+    {
+        std::unique_lock lock(m_mutex);
+        m_dx12_present_hook               = {};
+        m_dx12_resize_buffers_hook        = {};
+        m_dx12_execute_command_lists_hook = {};
+        m_is_dx12_hooked = false;
+    }
+
+    void HooksManager::set_on_present(present_callback callback)
+    {
+        std::unique_lock lock(m_mutex);
+        m_present_cb = std::move(callback);
+    }
+
+    void HooksManager::set_on_resize_buffers(resize_buffers_callback callback)
+    {
+        std::unique_lock lock(m_mutex);
+        m_resize_buffers_cb = std::move(callback);
+    }
+
+    void HooksManager::set_on_execute_command_lists(execute_command_lists_callback callback)
+    {
+        std::unique_lock lock(m_mutex);
+        m_execute_command_lists_cb = std::move(callback);
+    }
+
+    bool HooksManager::hook_wnd_proc(HWND hwnd)
+    {
+        std::unique_lock lock(m_mutex);
+        if (m_is_wnd_proc_hooked)
+            return true;
+
+        const auto prev = reinterpret_cast<WNDPROC>(
+            SetWindowLongPtr(hwnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(&wnd_proc_detour)));
+        if (!prev)
+            return false;
+
+        m_hooked_hwnd        = hwnd;
+        m_original_wndproc   = prev;
+        m_is_wnd_proc_hooked = true;
+        return true;
+    }
+
+    void HooksManager::unhook_wnd_proc()
+    {
+        std::unique_lock lock(m_mutex);
+        if (!m_is_wnd_proc_hooked)
+            return;
+
+        SetWindowLongPtr(m_hooked_hwnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(m_original_wndproc));
+        m_hooked_hwnd        = nullptr;
+        m_original_wndproc   = nullptr;
+        m_is_wnd_proc_hooked = false;
+    }
+
+    void HooksManager::set_on_wnd_proc(wnd_proc_callback callback)
+    {
+        std::unique_lock lock(m_mutex);
+        m_wnd_proc_cb = std::move(callback);
+    }
+
+    // Detour implementations: copy callback under shared lock, call it unlocked,
+    // then call original. This avoids a deadlock if the callback itself calls set_on_*().
+
+    HRESULT __stdcall HooksManager::dx9_present_detour(IDirect3DDevice9* p_device, const RECT* p_source_rect,
+                                                       const RECT* p_dest_rect, HWND h_dest_window_override,
+                                                       const RGNDATA* p_dirty_region)
+    {
+        auto& mgr = get();
+        dx9_present_callback cb;
+        {
+            std::shared_lock lock(mgr.m_mutex);
+            cb = mgr.m_dx9_present_cb;
+        }
+        if (cb)
+            cb(p_device, p_source_rect, p_dest_rect, h_dest_window_override, p_dirty_region);
+        return mgr.m_dx9_present_hook.call<HRESULT>(p_device, p_source_rect, p_dest_rect,
+                                                    h_dest_window_override, p_dirty_region);
+    }
+
+    HRESULT __stdcall HooksManager::dx9_reset_detour(IDirect3DDevice9* p_device,
+                                                     D3DPRESENT_PARAMETERS* p_presentation_parameters)
+    {
+        auto& mgr = get();
+        dx9_reset_callback cb;
+        {
+            std::shared_lock lock(mgr.m_mutex);
+            cb = mgr.m_dx9_reset_cb;
+        }
+        if (cb)
+            cb(p_device, p_presentation_parameters);
+        return mgr.m_dx9_reset_hook.call<HRESULT>(p_device, p_presentation_parameters);
+    }
+
+    HRESULT __stdcall HooksManager::dx9_end_scene_detour(IDirect3DDevice9* p_device)
+    {
+        auto& mgr = get();
+        dx9_end_scene_callback cb;
+        {
+            std::shared_lock lock(mgr.m_mutex);
+            cb = mgr.m_dx9_end_scene_cb;
+        }
+        if (cb)
+            cb(p_device);
+        return mgr.m_dx9_end_scene_hook.call<HRESULT>(p_device);
+    }
+
+    HRESULT __stdcall HooksManager::dx11_present_detour(IDXGISwapChain* p_swap_chain, UINT sync_interval, UINT flags)
+    {
+        auto& mgr = get();
+        present_callback cb;
+        {
+            std::shared_lock lock(mgr.m_mutex);
+            cb = mgr.m_present_cb;
+        }
+        if (cb)
+            cb(p_swap_chain, sync_interval, flags);
+        return mgr.m_dx11_present_hook.call<HRESULT>(p_swap_chain, sync_interval, flags);
+    }
+
+    HRESULT __stdcall HooksManager::dx11_resize_buffers_detour(IDXGISwapChain* p_swap_chain, UINT buffer_count,
+                                                               UINT width, UINT height, DXGI_FORMAT new_format,
+                                                               UINT swap_chain_flags)
+    {
+        auto& mgr = get();
+        resize_buffers_callback cb;
+        {
+            std::shared_lock lock(mgr.m_mutex);
+            cb = mgr.m_resize_buffers_cb;
+        }
+        if (cb)
+            cb(p_swap_chain, buffer_count, width, height, new_format, swap_chain_flags);
+        return mgr.m_dx11_resize_buffers_hook.call<HRESULT>(p_swap_chain, buffer_count, width, height,
+                                                            new_format, swap_chain_flags);
+    }
+
+    HRESULT __stdcall HooksManager::dx12_present_detour(IDXGISwapChain* p_swap_chain, UINT sync_interval, UINT flags)
+    {
+        auto& mgr = get();
+        present_callback cb;
+        {
+            std::shared_lock lock(mgr.m_mutex);
+            cb = mgr.m_present_cb;
+        }
+        if (cb)
+            cb(p_swap_chain, sync_interval, flags);
+        return mgr.m_dx12_present_hook.call<HRESULT>(p_swap_chain, sync_interval, flags);
+    }
+
+    HRESULT __stdcall HooksManager::dx12_resize_buffers_detour(IDXGISwapChain* p_swap_chain, UINT buffer_count,
+                                                               UINT width, UINT height, DXGI_FORMAT new_format,
+                                                               UINT swap_chain_flags)
+    {
+        auto& mgr = get();
+        resize_buffers_callback cb;
+        {
+            std::shared_lock lock(mgr.m_mutex);
+            cb = mgr.m_resize_buffers_cb;
+        }
+        if (cb)
+            cb(p_swap_chain, buffer_count, width, height, new_format, swap_chain_flags);
+        return mgr.m_dx12_resize_buffers_hook.call<HRESULT>(p_swap_chain, buffer_count, width, height,
+                                                            new_format, swap_chain_flags);
+    }
+
+    void __stdcall HooksManager::dx12_execute_command_lists_detour(ID3D12CommandQueue* p_command_queue,
+                                                                   UINT num_command_lists,
+                                                                   ID3D12CommandList* const* pp_command_lists)
+    {
+        auto& mgr = get();
+        execute_command_lists_callback cb;
+        {
+            std::shared_lock lock(mgr.m_mutex);
+            cb = mgr.m_execute_command_lists_cb;
+        }
+        if (cb)
+            cb(p_command_queue, num_command_lists, pp_command_lists);
+        mgr.m_dx12_execute_command_lists_hook.call<void>(p_command_queue, num_command_lists, pp_command_lists);
+    }
+
+    LRESULT __stdcall HooksManager::wnd_proc_detour(HWND hwnd, UINT msg, WPARAM w_param, LPARAM l_param)
+    {
+        auto& mgr = get();
+        wnd_proc_callback cb;
+        WNDPROC original;
+        {
+            std::shared_lock lock(mgr.m_mutex);
+            cb       = mgr.m_wnd_proc_cb;
+            original = mgr.m_original_wndproc;
+        }
+        if (cb)
+        {
+            if (const auto result = cb(hwnd, msg, w_param, l_param))
+                return *result;
+        }
+        return CallWindowProc(original, hwnd, msg, w_param, l_param);
+    }
+} // namespace omath::hooks
+
+#else // !OMATH_ENABLE_HOOKING
+
+namespace omath::hooks
+{
+    HooksManager& HooksManager::get()
+    {
+        static HooksManager obj;
+        return obj;
+    }
+    HooksManager::~HooksManager() = default;
+} // namespace omath::hooks
+
+#endif

source/hud/entity_overlay.cpp

@@ -457,6 +457,137 @@ namespace omath::hud
           m_text_cursor_left(m_canvas.top_left_corner), m_renderer(renderer)
     {
     }
+    // ── Spacers ─────────────────────────────────────────────────────────────────
+    EntityOverlay& EntityOverlay::add_right_space_vertical(const float size)
+    {
+        m_text_cursor_right.y += size;
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_right_space_horizontal(const float size)
+    {
+        m_text_cursor_right.x += size;
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_left_space_vertical(const float size)
+    {
+        m_text_cursor_left.y += size;
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_left_space_horizontal(const float size)
+    {
+        m_text_cursor_left.x -= size;
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_top_space_vertical(const float size)
+    {
+        m_text_cursor_top.y -= size;
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_top_space_horizontal(const float size)
+    {
+        m_text_cursor_top.x += size;
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_bottom_space_vertical(const float size)
+    {
+        m_text_cursor_bottom.y += size;
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_bottom_space_horizontal(const float size)
+    {
+        m_text_cursor_bottom.x += size;
+        return *this;
+    }
+
+    // ── Progress rings ──────────────────────────────────────────────────────────
+    EntityOverlay& EntityOverlay::add_right_progress_ring(const Color& color, const Color& bg, const float radius,
+                                                          const float ratio, const float thickness, const float offset,
+                                                          const int segments)
+    {
+        const auto cx = m_text_cursor_right.x + offset + radius;
+        const auto cy = m_text_cursor_right.y + radius;
+        draw_progress_ring({cx, cy}, widget::ProgressRing{color, bg, radius, ratio, thickness, offset, segments});
+        m_text_cursor_right.y += radius * 2.f;
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_left_progress_ring(const Color& color, const Color& bg, const float radius,
+                                                         const float ratio, const float thickness, const float offset,
+                                                         const int segments)
+    {
+        const auto cx = m_text_cursor_left.x - offset - radius;
+        const auto cy = m_text_cursor_left.y + radius;
+        draw_progress_ring({cx, cy}, widget::ProgressRing{color, bg, radius, ratio, thickness, offset, segments});
+        m_text_cursor_left.y += radius * 2.f;
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_top_progress_ring(const Color& color, const Color& bg, const float radius,
+                                                        const float ratio, const float thickness, const float offset,
+                                                        const int segments)
+    {
+        m_text_cursor_top.y -= radius * 2.f;
+        const auto cx = m_text_cursor_top.x + radius;
+        const auto cy = m_text_cursor_top.y - offset + radius;
+        draw_progress_ring({cx, cy}, widget::ProgressRing{color, bg, radius, ratio, thickness, offset, segments});
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_bottom_progress_ring(const Color& color, const Color& bg, const float radius,
+                                                           const float ratio, const float thickness, const float offset,
+                                                           const int segments)
+    {
+        const auto cx = m_text_cursor_bottom.x + radius;
+        const auto cy = m_text_cursor_bottom.y + offset + radius;
+        draw_progress_ring({cx, cy}, widget::ProgressRing{color, bg, radius, ratio, thickness, offset, segments});
+        m_text_cursor_bottom.y += radius * 2.f;
+        return *this;
+    }
+
+    // ── Icons ────────────────────────────────────────────────────────────────────
+    EntityOverlay& EntityOverlay::add_right_icon(const std::any& texture_id, const float width, const float height,
+                                                 const Color& tint, const float offset)
+    {
+        const auto pos = m_text_cursor_right + Vector2<float>{offset, 0.f};
+        m_renderer->add_image(texture_id, pos, pos + Vector2<float>{width, height}, tint);
+        m_text_cursor_right.y += height;
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_left_icon(const std::any& texture_id, const float width, const float height,
+                                                const Color& tint, const float offset)
+    {
+        const auto pos = m_text_cursor_left + Vector2<float>{-(offset + width), 0.f};
+        m_renderer->add_image(texture_id, pos, pos + Vector2<float>{width, height}, tint);
+        m_text_cursor_left.y += height;
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_top_icon(const std::any& texture_id, const float width, const float height,
+                                               const Color& tint, const float offset)
+    {
+        m_text_cursor_top.y -= height;
+        const auto pos = m_text_cursor_top + Vector2<float>{0.f, -offset};
+        m_renderer->add_image(texture_id, pos, pos + Vector2<float>{width, height}, tint);
+        return *this;
+    }
+
+    EntityOverlay& EntityOverlay::add_bottom_icon(const std::any& texture_id, const float width, const float height,
+                                                  const Color& tint, const float offset)
+    {
+        const auto pos = m_text_cursor_bottom + Vector2<float>{0.f, offset};
+        m_renderer->add_image(texture_id, pos, pos + Vector2<float>{width, height}, tint);
+        m_text_cursor_bottom.y += height;
+        return *this;
+    }
+
     // ── widget dispatch ───────────────────────────────────────────────────────
     void EntityOverlay::dispatch(const widget::Box& box)
     {
@@ -483,10 +614,78 @@ namespace omath::hud
         add_snap_line(snap_line.start, snap_line.color, snap_line.width);
     }
 
-    // ── Side container dispatch ───────────────────────────────────────────────
+    void EntityOverlay::dispatch(const widget::ScanMarker& scan_marker)
-    void EntityOverlay::dispatch(const widget::RightSide& s)
     {
-        for (const auto& child : s.children)
+        const auto box_width = std::abs(m_canvas.top_right_corner.x - m_canvas.top_left_corner.x);
+        const auto box_height = std::abs(m_canvas.bottom_left_corner.y - m_canvas.top_left_corner.y);
+
+        const auto center_x = (m_canvas.top_left_corner.x + m_canvas.top_right_corner.x) / 2.f;
+        const auto center_y = m_canvas.top_left_corner.y + box_height * 0.44f;
+
+        const auto side = std::min(box_width, box_height) * 0.5f;
+        const auto h = side * std::sqrt(3.f) / 2.f;
+
+        const std::array<Vector2<float>, 3> tri = {
+                Vector2<float>{center_x, center_y - h * 2.f / 3.f},
+                Vector2<float>{center_x - side / 2.f, center_y + h / 3.f},
+                Vector2<float>{center_x + side / 2.f, center_y + h / 3.f},
+        };
+
+        m_renderer->add_filled_polyline({tri.data(), tri.size()}, scan_marker.color);
+
+        if (scan_marker.outline.value().w > 0.f)
+            m_renderer->add_polyline({tri.data(), tri.size()}, scan_marker.outline, scan_marker.outline_thickness);
+    }
+
+    void EntityOverlay::dispatch(const widget::AimDot& aim_dot)
+    {
+        m_renderer->add_filled_circle(aim_dot.position, aim_dot.radius, aim_dot.color);
+    }
+    void EntityOverlay::dispatch(const widget::ProjectileAim& proj_widget)
+    {
+        const auto box_width = std::abs(m_canvas.top_right_corner.x - m_canvas.top_left_corner.x);
+        const auto box_height = std::abs(m_canvas.bottom_left_corner.y - m_canvas.top_left_corner.y);
+
+        const auto box_center = m_canvas.top_left_corner + Vector2{box_width, box_height} / 2.f;
+
+        m_renderer->add_line(box_center, proj_widget.position, proj_widget.color, proj_widget.line_size);
+
+        if (proj_widget.figure == widget::ProjectileAim::Figure::CIRCLE)
+        {
+            m_renderer->add_filled_circle(proj_widget.position, proj_widget.size, proj_widget.color);
+            return;
+        }
+
+        if (proj_widget.figure == widget::ProjectileAim::Figure::SQUARE)
+        {
+            const auto box_min = proj_widget.position - Vector2{proj_widget.size, proj_widget.size} / 2.f;
+            const auto box_max = proj_widget.position + Vector2{proj_widget.size, proj_widget.size} / 2.f;
+            m_renderer->add_filled_rectangle(box_min, box_max, proj_widget.color);
+            return;
+        }
+
+        std::unreachable();
+    }
+
+    void EntityOverlay::draw_progress_ring(const Vector2<float>& center, const widget::ProgressRing& ring)
+    {
+        constexpr auto pi = std::numbers::pi_v<float>;
+        const float ratio = std::clamp(ring.ratio, 0.f, 1.f);
+
+        m_renderer->add_circle(center, ring.radius, ring.bg, ring.thickness, ring.segments);
+
+        if (ratio > 0.f)
+        {
+            const float a_min = -pi / 2.f;
+            const float a_max = a_min + ratio * 2.f * pi;
+            m_renderer->add_arc(center, ring.radius, a_min, a_max, ring.color, ring.thickness, ring.segments);
+        }
+    }
+
+    // ── Side container dispatch ───────────────────────────────────────────────
+    void EntityOverlay::dispatch(const widget::RightSide& right_side)
+    {
+        for (const auto& child : right_side.children)
             std::visit(
                     widget::Overloaded{
                             [](const widget::None&)
@@ -509,13 +708,30 @@ namespace omath::hud
                             {
                                 add_right_label(w.child.color, w.child.offset, w.child.outlined, w.child.text);
                             },
+                            [this](const widget::SpaceVertical& w)
+                            {
+                                add_right_space_vertical(w.size);
+                            },
+                            [this](const widget::SpaceHorizontal& w)
+                            {
+                                add_right_space_horizontal(w.size);
+                            },
+                            [this](const widget::ProgressRing& w)
+                            {
+                                add_right_progress_ring(w.color, w.bg, w.radius, w.ratio, w.thickness, w.offset,
+                                                        w.segments);
+                            },
+                            [this](const widget::Icon& w)
+                            {
+                                add_right_icon(w.texture_id, w.width, w.height, w.tint, w.offset);
+                            },
                     },
                     child);
     }
 
-    void EntityOverlay::dispatch(const widget::LeftSide& s)
+    void EntityOverlay::dispatch(const widget::LeftSide& left_side)
     {
-        for (const auto& child : s.children)
+        for (const auto& child : left_side.children)
             std::visit(
                     widget::Overloaded{
                             [](const widget::None&)
@@ -538,6 +754,23 @@ namespace omath::hud
                             {
                                 add_left_label(w.child.color, w.child.offset, w.child.outlined, w.child.text);
                             },
+                            [this](const widget::SpaceVertical& w)
+                            {
+                                add_left_space_vertical(w.size);
+                            },
+                            [this](const widget::SpaceHorizontal& w)
+                            {
+                                add_left_space_horizontal(w.size);
+                            },
+                            [this](const widget::ProgressRing& w)
+                            {
+                                add_left_progress_ring(w.color, w.bg, w.radius, w.ratio, w.thickness, w.offset,
+                                                       w.segments);
+                            },
+                            [this](const widget::Icon& w)
+                            {
+                                add_left_icon(w.texture_id, w.width, w.height, w.tint, w.offset);
+                            },
                     },
                     child);
     }
@@ -567,6 +800,23 @@ namespace omath::hud
                             {
                                 add_centered_top_label(w.child.color, w.child.offset, w.child.outlined, w.child.text);
                             },
+                            [this](const widget::SpaceVertical& w)
+                            {
+                                add_top_space_vertical(w.size);
+                            },
+                            [this](const widget::SpaceHorizontal& w)
+                            {
+                                add_top_space_horizontal(w.size);
+                            },
+                            [this](const widget::ProgressRing& w)
+                            {
+                                add_top_progress_ring(w.color, w.bg, w.radius, w.ratio, w.thickness, w.offset,
+                                                      w.segments);
+                            },
+                            [this](const widget::Icon& w)
+                            {
+                                add_top_icon(w.texture_id, w.width, w.height, w.tint, w.offset);
+                            },
                     },
                     child);
     }
@@ -596,6 +846,23 @@ namespace omath::hud
                                 add_centered_bottom_label(w.child.color, w.child.offset, w.child.outlined,
                                                           w.child.text);
                             },
+                            [this](const widget::SpaceVertical& w)
+                            {
+                                add_bottom_space_vertical(w.size);
+                            },
+                            [this](const widget::SpaceHorizontal& w)
+                            {
+                                add_bottom_space_horizontal(w.size);
+                            },
+                            [this](const widget::ProgressRing& w)
+                            {
+                                add_bottom_progress_ring(w.color, w.bg, w.radius, w.ratio, w.thickness, w.offset,
+                                                         w.segments);
+                            },
+                            [this](const widget::Icon& w)
+                            {
+                                add_bottom_icon(w.texture_id, w.width, w.height, w.tint, w.offset);
+                            },
                     },
                     child);
     }

source/hud/renderer_realizations/imgui_renderer.cpp

@@ -42,6 +42,32 @@ namespace omath::hud
         ImGui::GetBackgroundDrawList()->AddRectFilled(min.to_im_vec2(), max.to_im_vec2(), color.to_im_color());
     }
 
+    void ImguiHudRenderer::add_circle(const Vector2<float>& center, const float radius, const Color& color,
+                                       const float thickness, const int segments)
+    {
+        ImGui::GetBackgroundDrawList()->AddCircle(center.to_im_vec2(), radius, color.to_im_color(), segments, thickness);
+    }
+
+    void ImguiHudRenderer::add_filled_circle(const Vector2<float>& center, const float radius, const Color& color,
+                                              const int segments)
+    {
+        ImGui::GetBackgroundDrawList()->AddCircleFilled(center.to_im_vec2(), radius, color.to_im_color(), segments);
+    }
+
+    void ImguiHudRenderer::add_arc(const Vector2<float>& center, const float radius, const float a_min, const float a_max,
+                                    const Color& color, const float thickness, const int segments)
+    {
+        ImGui::GetBackgroundDrawList()->PathArcTo(center.to_im_vec2(), radius, a_min, a_max, segments);
+        ImGui::GetBackgroundDrawList()->PathStroke(color.to_im_color(), ImDrawFlags_None, thickness);
+    }
+
+    void ImguiHudRenderer::add_image(const std::any& texture_id, const Vector2<float>& min, const Vector2<float>& max,
+                                      const Color& tint)
+    {
+        ImGui::GetBackgroundDrawList()->AddImage(std::any_cast<ImTextureID>(texture_id), min.to_im_vec2(),
+                                                  max.to_im_vec2(), {0, 0}, {1, 1}, tint.to_im_color());
+    }
+
     void ImguiHudRenderer::add_text(const Vector2<float>& position, const Color& color, const std::string_view& text)
     {
         ImGui::GetBackgroundDrawList()->AddText(position.to_im_vec2(), color.to_im_color(), text.data(),

source/lua/lua_engines.cpp

@@ -3,6 +3,8 @@
 //
 #ifdef OMATH_ENABLE_LUA
 #include "omath/lua/lua.hpp"
+#include "omath/omath.hpp"
+#include "omath/projection/error_codes.hpp"
 #include <omath/engines/cry_engine/camera.hpp>
 #include <omath/engines/frostbite_engine/camera.hpp>
 #include <omath/engines/iw_engine/camera.hpp>
@@ -33,6 +35,8 @@ namespace
             return "world position is out of screen bounds";
         case omath::projection::Error::INV_VIEW_PROJ_MAT_DET_EQ_ZERO:
             return "inverse view-projection matrix determinant is zero";
+        case omath::projection::Error::PERSPECTIVE_DIVIDER_LESS_EQ_ZERO:
+            return "perspective divider is less or equal to zero";
         }
         return "unknown error";
     }
@@ -74,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;
@@ -88,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",
@@ -100,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)
@@ -110,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)
@@ -220,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,14 +14,14 @@
 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;
         const float v0 = projectile.m_launch_speed;
         const float v0_sqr = v0 * v0;
-        const Vector3 proj_origin = projectile.m_origin;
+        const Vector3 proj_origin = projectile.m_origin + projectile.m_launch_offset;
 
         constexpr int SIMD_FACTOR = 8;
         float current_time = m_simulation_time_step;
@@ -124,6 +124,110 @@ namespace omath::projectile_prediction
                 std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
 #endif
     }
+    std::optional<AimAngles<float>>
+    ProjPredEngineAvx2::maybe_calculate_aim_angles([[maybe_unused]] const Projectile<float>& projectile,
+                                                    [[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;
+        const float v0 = projectile.m_launch_speed;
+        const Vector3 proj_origin = projectile.m_origin + projectile.m_launch_offset;
+
+        constexpr int SIMD_FACTOR = 8;
+        float current_time = m_simulation_time_step;
+
+        for (; current_time <= m_maximum_simulation_time; current_time += m_simulation_time_step * SIMD_FACTOR)
+        {
+            const __m256 times
+                    = _mm256_setr_ps(current_time, current_time + m_simulation_time_step,
+                                     current_time + m_simulation_time_step * 2, current_time + m_simulation_time_step * 3,
+                                     current_time + m_simulation_time_step * 4, current_time + m_simulation_time_step * 5,
+                                     current_time + m_simulation_time_step * 6, current_time + m_simulation_time_step * 7);
+
+            const __m256 target_x
+                    = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.x), times, _mm256_set1_ps(target.m_origin.x));
+            const __m256 target_y
+                    = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.y), times, _mm256_set1_ps(target.m_origin.y));
+            const __m256 times_sq = _mm256_mul_ps(times, times);
+            const __m256 target_z = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.z), times,
+                                                   _mm256_fnmadd_ps(_mm256_set1_ps(0.5f * m_gravity_constant), times_sq,
+                                                                    _mm256_set1_ps(target.m_origin.z)));
+
+            const __m256 delta_x = _mm256_sub_ps(target_x, _mm256_set1_ps(proj_origin.x));
+            const __m256 delta_y = _mm256_sub_ps(target_y, _mm256_set1_ps(proj_origin.y));
+
+            const __m256 d_sqr = _mm256_add_ps(_mm256_mul_ps(delta_x, delta_x), _mm256_mul_ps(delta_y, delta_y));
+            const __m256 delta_z = _mm256_sub_ps(target_z, _mm256_set1_ps(proj_origin.z));
+
+            const __m256 bg_times_sq = _mm256_mul_ps(_mm256_set1_ps(bullet_gravity), times_sq);
+            const __m256 term = _mm256_add_ps(delta_z, _mm256_mul_ps(_mm256_set1_ps(0.5f), bg_times_sq));
+            const __m256 term_sq = _mm256_mul_ps(term, term);
+            const __m256 numerator = _mm256_add_ps(d_sqr, term_sq);
+            const __m256 denominator = _mm256_add_ps(times_sq, _mm256_set1_ps(1e-8f));
+            const __m256 required_v0_sqr = _mm256_div_ps(numerator, denominator);
+
+            const __m256 v0_sqr_vec = _mm256_set1_ps(v0 * v0 + 1e-3f);
+            const __m256 mask = _mm256_cmp_ps(required_v0_sqr, v0_sqr_vec, _CMP_LE_OQ);
+
+            const unsigned valid_mask = _mm256_movemask_ps(mask);
+            if (!valid_mask)
+                continue;
+
+            alignas(32) float valid_times[SIMD_FACTOR];
+            _mm256_store_ps(valid_times, times);
+
+            for (int i = 0; i < SIMD_FACTOR; ++i)
+            {
+                if (!(valid_mask & (1 << i)))
+                    continue;
+
+                const float candidate_time = valid_times[i];
+                if (candidate_time > m_maximum_simulation_time)
+                    continue;
+
+                for (float fine_time = candidate_time - m_simulation_time_step * 2;
+                     fine_time <= candidate_time + m_simulation_time_step * 2; fine_time += m_simulation_time_step)
+                {
+                    if (fine_time < 0)
+                        continue;
+
+                    Vector3 target_pos = target.m_origin + target.m_velocity * fine_time;
+                    if (target.m_is_airborne)
+                        target_pos.z -= 0.5f * m_gravity_constant * fine_time * fine_time;
+
+                    const auto pitch = calculate_pitch(proj_origin, target_pos, bullet_gravity, v0, fine_time);
+                    if (!pitch)
+                        continue;
+
+                    const Vector3 delta = target_pos - projectile.m_origin;
+                    const float yaw = angles::radians_to_degrees(std::atan2(delta.y, delta.x));
+                    return AimAngles<float>{*pitch, yaw};
+                }
+            }
+        }
+
+        for (; current_time <= m_maximum_simulation_time; current_time += m_simulation_time_step)
+        {
+            Vector3 target_pos = target.m_origin + target.m_velocity * current_time;
+            if (target.m_is_airborne)
+                target_pos.z -= 0.5f * m_gravity_constant * current_time * current_time;
+
+            const auto pitch = calculate_pitch(proj_origin, target_pos, bullet_gravity, v0, current_time);
+            if (!pitch)
+                continue;
+
+            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 std::nullopt;
+#else
+        throw std::runtime_error(
+                std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
+#endif
+    }
+
     ProjPredEngineAvx2::ProjPredEngineAvx2(const float gravity_constant, const float simulation_time_step,
                                            const float maximum_simulation_time)
         : m_gravity_constant(gravity_constant), m_simulation_time_step(simulation_time_step),

tests/engines/unit_test_cry_engine.cpp

@@ -237,4 +237,54 @@ TEST(unit_test_cry_engine, loook_at_random_z_axis)
             failed_points++;
     }
     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);
+}