added more tests

.clang-format

@@ -12,7 +12,6 @@ AlignConsecutiveMacros: AcrossEmptyLinesAndComments
 AlignTrailingComments: false
 AllowShortBlocksOnASingleLine: Never
 AllowShortFunctionsOnASingleLine: None
-AllowShortLambdasOnASingleLine: None
 AllowShortIfStatementsOnASingleLine: false
 AllowShortLoopsOnASingleLine: false
 BreakTemplateDeclarations: Leave

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

@@ -370,8 +370,6 @@ 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' }} \
@@ -382,7 +380,6 @@ 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

@@ -1,62 +0,0 @@
-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,35 +12,6 @@ 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="DO_NOT_SHOW" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassCanBeFinal/@EntryIndexedValue" value="WARNING" 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" />
@@ -110,7 +110,7 @@
     <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="DO_NOT_SHOW" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableWithNonTrivialDtorIsNeverUsed/@EntryIndexedValue" value="WARNING" 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" />

CMakeLists.txt

@@ -34,6 +34,8 @@ option(OMATH_ENABLE_FORCE_INLINE
 
 option(OMATH_ENABLE_LUA
         "omath bindings for lua" OFF)
+option(OMATH_ENABLE_PHYSX
+        "PhysX-backed collider implementations" OFF)
 if(VCPKG_MANIFEST_FEATURES)
     foreach(omath_feature IN LISTS VCPKG_MANIFEST_FEATURES)
         if(omath_feature STREQUAL "imgui")
@@ -48,6 +50,8 @@ if(VCPKG_MANIFEST_FEATURES)
             set(OMATH_BUILD_EXAMPLES ON)
         elseif(omath_feature STREQUAL "lua")
             set(OMATH_ENABLE_LUA ON)
+        elseif(omath_feature STREQUAL "physx")
+            set(OMATH_ENABLE_PHYSX ON)
         endif()
 
     endforeach()
@@ -78,6 +82,7 @@ if(${PROJECT_IS_TOP_LEVEL})
     message(STATUS "[${PROJECT_NAME}]: Coverage feature status ${OMATH_ENABLE_COVERAGE}")
     message(STATUS "[${PROJECT_NAME}]: Valgrind feature status ${OMATH_ENABLE_VALGRIND}")
     message(STATUS "[${PROJECT_NAME}]: Lua feature status ${OMATH_ENABLE_LUA}")
+    message(STATUS "[${PROJECT_NAME}]: PhysX feature status ${OMATH_ENABLE_PHYSX}")
 endif()
 
 file(GLOB_RECURSE OMATH_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp")
@@ -100,6 +105,13 @@ if (OMATH_ENABLE_LUA)
     target_include_directories(${PROJECT_NAME} PRIVATE ${SOL2_INCLUDE_DIRS})
 endif ()
 
+if (OMATH_ENABLE_PHYSX)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_PHYSX)
+
+    find_package(unofficial-omniverse-physx-sdk CONFIG REQUIRED)
+    target_link_libraries(${PROJECT_NAME} PUBLIC unofficial::omniverse-physx-sdk::sdk)
+endif ()
+
 add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
 
 target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_VERSION="${PROJECT_VERSION}")

CMakePresets.json

@@ -145,7 +145,7 @@
       "hidden": true,
       "inherits": ["linux-base", "vcpkg-base"],
       "cacheVariables": {
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;lua"
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;lua;physx"
       }
     },
     {

CONTRIBUTING.md

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

CREDITS.md

@@ -3,8 +3,8 @@
 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
 
 And a big hand to everyone else who has contributed over the past!
 

INSTALL.md

@@ -28,29 +28,6 @@ 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.

README.md

@@ -14,7 +14,7 @@
 [![discord badge](https://dcbadge.limes.pink/api/server/https://discord.gg/eDgdaWbqwZ?style=flat)](https://discord.gg/eDgdaWbqwZ)
 [![telegram badge](https://img.shields.io/badge/Telegram-2CA5E0?style=flat-squeare&logo=telegram&logoColor=white)](https://t.me/orangennotes)
 
-OMath is a 100% independent, constexpr template blazingly fast math/physics/games/mods/cheats development framework that doesn't have legacy C++ code.
+OMath is a 100% independent, constexpr template blazingly fast math library that doesn't have legacy C++ code.
 
 It provides the latest features, is highly customizable, has all for cheat development, DirectX/OpenGL/Vulkan support, premade support for different game engines, much more constexpr stuff than in other libraries and more...
 <br>
@@ -84,8 +84,7 @@ if (auto screen = camera.world_to_screen(world_position)) {
 - **Engine support**: Supports coordinate systems of **Source, Unity, Unreal, Frostbite, IWEngine, CryEngine and canonical OpenGL**.
 - **Cross platform**: Supports Windows, MacOS and Linux.
 - **Algorithms**: Has ability to scan for byte pattern with wildcards in ELF/Mach-O/PE files/modules, binary slices, works even with Wine apps. 
-- **Scripting**: Supports to make scripts in Lua out of box.
-- **Handy**: Allow to design wall hacks in modern jetpack compose like way.
+- **Scripting**: Supports to make scripts in Lua out of box
 - **Battle tested**: It's already used by some big players on the market like wraith.su and bluedream.ltd
 <div align = center>
  

docs/install.md

@@ -1,6 +1,6 @@
-# Installation Guide
+# Installation
 
-## <img width="28px" src="https://vcpkg.io/assets/mark/mark.svg" /> Using vcpkg (recomended)
+## <img width="28px" src="https://vcpkg.io/assets/mark/mark.svg" /> Using vcpkg
 **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,69 +28,6 @@ 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**
 
@@ -125,7 +62,7 @@ For more details, see the [Conan documentation](https://docs.conan.io/2/).
    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

@@ -2,7 +2,6 @@ add_subdirectory(example_barycentric)
 add_subdirectory(example_glfw3)
 add_subdirectory(example_proj_mat_builder)
 add_subdirectory(example_signature_scan)
-add_subdirectory(example_hud)
 
 if(OMATH_ENABLE_VALGRIND)
     omath_setup_valgrind(example_projection_matrix_builder)

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.value().x);
-        lines.push_back(color.value().y);
-        lines.push_back(color.value().z);
+        lines.push_back(color.x);
+        lines.push_back(color.y);
+        lines.push_back(color.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.value().x);
-        lines.push_back(color.value().y);
-        lines.push_back(color.value().z);
+        lines.push_back(color.x);
+        lines.push_back(color.y);
+        lines.push_back(color.z);
         lines.push_back(1.0f); // size
         lines.push_back(1.0f); // isLine
     };

examples/example_hud/CMakeLists.txt

@@ -1,16 +0,0 @@
-project(example_hud)
-
-
-add_executable(${PROJECT_NAME} main.cpp gui/main_window.cpp gui/main_window.hpp)
-
-set_target_properties(
-        ${PROJECT_NAME}
-        PROPERTIES CXX_STANDARD 23
-        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(OpenGL)
-find_package(GLEW REQUIRED)
-find_package(glfw3 CONFIG REQUIRED)
-target_link_libraries(${PROJECT_NAME} PRIVATE glfw imgui::imgui omath::omath OpenGL::GL)

examples/example_hud/gui/main_window.cpp

@@ -1,263 +0,0 @@
-//
-// Created by Orange on 11/11/2024.
-//
-#include "main_window.hpp"
-#include "omath/hud/renderer_realizations/imgui_renderer.hpp"
-#include <GLFW/glfw3.h>
-#include <imgui.h>
-#include <imgui_impl_glfw.h>
-#include <imgui_impl_opengl3.h>
-#include <omath/hud/entity_overlay.hpp>
-
-namespace imgui_desktop::gui
-{
-    bool MainWindow::m_canMoveWindow = false;
-
-    MainWindow::MainWindow(const std::string_view& caption, int width, int height)
-    {
-        if (!glfwInit())
-            std::exit(EXIT_FAILURE);
-
-        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
-        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
-        glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, true);
-        m_window = glfwCreateWindow(width, height, caption.data(), nullptr, nullptr);
-
-        glfwMakeContextCurrent(m_window);
-
-        ImGui::CreateContext();
-        ImGui::StyleColorsDark();
-        ImGui::GetStyle().Colors[ImGuiCol_WindowBg] = {0.05f, 0.05f, 0.05f, 0.92f};
-        ImGui::GetStyle().AntiAliasedLines = false;
-        ImGui::GetStyle().AntiAliasedFill = false;
-        ImGui_ImplGlfw_InitForOpenGL(m_window, true);
-        ImGui_ImplOpenGL3_Init("#version 150");
-    }
-
-    void MainWindow::Run()
-    {
-        while (!glfwWindowShouldClose(m_window) && m_opened)
-        {
-            glfwPollEvents();
-            ImGui_ImplOpenGL3_NewFrame();
-            ImGui_ImplGlfw_NewFrame();
-            ImGui::NewFrame();
-
-            const auto* vp = ImGui::GetMainViewport();
-            ImGui::GetBackgroundDrawList()->AddRectFilled({}, vp->Size, ImColor(30, 30, 30, 220));
-
-            draw_controls();
-            draw_overlay();
-
-            ImGui::Render();
-            present();
-        }
-        glfwDestroyWindow(m_window);
-    }
-
-    void MainWindow::draw_controls()
-    {
-        const auto* vp = ImGui::GetMainViewport();
-        ImGui::SetNextWindowPos({0.f, 0.f});
-        ImGui::SetNextWindowSize({280.f, vp->Size.y});
-        ImGui::Begin("Controls", &m_opened,
-                     ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
-        ImGui::PushItemWidth(160.f);
-
-        if (ImGui::CollapsingHeader("Entity", ImGuiTreeNodeFlags_DefaultOpen))
-        {
-            ImGui::SliderFloat("X##ent", &m_entity_x, 100.f, vp->Size.x - 100.f);
-            ImGui::SliderFloat("Top Y", &m_entity_top_y, 20.f, m_entity_bottom_y - 20.f);
-            ImGui::SliderFloat("Bottom Y", &m_entity_bottom_y, m_entity_top_y + 20.f, vp->Size.y - 20.f);
-        }
-
-        if (ImGui::CollapsingHeader("Box", ImGuiTreeNodeFlags_DefaultOpen))
-        {
-            ImGui::Checkbox("Box##chk", &m_show_box);
-            ImGui::SameLine();
-            ImGui::Checkbox("Cornered", &m_show_cornered_box);
-            ImGui::SameLine();
-            ImGui::Checkbox("Dashed", &m_show_dashed_box);
-            ImGui::ColorEdit4("Color##box", reinterpret_cast<float*>(&m_box_color), ImGuiColorEditFlags_NoInputs);
-            ImGui::ColorEdit4("Fill##box", reinterpret_cast<float*>(&m_box_fill), ImGuiColorEditFlags_NoInputs);
-            ImGui::SliderFloat("Thickness", &m_box_thickness, 0.5f, 5.f);
-            ImGui::SliderFloat("Corner ratio", &m_corner_ratio, 0.05f, 0.5f);
-            ImGui::Separator();
-            ImGui::ColorEdit4("Dash color", reinterpret_cast<float*>(&m_dash_color), ImGuiColorEditFlags_NoInputs);
-            ImGui::SliderFloat("Dash length", &m_dash_len, 2.f, 30.f);
-            ImGui::SliderFloat("Dash gap", &m_dash_gap, 1.f, 20.f);
-            ImGui::SliderFloat("Dash thick", &m_dash_thickness, 0.5f, 5.f);
-        }
-
-        if (ImGui::CollapsingHeader("Bars", ImGuiTreeNodeFlags_DefaultOpen))
-        {
-            ImGui::ColorEdit4("Color##bar", reinterpret_cast<float*>(&m_bar_color), ImGuiColorEditFlags_NoInputs);
-            ImGui::ColorEdit4("BG##bar", reinterpret_cast<float*>(&m_bar_bg_color), ImGuiColorEditFlags_NoInputs);
-            ImGui::ColorEdit4("Outline##bar", reinterpret_cast<float*>(&m_bar_outline_color),
-                              ImGuiColorEditFlags_NoInputs);
-            ImGui::SliderFloat("Width##bar", &m_bar_width, 1.f, 20.f);
-            ImGui::SliderFloat("Value##bar", &m_bar_value, 0.f, 1.f);
-            ImGui::SliderFloat("Offset##bar", &m_bar_offset, 1.f, 20.f);
-            ImGui::Checkbox("Right##bar", &m_show_right_bar);
-            ImGui::SameLine();
-            ImGui::Checkbox("Left##bar", &m_show_left_bar);
-            ImGui::Checkbox("Top##bar", &m_show_top_bar);
-            ImGui::SameLine();
-            ImGui::Checkbox("Bottom##bar", &m_show_bottom_bar);
-            ImGui::Checkbox("Right dashed##bar", &m_show_right_dashed_bar);
-            ImGui::SameLine();
-            ImGui::Checkbox("Left dashed##bar", &m_show_left_dashed_bar);
-            ImGui::Checkbox("Top dashed##bar", &m_show_top_dashed_bar);
-            ImGui::SameLine();
-            ImGui::Checkbox("Bot dashed##bar", &m_show_bottom_dashed_bar);
-            ImGui::SliderFloat("Dash len##bar", &m_bar_dash_len, 2.f, 20.f);
-            ImGui::SliderFloat("Dash gap##bar", &m_bar_dash_gap, 1.f, 15.f);
-        }
-
-        if (ImGui::CollapsingHeader("Labels", ImGuiTreeNodeFlags_DefaultOpen))
-        {
-            ImGui::Checkbox("Outlined", &m_outlined);
-            ImGui::SliderFloat("Offset##lbl", &m_label_offset, 0.f, 15.f);
-            ImGui::Checkbox("Right##lbl", &m_show_right_labels);
-            ImGui::SameLine();
-            ImGui::Checkbox("Left##lbl", &m_show_left_labels);
-            ImGui::Checkbox("Top##lbl", &m_show_top_labels);
-            ImGui::SameLine();
-            ImGui::Checkbox("Bottom##lbl", &m_show_bottom_labels);
-            ImGui::Checkbox("Ctr top##lbl", &m_show_centered_top);
-            ImGui::SameLine();
-            ImGui::Checkbox("Ctr bot##lbl", &m_show_centered_bottom);
-        }
-
-        if (ImGui::CollapsingHeader("Skeleton"))
-        {
-            ImGui::Checkbox("Show##skel", &m_show_skeleton);
-            ImGui::ColorEdit4("Color##skel", reinterpret_cast<float*>(&m_skel_color), ImGuiColorEditFlags_NoInputs);
-            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);
-            ImGui::ColorEdit4("Color##snap", reinterpret_cast<float*>(&m_snap_color), ImGuiColorEditFlags_NoInputs);
-            ImGui::SliderFloat("Width##snap", &m_snap_width, 0.5f, 5.f);
-        }
-
-        ImGui::PopItemWidth();
-        ImGui::End();
-    }
-
-    void MainWindow::draw_overlay()
-    {
-        using namespace omath::hud::widget;
-        using omath::hud::when;
-        const auto* vp = ImGui::GetMainViewport();
-        const Bar bar{m_bar_color, m_bar_outline_color, m_bar_bg_color, m_bar_width, m_bar_value, m_bar_offset};
-        const DashedBar dbar{m_bar_color, m_bar_outline_color, m_bar_bg_color, m_bar_width,
-                             m_bar_value, m_bar_dash_len,      m_bar_dash_gap, m_bar_offset};
-
-        omath::hud::EntityOverlay({m_entity_x, m_entity_top_y}, {m_entity_x, m_entity_bottom_y},
-                                  std::make_shared<omath::hud::ImguiHudRenderer>())
-                .contents(
-                        // ── Boxes ────────────────────────────────────────────────────
-                        when(m_show_box, Box{m_box_color, m_box_fill, m_box_thickness}),
-                        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),
-                                when(m_show_right_labels,
-                                     Label{{0.f, 1.f, 0.f, 1.f}, m_label_offset, m_outlined, "Health: 100/100"}),
-                                when(m_show_right_labels,
-                                     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),
-                                when(m_show_left_dashed_bar, dbar),
-                                when(m_show_left_labels, Label{omath::Color::from_rgba(255, 128, 0, 255),
-                                                               m_label_offset, m_outlined, "Armor: 75"}),
-                                when(m_show_left_labels, Label{omath::Color::from_rgba(0, 200, 255, 255),
-                                                               m_label_offset, m_outlined, "Level: 42"}),
-                        },
-                        TopSide{
-                                when(m_show_top_bar, bar),
-                                when(m_show_top_dashed_bar, dbar),
-                                when(m_show_centered_top, Centered{Label{omath::Color::from_rgba(0, 255, 255, 255),
-                                                                         m_label_offset, m_outlined, "*VISIBLE*"}}),
-                                when(m_show_top_labels, Label{omath::Color::from_rgba(255, 255, 0, 255), m_label_offset,
-                                                              m_outlined, "*SCOPED*"}),
-                                when(m_show_top_labels, Label{omath::Color::from_rgba(255, 0, 0, 255), m_label_offset,
-                                                              m_outlined, "*BLEEDING*"}),
-                        },
-                        BottomSide{
-                                when(m_show_bottom_bar, bar),
-                                when(m_show_bottom_dashed_bar, dbar),
-                                when(m_show_centered_bottom, Centered{Label{omath::Color::from_rgba(255, 255, 255, 255),
-                                                                            m_label_offset, m_outlined, "PlayerName"}}),
-                                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}));
-    }
-
-    void MainWindow::present()
-    {
-        int w, h;
-        glfwGetFramebufferSize(m_window, &w, &h);
-        glViewport(0, 0, w, h);
-        glClearColor(0.f, 0.f, 0.f, 0.f);
-        glClear(GL_COLOR_BUFFER_BIT);
-        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
-        glfwSwapBuffers(m_window);
-    }
-} // namespace imgui_desktop::gui

examples/example_hud/gui/main_window.hpp

@@ -1,94 +0,0 @@
-//
-// Created by Orange on 11/11/2024.
-//
-#pragma once
-#include <omath/hud/entity_overlay.hpp>
-#include <omath/utility/color.hpp>
-#include <string_view>
-
-struct GLFWwindow;
-
-namespace imgui_desktop::gui
-{
-    class MainWindow
-    {
-    public:
-        MainWindow(const std::string_view& caption, int width, int height);
-        void Run();
-
-    private:
-        void draw_controls();
-        void draw_overlay();
-        void present();
-
-        GLFWwindow* m_window = nullptr;
-        static bool m_canMoveWindow;
-        bool m_opened = true;
-
-        // Entity
-        float m_entity_x = 550.f, m_entity_top_y = 150.f, m_entity_bottom_y = 450.f;
-
-        // Box
-        omath::Color m_box_color{1.f, 1.f, 1.f, 1.f};
-        omath::Color m_box_fill{0.f, 0.f, 0.f, 0.f};
-        float m_box_thickness = 1.f, m_corner_ratio = 0.2f;
-        bool m_show_box = true, m_show_cornered_box = true, m_show_dashed_box = false;
-
-        // Dashed box
-        omath::Color m_dash_color = omath::Color::from_rgba(255, 200, 0, 255);
-        float m_dash_len = 8.f, m_dash_gap = 5.f, m_dash_thickness = 1.f;
-
-        // Bars
-        omath::Color m_bar_color{0.f, 1.f, 0.f, 1.f};
-        omath::Color m_bar_bg_color{0.f, 0.f, 0.f, 0.5f};
-        omath::Color m_bar_outline_color{0.f, 0.f, 0.f, 1.f};
-        float m_bar_width = 4.f, m_bar_value = 0.75f, m_bar_offset = 5.f;
-        bool m_show_right_bar = true,         m_show_left_bar = true;
-        bool m_show_top_bar = true,           m_show_bottom_bar = true;
-        bool m_show_right_dashed_bar = false, m_show_left_dashed_bar = false;
-        bool m_show_top_dashed_bar = false,   m_show_bottom_dashed_bar = false;
-        float m_bar_dash_len = 6.f, m_bar_dash_gap = 4.f;
-
-        // Labels
-        float m_label_offset = 3.f;
-        bool m_outlined = true;
-        bool m_show_right_labels = true, m_show_left_labels = true;
-        bool m_show_top_labels = true,   m_show_bottom_labels = true;
-        bool m_show_centered_top = true, m_show_centered_bottom = true;
-
-        // Skeleton
-        omath::Color m_skel_color = omath::Color::from_rgba(255, 255, 255, 200);
-        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

examples/example_hud/main.cpp

@@ -1,8 +0,0 @@
-//
-// Created by orange on 13.03.2026.
-//
-#include "gui/main_window.hpp"
-int main()
-{
-    imgui_desktop::gui::MainWindow("omath::hud", 800, 600).Run();
-}

include/omath/3d_primitives/aabb.hpp

@@ -1,28 +0,0 @@
-//
-// Created by Vladislav on 24.03.2026.
-//
-
-#pragma once
-#include "omath/linear_algebra/vector3.hpp"
-
-namespace omath::primitives
-{
-    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);
-        }
-    };
-} // namespace omath::primitives

include/omath/algorithm/targeting.hpp

@@ -1,98 +0,0 @@
-//
-// 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,7 +3,6 @@
 //
 #pragma once
 
-#include "omath/3d_primitives/aabb.hpp"
 #include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
 
@@ -35,7 +34,6 @@ namespace omath::collision
     class LineTracer final
     {
         using TriangleType = Triangle<typename RayType::VectorType>;
-        using AABBType = primitives::Aabb<typename RayType::VectorType::ContainedType>;
 
     public:
         LineTracer() = delete;
@@ -89,54 +87,6 @@ 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/collision/physx_box_collider.hpp

@@ -0,0 +1,59 @@
+//
+// Created by orange-cpp
+//
+#pragma once
+
+#ifdef OMATH_ENABLE_PHYSX
+
+#include "collider_interface.hpp"
+#include <PxPhysicsAPI.h>
+
+namespace omath::collision
+{
+    /// Axis-aligned box collider backed by PhysX PxBoxGeometry.
+    /// Half-extents are stored in PhysX convention (positive values along each axis).
+    class PhysXBoxCollider final : public ColliderInterface<Vector3<float>>
+    {
+    public:
+        /// @param half_extents  Half-widths along X, Y and Z axes (all must be > 0).
+        /// @param origin        World-space centre of the box.
+        explicit PhysXBoxCollider(const VectorType& half_extents, const VectorType& origin = {})
+            : m_geometry(physx::PxVec3(half_extents.x, half_extents.y, half_extents.z))
+            , m_origin(origin)
+        {
+        }
+
+        /// Support function: returns the world-space point on the box furthest in @p direction.
+        /// For a box, the furthest point along d is origin + (sign(d.x)*hx, sign(d.y)*hy, sign(d.z)*hz).
+        [[nodiscard]]
+        VectorType find_abs_furthest_vertex_position(const VectorType& direction) const override
+        {
+            const auto& he = m_geometry.halfExtents;
+            return {
+                m_origin.x + (direction.x >= 0.f ? he.x : -he.x),
+                m_origin.y + (direction.y >= 0.f ? he.y : -he.y),
+                m_origin.z + (direction.z >= 0.f ? he.z : -he.z),
+            };
+        }
+
+        [[nodiscard]]
+        const VectorType& get_origin() const override { return m_origin; }
+
+        void set_origin(const VectorType& new_origin) override { m_origin = new_origin; }
+
+        [[nodiscard]]
+        const physx::PxBoxGeometry& get_geometry() const { return m_geometry; }
+
+        /// Update half-extents at runtime.
+        void set_half_extents(const VectorType& half_extents)
+        {
+            m_geometry = physx::PxBoxGeometry(physx::PxVec3(half_extents.x, half_extents.y, half_extents.z));
+        }
+
+    private:
+        physx::PxBoxGeometry m_geometry;
+        VectorType m_origin;
+    };
+} // namespace omath::collision
+
+#endif // OMATH_ENABLE_PHYSX

include/omath/collision/physx_rigid_body.hpp

@@ -0,0 +1,137 @@
+//
+// Created by orange-cpp
+//
+#pragma once
+
+#ifdef OMATH_ENABLE_PHYSX
+
+#include "collider_interface.hpp"
+#include "physx_world.hpp"
+#include <PxPhysicsAPI.h>
+#include <extensions/PxRigidBodyExt.h>
+#include <cmath>
+
+namespace omath::collision
+{
+    /// Dynamic rigid body backed by a PhysX PxRigidDynamic actor.
+    /// Implements ColliderInterface so it can participate in both omath GJK
+    /// and PhysX simulation-based collision resolution.
+    ///
+    /// Ownership: the actor is added to the world's scene on construction
+    /// and removed + released on destruction.
+    class PhysXRigidBody final : public ColliderInterface<Vector3<float>>
+    {
+    public:
+        /// @param world     PhysXWorld that owns the scene.
+        /// @param geometry  Shape geometry (PxBoxGeometry, PxSphereGeometry, …).
+        /// @param origin    Initial world-space position.
+        /// @param density   Mass density used to compute mass and inertia.
+        PhysXRigidBody(PhysXWorld& world, const physx::PxGeometry& geometry,
+                       const VectorType& origin = {}, float density = 1.f)
+            : m_world(world)
+            , m_geometry(geometry)
+        {
+            const physx::PxTransform pose(physx::PxVec3(origin.x, origin.y, origin.z));
+            m_actor = world.get_physics().createRigidDynamic(pose);
+
+            physx::PxShape* shape = world.get_physics().createShape(
+                geometry, world.get_default_material(), true);
+            m_actor->attachShape(*shape);
+            shape->release();
+
+            physx::PxRigidBodyExt::updateMassAndInertia(*m_actor, density);
+            world.get_scene().addActor(*m_actor);
+        }
+
+        ~PhysXRigidBody() override
+        {
+            m_world.get_scene().removeActor(*m_actor);
+            m_actor->release();
+        }
+
+        PhysXRigidBody(const PhysXRigidBody&)            = delete;
+        PhysXRigidBody& operator=(const PhysXRigidBody&) = delete;
+
+        // ── ColliderInterface ────────────────────────────────────────────────
+
+        /// Support function — delegates to the stored geometry type so the body
+        /// can be used with omath GJK alongside the non-simulated colliders.
+        [[nodiscard]]
+        VectorType find_abs_furthest_vertex_position(const VectorType& direction) const override
+        {
+            const VectorType o = get_origin();
+            switch (m_geometry.getType())
+            {
+                case physx::PxGeometryType::eBOX:
+                {
+                    const auto& he = m_geometry.box().halfExtents;
+                    return {
+                        o.x + (direction.x >= 0.f ? he.x : -he.x),
+                        o.y + (direction.y >= 0.f ? he.y : -he.y),
+                        o.z + (direction.z >= 0.f ? he.z : -he.z),
+                    };
+                }
+                case physx::PxGeometryType::eSPHERE:
+                {
+                    const float r   = m_geometry.sphere().radius;
+                    const float len = std::sqrt(direction.x * direction.x +
+                                               direction.y * direction.y +
+                                               direction.z * direction.z);
+                    if (len == 0.f)
+                        return o;
+                    const float inv = r / len;
+                    return { o.x + direction.x * inv,
+                             o.y + direction.y * inv,
+                             o.z + direction.z * inv };
+                }
+                default:
+                    return o; // unsupported geometry — return centre
+            }
+        }
+
+        [[nodiscard]]
+        const VectorType& get_origin() const override
+        {
+            const auto& p = m_actor->getGlobalPose().p;
+            m_cached_origin = { p.x, p.y, p.z };
+            return m_cached_origin;
+        }
+
+        void set_origin(const VectorType& new_origin) override
+        {
+            physx::PxTransform pose = m_actor->getGlobalPose();
+            pose.p = physx::PxVec3(new_origin.x, new_origin.y, new_origin.z);
+            m_actor->setGlobalPose(pose);
+        }
+
+        // ── PhysX-specific API ───────────────────────────────────────────────
+
+        [[nodiscard]] physx::PxRigidDynamic& get_actor() { return *m_actor; }
+        [[nodiscard]] const physx::PxRigidDynamic& get_actor() const { return *m_actor; }
+
+        void set_linear_velocity(const VectorType& v)
+        {
+            m_actor->setLinearVelocity(physx::PxVec3(v.x, v.y, v.z));
+        }
+
+        [[nodiscard]]
+        VectorType get_linear_velocity() const
+        {
+            const auto& v = m_actor->getLinearVelocity();
+            return { v.x, v.y, v.z };
+        }
+
+        void set_kinematic(bool enabled)
+        {
+            m_actor->setRigidBodyFlag(physx::PxRigidBodyFlag::eKINEMATIC, enabled);
+        }
+
+    private:
+        PhysXWorld&                    m_world;
+        physx::PxGeometryHolder        m_geometry;
+        physx::PxRigidDynamic*         m_actor{nullptr};
+        mutable VectorType             m_cached_origin{};
+    };
+} // namespace omath::collision
+
+#endif // OMATH_ENABLE_PHYSX

include/omath/collision/physx_sphere_collider.hpp

@@ -0,0 +1,64 @@
+//
+// Created by orange-cpp
+//
+#pragma once
+
+#ifdef OMATH_ENABLE_PHYSX
+
+#include "collider_interface.hpp"
+#include <PxPhysicsAPI.h>
+#include <cmath>
+
+namespace omath::collision
+{
+    /// Sphere collider backed by PhysX PxSphereGeometry.
+    class PhysXSphereCollider final : public ColliderInterface<Vector3<float>>
+    {
+    public:
+        /// @param radius  Sphere radius (must be > 0).
+        /// @param origin  World-space centre of the sphere.
+        explicit PhysXSphereCollider(float radius, const VectorType& origin = {})
+            : m_geometry(radius)
+            , m_origin(origin)
+        {
+        }
+
+        /// Support function: returns the world-space point on the sphere furthest in @p direction.
+        /// For a sphere that is simply origin + normalize(direction) * radius.
+        [[nodiscard]]
+        VectorType find_abs_furthest_vertex_position(const VectorType& direction) const override
+        {
+            const float len = std::sqrt(direction.x * direction.x +
+                                        direction.y * direction.y +
+                                        direction.z * direction.z);
+            if (len == 0.f)
+                return m_origin;
+
+            const float inv = m_geometry.radius / len;
+            return {
+                m_origin.x + direction.x * inv,
+                m_origin.y + direction.y * inv,
+                m_origin.z + direction.z * inv,
+            };
+        }
+
+        [[nodiscard]]
+        const VectorType& get_origin() const override { return m_origin; }
+
+        void set_origin(const VectorType& new_origin) override { m_origin = new_origin; }
+
+        [[nodiscard]]
+        const physx::PxSphereGeometry& get_geometry() const { return m_geometry; }
+
+        [[nodiscard]]
+        float get_radius() const { return m_geometry.radius; }
+
+        void set_radius(float radius) { m_geometry = physx::PxSphereGeometry(radius); }
+
+    private:
+        physx::PxSphereGeometry m_geometry;
+        VectorType m_origin;
+    };
+} // namespace omath::collision
+
+#endif // OMATH_ENABLE_PHYSX

include/omath/collision/physx_world.hpp

@@ -0,0 +1,82 @@
+//
+// Created by orange-cpp
+//
+#pragma once
+
+#ifdef OMATH_ENABLE_PHYSX
+
+#include <PxPhysicsAPI.h>
+
+namespace omath::collision
+{
+    /// RAII owner of a PhysX Foundation + Physics + Scene.
+    /// One world per simulation context; not copyable or movable.
+    class PhysXWorld final
+    {
+    public:
+        explicit PhysXWorld(physx::PxVec3 gravity = {0.f, -9.81f, 0.f},
+                            physx::PxU32 cpu_threads = 2)
+        {
+            m_foundation = PxCreateFoundation(PX_PHYSICS_VERSION, m_allocator, m_error_callback);
+
+            m_physics = PxCreatePhysics(PX_PHYSICS_VERSION, *m_foundation,
+                                        physx::PxTolerancesScale{});
+
+            physx::PxSceneDesc desc(m_physics->getTolerancesScale());
+            desc.gravity       = gravity;
+            desc.cpuDispatcher = physx::PxDefaultCpuDispatcherCreate(cpu_threads);
+            m_dispatcher       = static_cast<physx::PxDefaultCpuDispatcher*>(desc.cpuDispatcher);
+            desc.filterShader  = physx::PxDefaultSimulationFilterShader;
+
+            m_scene = m_physics->createScene(desc);
+
+            // Default material: static friction 0.5, dynamic friction 0.5, restitution 0.
+            m_default_material = m_physics->createMaterial(0.5f, 0.5f, 0.f);
+        }
+
+        ~PhysXWorld()
+        {
+            m_scene->release();
+            m_dispatcher->release();
+            m_default_material->release();
+            m_physics->release();
+            m_foundation->release();
+        }
+
+        PhysXWorld(const PhysXWorld&)            = delete;
+        PhysXWorld& operator=(const PhysXWorld&) = delete;
+
+        /// Advance the simulation by @p dt seconds and block until results are ready.
+        void step(float dt)
+        {
+            m_scene->simulate(dt);
+            m_scene->fetchResults(true);
+        }
+
+        [[nodiscard]] physx::PxPhysics&  get_physics()          { return *m_physics;          }
+        [[nodiscard]] physx::PxScene&    get_scene()             { return *m_scene;             }
+        [[nodiscard]] physx::PxMaterial& get_default_material()  { return *m_default_material;  }
+
+        /// Add an infinite static ground plane at y = @p y_level facing +Y.
+        physx::PxRigidStatic* add_ground_plane(float y_level = 0.f)
+        {
+            physx::PxRigidStatic* plane = PxCreatePlane(
+                *m_physics,
+                physx::PxPlane(0.f, 1.f, 0.f, -y_level),
+                *m_default_material);
+            m_scene->addActor(*plane);
+            return plane;
+        }
+
+    private:
+        physx::PxDefaultAllocator      m_allocator{};
+        physx::PxDefaultErrorCallback  m_error_callback{};
+        physx::PxFoundation*           m_foundation{nullptr};
+        physx::PxPhysics*              m_physics{nullptr};
+        physx::PxDefaultCpuDispatcher* m_dispatcher{nullptr};
+        physx::PxScene*                m_scene{nullptr};
+        physx::PxMaterial*             m_default_material{nullptr};
+    };
+} // namespace omath::collision
+
+#endif // OMATH_ENABLE_PHYSX

include/omath/engines/cry_engine/camera.hpp

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

include/omath/engines/cry_engine/formulas.hpp

@@ -22,8 +22,7 @@ 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,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) 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, NDCDepthRange ndc_depth_range) noexcept;
+                                             float near, float far) noexcept;
     };
 
 } // namespace omath::cry_engine

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

@@ -16,8 +16,7 @@ namespace omath::cry_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
-            auto current_pos = launch_pos
+            auto current_pos = projectile.m_origin
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/engines/frostbite_engine/camera.hpp

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

include/omath/engines/frostbite_engine/formulas.hpp

@@ -22,8 +22,7 @@ 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,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) 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, NDCDepthRange ndc_depth_range) noexcept;
+                                             float near, float far) noexcept;
     };
 
 } // namespace omath::unreal_engine

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

@@ -16,8 +16,7 @@ namespace omath::frostbite_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
-            auto current_pos = launch_pos
+            auto current_pos = projectile.m_origin
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/engines/iw_engine/camera.hpp

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

include/omath/engines/iw_engine/formulas.hpp

@@ -22,8 +22,7 @@ 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,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) 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, NDCDepthRange ndc_depth_range) noexcept;
+                                             float near, float far) noexcept;
     };
 
 } // namespace omath::iw_engine

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

@@ -17,8 +17,7 @@ namespace omath::iw_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
-            auto current_pos = launch_pos
+            auto current_pos = projectile.m_origin
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/engines/opengl_engine/camera.hpp

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

include/omath/engines/opengl_engine/formulas.hpp

@@ -21,8 +21,7 @@ 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,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) 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, NDCDepthRange ndc_depth_range) noexcept;
+                                             float near, float far) noexcept;
     };
 
 } // namespace omath::opengl_engine

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

@@ -16,8 +16,7 @@ namespace omath::opengl_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
-            auto current_pos = launch_pos
+            auto current_pos = projectile.m_origin
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

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, NDCDepthRange::ZERO_TO_ONE>;
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
 } // namespace omath::source_engine

include/omath/engines/source_engine/formulas.hpp

@@ -21,8 +21,7 @@ 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,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) 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, NDCDepthRange ndc_depth_range) noexcept;
+                                             float near, float far) noexcept;
     };
 
 } // namespace omath::source_engine

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

@@ -17,8 +17,7 @@ namespace omath::source_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
-            auto current_pos = launch_pos
+            auto current_pos = projectile.m_origin
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/engines/unity_engine/camera.hpp

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

include/omath/engines/unity_engine/formulas.hpp

@@ -22,8 +22,7 @@ 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,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) 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, NDCDepthRange ndc_depth_range) noexcept;
+                                             float near, float far) noexcept;
     };
 
 } // namespace omath::unity_engine

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

@@ -16,8 +16,7 @@ namespace omath::unity_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
-            auto current_pos = launch_pos
+            auto current_pos = projectile.m_origin
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/engines/unreal_engine/camera.hpp

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

include/omath/engines/unreal_engine/formulas.hpp

@@ -22,8 +22,7 @@ namespace omath::unreal_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,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>

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

@@ -18,7 +18,7 @@ namespace omath::unreal_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, NDCDepthRange ndc_depth_range) noexcept;
+                                             float near, float far) noexcept;
     };
 
 } // namespace omath::unreal_engine

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

@@ -16,8 +16,7 @@ namespace omath::unreal_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
-            auto current_pos = launch_pos
+            auto current_pos = projectile.m_origin
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/hud/canvas_box.hpp

@@ -1,23 +0,0 @@
-//
-// Created by orange on 13.03.2026.
-//
-#pragma once
-#include "omath/linear_algebra/vector2.hpp"
-#include <array>
-namespace omath::hud
-{
-    class CanvasBox final
-    {
-    public:
-        CanvasBox(Vector2<float> top, Vector2<float> bottom, float ratio = 4.f);
-
-        [[nodiscard]]
-        std::array<Vector2<float>, 4> as_array() const;
-
-        Vector2<float> top_left_corner;
-        Vector2<float> top_right_corner;
-
-        Vector2<float> bottom_left_corner;
-        Vector2<float> bottom_right_corner;
-    };
-} // namespace omath::hud

include/omath/hud/entity_overlay.hpp

@@ -1,202 +0,0 @@
-//
-// Created by orange on 13.03.2026.
-//
-#pragma once
-#include "canvas_box.hpp"
-#include "entity_overlay_widgets.hpp"
-#include "hud_renderer_interface.hpp"
-#include "omath/linear_algebra/vector2.hpp"
-#include "omath/utility/color.hpp"
-#include <memory>
-#include <string_view>
-
-namespace omath::hud
-{
-    class EntityOverlay final
-    {
-    public:
-        EntityOverlay(const Vector2<float>& top, const Vector2<float>& bottom,
-                      const std::shared_ptr<HudRendererInterface>& renderer);
-
-        // ── Boxes ────────────────────────────────────────────────────────
-        EntityOverlay& add_2d_box(const Color& box_color, const Color& fill_color = Color{0.f, 0.f, 0.f, 0.f},
-                                  float thickness = 1.f);
-
-        EntityOverlay& add_cornered_2d_box(const Color& box_color, const Color& fill_color = Color{0.f, 0.f, 0.f, 0.f},
-                                           float corner_ratio_len = 0.2f, float thickness = 1.f);
-
-        EntityOverlay& add_dashed_box(const Color& color, float dash_len = 8.f, float gap_len = 5.f,
-                                      float thickness = 1.f);
-
-        // ── Bars ─────────────────────────────────────────────────────────
-        EntityOverlay& add_right_bar(const Color& color, const Color& outline_color, const Color& bg_color, float width,
-                                     float ratio, float offset = 5.f);
-
-        EntityOverlay& add_left_bar(const Color& color, const Color& outline_color, const Color& bg_color, float width,
-                                    float ratio, float offset = 5.f);
-
-        EntityOverlay& add_top_bar(const Color& color, const Color& outline_color, const Color& bg_color, float height,
-                                   float ratio, float offset = 5.f);
-
-        EntityOverlay& add_bottom_bar(const Color& color, const Color& outline_color, const Color& bg_color,
-                                      float height, float ratio, float offset = 5.f);
-
-        EntityOverlay& add_right_dashed_bar(const Color& color, const Color& outline_color, const Color& bg_color,
-                                            float width, float ratio, float dash_len, float gap_len,
-                                            float offset = 5.f);
-
-        EntityOverlay& add_left_dashed_bar(const Color& color, const Color& outline_color, const Color& bg_color,
-                                           float width, float ratio, float dash_len, float gap_len, float offset = 5.f);
-
-        EntityOverlay& add_top_dashed_bar(const Color& color, const Color& outline_color, const Color& bg_color,
-                                          float height, float ratio, float dash_len, float gap_len, float offset = 5.f);
-
-        EntityOverlay& add_bottom_dashed_bar(const Color& color, const Color& outline_color, const Color& bg_color,
-                                             float height, float ratio, float dash_len, float gap_len,
-                                             float offset = 5.f);
-
-        // ── Labels ───────────────────────────────────────────────────────
-        EntityOverlay& add_right_label(const Color& color, float offset, bool outlined, const std::string_view& text);
-
-        EntityOverlay& add_left_label(const Color& color, float offset, bool outlined, const std::string_view& text);
-
-        EntityOverlay& add_top_label(const Color& color, float offset, bool outlined, std::string_view text);
-
-        EntityOverlay& add_bottom_label(const Color& color, float offset, bool outlined, std::string_view text);
-
-        EntityOverlay& add_centered_top_label(const Color& color, float offset, bool outlined,
-                                              const std::string_view& text);
-
-        EntityOverlay& add_centered_bottom_label(const Color& color, float offset, bool outlined,
-                                                 const std::string_view& text);
-
-        template<typename... Args>
-        EntityOverlay& add_right_label(const Color& color, const float offset, const bool outlined, std::format_string<Args...> fmt,
-                                       Args&&... args)
-        {
-            return add_right_label(color, offset, outlined,
-                                   std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
-        }
-
-        template<typename... Args>
-        EntityOverlay& add_left_label(const Color& color, const float offset, const bool outlined, std::format_string<Args...> fmt,
-                                      Args&&... args)
-        {
-            return add_left_label(color, offset, outlined,
-                                  std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
-        }
-
-        template<typename... Args>
-        EntityOverlay& add_top_label(const Color& color, const float offset, const bool outlined, std::format_string<Args...> fmt,
-                                     Args&&... args)
-        {
-            return add_top_label(color, offset, outlined,
-                                 std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
-        }
-
-        template<typename... Args>
-        EntityOverlay& add_bottom_label(const Color& color, const float offset, const bool outlined,
-                                        std::format_string<Args...> fmt, Args&&... args)
-        {
-            return add_bottom_label(color, offset, outlined,
-                                    std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
-        }
-
-        template<typename... Args>
-        EntityOverlay& add_centered_top_label(const Color& color, const float offset, const bool outlined,
-                                              std::format_string<Args...> fmt, Args&&... args)
-        {
-            return add_centered_top_label(color, offset, outlined,
-                                          std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
-        }
-
-        template<typename... Args>
-        EntityOverlay& add_centered_bottom_label(const Color& color, const float offset, const bool outlined,
-                                                 std::format_string<Args...> fmt, Args&&... args)
-        {
-            return add_centered_bottom_label(color, offset, outlined,
-                                             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);
-
-        EntityOverlay& add_skeleton(const Color& color, float thickness = 1.f);
-
-        // ── Declarative interface ─────────────────────────────────────────
-        /// Pass any combination of widget:: descriptor structs (and std::optional<W>
-        /// from when()) to render them all in declaration order.
-        template<typename... Widgets>
-        EntityOverlay& contents(Widgets&&... widgets)
-        {
-            (dispatch(std::forward<Widgets>(widgets)), ...);
-            return *this;
-        }
-
-    private:
-        // optional<W> dispatch — enables when() conditional widgets
-        template<typename W>
-        void dispatch(const std::optional<W>& w)
-        {
-            if (w)
-                dispatch(*w);
-        }
-
-        void dispatch(const widget::Box& box);
-        void dispatch(const widget::CorneredBox& cornered_box);
-        void dispatch(const widget::DashedBox& dashed_box);
-        void dispatch(const widget::RightSide& right_side);
-        void dispatch(const widget::LeftSide& left_side);
-        void dispatch(const widget::TopSide& top_side);
-        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;
-        void draw_dashed_fill(const Vector2<float>& origin, const Vector2<float>& step_dir,
-                              const Vector2<float>& perp_dir, float full_len, float filled_len, const Color& fill_color,
-                              const Color& split_color, float dash_len, float gap_len) const;
-
-        CanvasBox m_canvas;
-        Vector2<float> m_text_cursor_right;
-        Vector2<float> m_text_cursor_top;
-        Vector2<float> m_text_cursor_bottom;
-        Vector2<float> m_text_cursor_left;
-        std::shared_ptr<HudRendererInterface> m_renderer;
-    };
-} // namespace omath::hud

include/omath/hud/entity_overlay_widgets.hpp

@@ -1,233 +0,0 @@
-//
-// Created by orange on 15.03.2026.
-//
-#pragma once
-#include "omath/linear_algebra/vector2.hpp"
-#include "omath/utility/color.hpp"
-#include <any>
-#include <initializer_list>
-#include <optional>
-#include <string_view>
-#include <variant>
-
-namespace omath::hud::widget
-{
-    // ── Overloaded helper for std::visit ──────────────────────────────────────
-    template<typename... Ts>
-    struct Overloaded : Ts...
-    {
-        using Ts::operator()...;
-    };
-    template<typename... Ts>
-    Overloaded(Ts...) -> Overloaded<Ts...>;
-
-    // ── Standalone widgets ────────────────────────────────────────────────────
-    struct Box
-    {
-        Color color;
-        Color fill{0.f, 0.f, 0.f, 0.f};
-        float thickness = 1.f;
-    };
-
-    struct CorneredBox
-    {
-        Color color;
-        Color fill{0.f, 0.f, 0.f, 0.f};
-        float corner_ratio = 0.2f;
-        float thickness = 1.f;
-    };
-
-    struct DashedBox
-    {
-        Color color;
-        float dash_len = 8.f;
-        float gap_len = 5.f;
-        float thickness = 1.f;
-    };
-
-    struct Skeleton
-    {
-        Color color;
-        float thickness = 1.f;
-    };
-    struct SnapLine
-    {
-        Vector2<float> start;
-        Color color;
-        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.
-    struct Bar
-    {
-        Color color;
-        Color outline;
-        Color bg;
-        float size;
-        float ratio;
-        float offset = 5.f;
-    };
-
-    /// A dashed bar. Same field semantics as Bar plus dash parameters.
-    struct DashedBar
-    {
-        Color color;
-        Color outline;
-        Color bg;
-        float size;
-        float ratio;
-        float dash_len;
-        float gap_len;
-        float offset = 5.f;
-    };
-
-    struct Label
-    {
-        Color color;
-        float offset;
-        bool outlined;
-        std::string_view text;
-    };
-
-    /// Wraps a Label to request horizontal centering (only applied in TopSide / BottomSide).
-    template<typename W>
-    struct Centered
-    {
-        W child;
-    };
-    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>, SpaceVertical, SpaceHorizontal, ProgressRing, Icon>;
-
-    // ── Side containers ───────────────────────────────────────────────────────
-    // Storing std::initializer_list<SideWidget> is safe here: the backing array
-    // is a const SideWidget[] on the caller's stack whose lifetime matches the
-    // temporary side-container object, which is consumed within the same
-    // full-expression by EntityOverlay::dispatch. No heap allocation occurs.
-
-    struct RightSide
-    {
-        std::initializer_list<SideWidget> children;
-        RightSide(const std::initializer_list<SideWidget> c): children(c)
-        {
-        }
-    };
-    struct LeftSide
-    {
-        std::initializer_list<SideWidget> children;
-        LeftSide(const std::initializer_list<SideWidget> c): children(c)
-        {
-        }
-    };
-    struct TopSide
-    {
-        std::initializer_list<SideWidget> children;
-        TopSide(const std::initializer_list<SideWidget> c): children(c)
-        {
-        }
-    };
-    struct BottomSide
-    {
-        std::initializer_list<SideWidget> children;
-        BottomSide(const std::initializer_list<SideWidget> c): children(c)
-        {
-        }
-    };
-
-} // namespace omath::hud::widget
-
-namespace omath::hud::widget
-{
-    /// Inside XxxSide containers: returns the widget as a SideWidget when condition is true,
-    /// or None{} otherwise. Preferred over hud::when for types inside the SideWidget variant.
-    template<typename W>
-    requires std::constructible_from<SideWidget, W>
-    SideWidget when(const bool condition, W widget)
-    {
-        if (condition)
-            return SideWidget{std::move(widget)};
-        return None{};
-    }
-} // namespace omath::hud::widget
-
-namespace omath::hud
-{
-    /// Top-level: returns an engaged optional<W> when condition is true, std::nullopt otherwise.
-    /// Designed for use with EntityOverlay::contents() for top-level widget types.
-    template<typename W>
-    std::optional<W> when(const bool condition, W widget)
-    {
-        if (condition)
-            return std::move(widget);
-        return std::nullopt;
-    }
-} // namespace omath::hud

include/omath/hud/hud_renderer_interface.hpp

@@ -1,47 +0,0 @@
-//
-// Created by orange on 13.03.2026.
-//
-#pragma once
-#include "omath/linear_algebra/vector2.hpp"
-#include "omath/utility/color.hpp"
-#include <any>
-#include <span>
-
-namespace omath::hud
-{
-    class HudRendererInterface
-    {
-    public:
-        virtual ~HudRendererInterface() = default;
-        virtual void add_line(const Vector2<float>& line_start, const Vector2<float>& line_end, const Color& color,
-                              float thickness) = 0;
-
-        virtual void add_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color,
-                                  float thickness) = 0;
-
-        virtual void add_filled_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color) = 0;
-
-        virtual void add_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) = 0;
-
-        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]]
-        virtual Vector2<float> calc_text_size(const std::string_view& text) = 0;
-    };
-} // namespace omath::hud

include/omath/hud/renderer_realizations/imgui_renderer.hpp

@@ -1,33 +0,0 @@
-//
-// Created by orange on 13.03.2026.
-//
-#pragma once
-#include <omath/hud/hud_renderer_interface.hpp>
-
-#ifdef OMATH_IMGUI_INTEGRATION
-namespace omath::hud
-{
-    class ImguiHudRenderer final : public HudRendererInterface
-    {
-    public:
-        ~ImguiHudRenderer() override;
-        void add_line(const Vector2<float>& line_start, const Vector2<float>& line_end, const Color& color,
-                      float thickness) override;
-        void add_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color, float thickness) override;
-        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;
-    };
-} // namespace omath::hud
-#endif // OMATH_IMGUI_INTEGRATION

include/omath/linear_algebra/mat.hpp

@@ -37,12 +37,6 @@ 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);
@@ -664,98 +658,56 @@ namespace omath
         } * mat_translation<Type, St>(-camera_origin);
     }
 
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
-             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
     Mat<4, 4, Type, St> mat_perspective_left_handed(const float field_of_view, const float aspect_ratio,
                                                     const float near, const float far) noexcept
     {
         const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
 
-        if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
-                    {0.f, 1.f / fov_half_tan, 0.f, 0.f},
-                    {0.f, 0.f, far / (far - near), -(near * far) / (far - near)},
-                    {0.f, 0.f, 1.f, 0.f}};
-        else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
-                    {0.f, 1.f / fov_half_tan, 0.f, 0.f},
-                    {0.f, 0.f, (far + near) / (far - near), -(2.f * near * far) / (far - near)},
-                    {0.f, 0.f, 1.f, 0.f}};
-        else
-            std::unreachable();
+        return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
+                {0.f, 1.f / fov_half_tan, 0.f, 0.f},
+                {0.f, 0.f, (far + near) / (far - near), -(2.f * near * far) / (far - near)},
+                {0.f, 0.f, 1.f, 0.f}};
     }
 
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
-             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
     Mat<4, 4, Type, St> mat_perspective_right_handed(const float field_of_view, const float aspect_ratio,
                                                      const float near, const float far) noexcept
     {
         const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
 
-        if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
-                    {0.f, 1.f / fov_half_tan, 0.f, 0.f},
-                    {0.f, 0.f, -far / (far - near), -(near * far) / (far - near)},
-                    {0.f, 0.f, -1.f, 0.f}};
-        else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
-                    {0.f, 1.f / fov_half_tan, 0.f, 0.f},
-                    {0.f, 0.f, -(far + near) / (far - near), -(2.f * near * far) / (far - near)},
-                    {0.f, 0.f, -1.f, 0.f}};
-        else
-            std::unreachable();
+        return {{1.f / (aspect_ratio * fov_half_tan), 0.f, 0.f, 0.f},
+                {0.f, 1.f / fov_half_tan, 0.f, 0.f},
+                {0.f, 0.f, -(far + near) / (far - near), -(2.f * near * far) / (far - near)},
+                {0.f, 0.f, -1.f, 0.f}};
     }
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
-             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
     Mat<4, 4, Type, St> mat_ortho_left_handed(const Type left, const Type right, const Type bottom, const Type top,
                                               const Type near, const Type far) noexcept
     {
-        if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return
-            {
-                { static_cast<Type>(2) / (right - left), 0.f,       0.f,    -(right + left) / (right - left)},
-                { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,    -(top + bottom) / (top - bottom)},
-                { 0.f,      0.f,       static_cast<Type>(1) / (far - near), -near / (far - near)            },
-                { 0.f,      0.f,       0.f,                                 1.f                             }
-            };
-        else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return
-            {
-                { static_cast<Type>(2) / (right - left), 0.f,       0.f,    -(right + left) / (right - left)},
-                { 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();
+        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                             }
+        };
     }
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
-             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard]]
     Mat<4, 4, Type, St> mat_ortho_right_handed(const Type left, const Type right, const Type bottom, const Type top,
                                                const Type near, const Type far) noexcept
     {
-        if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return
-            {
-                    { static_cast<Type>(2) / (right - left), 0.f,       0.f,     -(right + left) / (right - left)},
-                    { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,     -(top + bottom) / (top - bottom)},
-                    { 0.f,      0.f,       -static_cast<Type>(1) / (far - near), -near / (far - near)            },
-                    { 0.f,      0.f,       0.f,                                  1.f                             }
-            };
-        else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return
-            {
-                    { static_cast<Type>(2) / (right - left), 0.f,       0.f,     -(right + left) / (right - left)},
-                    { 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();
+        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                             }
+        };
     }
     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/pathfinding/walk_bot.hpp

@@ -1,46 +0,0 @@
-//
-// 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,23 +8,12 @@
 
 namespace omath::projectile_prediction
 {
-    struct AimAngles
-    {
-        float pitch{};
-        float yaw{};
-    };
-
     class ProjPredEngineInterface
     {
     public:
         [[nodiscard]]
         virtual std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
                                                                         const Target& target) const = 0;
-
-        [[nodiscard]]
-        virtual std::optional<AimAngles> maybe_calculate_aim_angles(const Projectile& projectile,
-                                                                     const Target& target) const = 0;
-
         virtual ~ProjPredEngineInterface() = default;
     };
 } // namespace omath::projectile_prediction

include/omath/projectile_prediction/proj_pred_engine_avx2.hpp

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

include/omath/projectile_prediction/proj_pred_engine_legacy.hpp

@@ -54,36 +54,6 @@ namespace omath::projectile_prediction
         [[nodiscard]]
         std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
                                                                 const Target& target) const override
-        {
-            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> maybe_calculate_aim_angles(const Projectile& projectile,
-                                                             const Target& 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{solution->pitch, yaw};
-        }
-
-    private:
-        struct Solution
-        {
-            Vector3<float> predicted_target_position;
-            float pitch;
-        };
-
-        [[nodiscard]]
-        std::optional<Solution> find_solution(const Projectile& projectile, const Target& target) const
         {
             for (float time = 0.f; time < m_maximum_simulation_time; time += m_simulation_time_step)
             {
@@ -100,11 +70,12 @@ namespace omath::projectile_prediction
                                                   time))
                     continue;
 
-                return Solution{predicted_target_position, projectile_pitch.value()};
+                return EngineTrait::calc_viewpoint_from_angles(projectile, predicted_target_position, projectile_pitch);
             }
             return std::nullopt;
         }
 
+    private:
         const float m_gravity_constant;
         const float m_simulation_time_step;
         const float m_maximum_simulation_time;
@@ -129,12 +100,10 @@ namespace omath::projectile_prediction
         {
             const auto bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
 
-            const auto launch_origin = projectile.m_origin + projectile.m_launch_offset;
-
             if (bullet_gravity == 0.f)
-                return EngineTrait::calc_direct_pitch_angle(launch_origin, target_position);
+                return EngineTrait::calc_direct_pitch_angle(projectile.m_origin, target_position);
 
-            const auto delta = target_position - launch_origin;
+            const auto delta = target_position - projectile.m_origin;
 
             const auto distance2d = EngineTrait::calc_vector_2d_distance(delta);
             const auto distance2d_sqr = distance2d * distance2d;
@@ -157,7 +126,7 @@ namespace omath::projectile_prediction
         bool is_projectile_reached_target(const Vector3<float>& target_position, const Projectile& projectile,
                                           const float pitch, const float time) const noexcept
         {
-            const auto yaw = EngineTrait::calc_direct_yaw_angle(projectile.m_origin + projectile.m_launch_offset, target_position);
+            const auto yaw = EngineTrait::calc_direct_yaw_angle(projectile.m_origin, target_position);
             const auto projectile_position =
                     EngineTrait::predict_projectile_position(projectile, pitch, yaw, time, m_gravity_constant);
 

include/omath/projectile_prediction/projectile.hpp

@@ -11,7 +11,6 @@ namespace omath::projectile_prediction
     {
     public:
         Vector3<float> m_origin;
-        Vector3<float> m_launch_offset{0.f, 0.f, 0.f};
         float m_launch_speed{};
         float m_gravity_scale{};
     };

include/omath/projection/camera.hpp

@@ -4,7 +4,6 @@
 
 #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"
@@ -37,36 +36,23 @@ 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>
     concept CameraEngineConcept =
             requires(const Vector3<float>& cam_origin, const Vector3<float>& look_at, const ViewAnglesType& angles,
-                     const FieldOfView& fov, const ViewPort& viewport, float znear, float zfar,
-                     NDCDepthRange ndc_depth_range) {
+                     const FieldOfView& fov, const ViewPort& viewport, float znear, float zfar) {
                 // 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, ndc_depth_range) } -> std::same_as<MatType>;
+                { T::calc_projection_matrix(fov, viewport, znear, zfar) } -> std::same_as<MatType>;
 
                 // 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, ndc_depth_range));
+                requires noexcept(T::calc_projection_matrix(fov, viewport, znear, zfar));
             };
 
-    template<class Mat4X4Type, class ViewAnglesType, class TraitClass,
-             NDCDepthRange depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE,
-             CameraAxes axes = {}>
+    template<class Mat4X4Type, class ViewAnglesType, class TraitClass, bool inverted_z = false>
     requires CameraEngineConcept<TraitClass, Mat4X4Type, ViewAnglesType>
     class Camera final
     {
@@ -90,45 +76,19 @@ namespace omath::projection
         {
         }
 
-        [[nodiscard]]
-        static ViewAnglesType calc_view_angles_from_view_matrix(const Mat4X4Type& view_matrix) noexcept
-        {
-            Vector3<float> 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<float> 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<float>& target)
         {
             m_view_angles = TraitClass::calc_look_at_angle(m_origin, target);
             m_view_projection_matrix = std::nullopt;
             m_view_matrix = std::nullopt;
         }
-        [[nodiscard]]
-        ViewAnglesType calc_look_at_angles(const Vector3<float>& look_to) const
-        {
-            return TraitClass::calc_look_at_angle(m_origin, look_to);
-        }
 
         [[nodiscard]]
         Vector3<float> get_forward() const noexcept
         {
             const auto& view_matrix = get_view_matrix();
 
-            if constexpr (axes.inverted_forward)
+            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]};
         }
@@ -137,8 +97,6 @@ namespace omath::projection
         Vector3<float> get_right() const noexcept
         {
             const auto& view_matrix = get_view_matrix();
-            if constexpr (axes.inverted_right)
-                return -Vector3<float>{view_matrix[0, 0], view_matrix[0, 1], view_matrix[0, 2]};
             return {view_matrix[0, 0], view_matrix[0, 1], view_matrix[0, 2]};
         }
 
@@ -168,8 +126,7 @@ namespace omath::projection
         {
             if (!m_projection_matrix.has_value())
                 m_projection_matrix = TraitClass::calc_projection_matrix(m_field_of_view, m_view_port,
-                                                                         m_near_plane_distance, m_far_plane_distance,
-                                                                         depth_range);
+                                                                         m_near_plane_distance, m_far_plane_distance);
 
             return m_projection_matrix.value();
         }
@@ -181,16 +138,16 @@ namespace omath::projection
             m_projection_matrix = std::nullopt;
         }
 
-        void set_near_plane(const float near_plane) noexcept
+        void set_near_plane(const float near) noexcept
         {
-            m_near_plane_distance = near_plane;
+            m_near_plane_distance = near;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
 
-        void set_far_plane(const float far_plane) noexcept
+        void set_far_plane(const float far) noexcept
         {
-            m_far_plane_distance = far_plane;
+            m_far_plane_distance = far;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
@@ -256,22 +213,6 @@ namespace omath::projection
             else
                 std::unreachable();
         }
-        template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
-        [[nodiscard]] std::expected<Vector3<float>, Error>
-        world_to_screen_unclipped(const Vector3<float>& world_position) const noexcept
-        {
-            const auto normalized_cords = world_to_view_port(world_position, ViewPortClipping::MANUAL);
-
-            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<float>>& triangle) const noexcept
         {
@@ -305,127 +246,40 @@ namespace omath::projection
                 return a[axis] < -a[3] && b[axis] < -b[3] && c[axis] < -c[3];
             };
 
-            // Clip volume in clip space:
+            // Clip volume in clip space (OpenGL-style):
             // -w <= x <= w
             // -w <= y <= w
-            // z_min <= z <= w  (z_min = -w for [-1,1], 0 for [0,1])
+            // -w <= z <= w
 
-            // x and y planes
-            for (int i = 0; i < 2; i++)
+            for (int i = 0; i < 3; i++)
             {
                 if (all_outside_plane(i, c0, c1, c2, false))
-                    return true;
+                    return true; // x < -w (left)
                 if (all_outside_plane(i, c0, c1, c2, true))
-                    return true;
+                    return true; // x >  w (right)
             }
-
-            // 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]] bool is_aabb_culled_by_frustum(const primitives::Aabb<float>& aabb) 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
-            {
-                float a, b, c, d;
-            };
-
-            const auto extract_plane = [&m](const int sign, const int row) -> Plane
-            {
-                return {
-                        m.at(3, 0) + static_cast<float>(sign) * m.at(row, 0),
-                        m.at(3, 1) + static_cast<float>(sign) * m.at(row, 1),
-                        m.at(3, 2) + static_cast<float>(sign) * m.at(row, 2),
-                        m.at(3, 3) + static_cast<float>(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 float px = a >= 0.f ? aabb.max.x : aabb.min.x;
-                const float py = b >= 0.f ? aabb.max.y : aabb.min.y;
-                const float pz = c >= 0.f ? aabb.max.z : aabb.min.z;
-
-                if (a * px + b * py + c * pz + d < 0.f)
-                    return true;
-            }
-
             return false;
         }
 
         [[nodiscard]] std::expected<Vector3<float>, Error>
-        world_to_view_port(const Vector3<float>& world_position,
-                           const ViewPortClipping& clipping = ViewPortClipping::AUTO) const noexcept
+        world_to_view_port(const Vector3<float>& world_position) const noexcept
         {
             auto projected = get_view_projection_matrix()
                              * mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(world_position);
 
             const auto& w = projected.at(3, 0);
-            constexpr auto eps = std::numeric_limits<float>::epsilon();
-            if (w <= eps)
-                return std::unexpected(Error::PERSPECTIVE_DIVIDER_LESS_EQ_ZERO);
+            if (w <= std::numeric_limits<float>::epsilon())
+                return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
             projected /= w;
 
-            // 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);
-
-            // ReSharper disable once CppTooWideScope
-            constexpr auto z_min = depth_range == NDCDepthRange::ZERO_TO_ONE ? 0.0f : -1.0f;
-            const auto clipped_manually = clipping == ViewPortClipping::MANUAL && (projected.at(2, 0) < z_min - eps
-                                          || projected.at(2, 0) > 1.0f + eps);
-            if (clipped_manually)
+            if (is_ndc_out_of_bounds(projected))
                 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)};
         }
         [[nodiscard]]
-        std::expected<Vector3<float>, Error> view_port_to_world(const Vector3<float>& ndc) const noexcept
+        std::expected<Vector3<float>, Error> view_port_to_screen(const Vector3<float>& ndc) const noexcept
         {
             const auto inv_view_proj = get_view_projection_matrix().inverted();
 
@@ -450,7 +304,7 @@ namespace omath::projection
         [[nodiscard]]
         std::expected<Vector3<float>, Error> screen_to_world(const Vector3<float>& screen_pos) const noexcept
         {
-            return view_port_to_world(screen_to_ndc<screen_start>(screen_pos));
+            return view_port_to_screen(screen_to_ndc<screen_start>(screen_pos));
         }
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
@@ -479,26 +333,8 @@ namespace omath::projection
         [[nodiscard]] constexpr static bool is_ndc_out_of_bounds(const Type& ndc) noexcept
         {
             constexpr auto eps = std::numeric_limits<float>::epsilon();
-
-            const auto& data = ndc.raw_array();
-            // x and y are always in [-1, 1]
-            if (data[0] < -1.0f - eps || data[0] > 1.0f + eps)
-                return true;
-            if (data[1] < -1.0f - eps || data[1] > 1.0f + 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<float>::epsilon();
-            if constexpr (depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-                return z_ndc < -1.0f - eps || z_ndc > 1.0f + eps;
-            if constexpr (depth_range == NDCDepthRange::ZERO_TO_ONE)
-                return z_ndc < 0.0f - eps || z_ndc > 1.0f + eps;
-
-            std::unreachable();
+            return std::ranges::any_of(ndc.raw_array(),
+                                       [](const auto& val) { return val < -1.0f - eps || val > 1.0f + eps; });
         }
 
         // NDC REPRESENTATION:

include/omath/projection/error_codes.hpp

@@ -11,6 +11,5 @@ 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,43 +3,11 @@
 //
 
 #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:
@@ -55,150 +23,26 @@ namespace omath::rev_eng
             return *reinterpret_cast<Type*>(reinterpret_cast<std::uintptr_t>(this) + offset);
         }
 
-        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>
+        template<std::size_t id, class ReturnType>
         ReturnType call_virtual_method(auto... arg_list)
         {
-            const auto vtable = *reinterpret_cast<void***>(this);
-            return call_method<ReturnType>(vtable[Id], arg_list...);
+#ifdef _MSC_VER
+            using VirtualMethodType = ReturnType(__thiscall*)(void*, decltype(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 Fn = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
+            using VirtualMethodType = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
 #else
-            using Fn = ReturnType(*)(void*, decltype(arg_list)...);
-#endif
-            return reinterpret_cast<Fn>(vtable[Id])(sub_this, arg_list...);
-        }
-        template<std::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;
+            using VirtualMethodType = ReturnType (*)(void*, decltype(arg_list)...);
 #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,7 +36,6 @@ namespace omath
         }
 
     public:
-        using ArithmeticType = Type;
         [[nodiscard]]
         constexpr static Angle from_degrees(const Type& degrees) noexcept
         {

include/omath/trigonometry/view_angles.hpp

@@ -2,25 +2,14 @@
 // 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

include/omath/utility/elf_pattern_scan.hpp

@@ -5,7 +5,6 @@
 #include <cstdint>
 #include <filesystem>
 #include <optional>
-#include <span>
 #include <string_view>
 #include "section_scan_result.hpp"
 namespace omath
@@ -22,10 +21,5 @@ namespace omath
         static std::optional<SectionScanResult>
         scan_for_pattern_in_file(const std::filesystem::path& path_to_file, const std::string_view& pattern,
                                  const std::string_view& target_section_name = ".text");
-
-        [[nodiscard]]
-        static std::optional<SectionScanResult>
-        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data, const std::string_view& pattern,
-                                        const std::string_view& target_section_name = ".text");
     };
 } // namespace omath

include/omath/utility/macho_pattern_scan.hpp

@@ -5,7 +5,6 @@
 #include <cstdint>
 #include <filesystem>
 #include <optional>
-#include <span>
 #include <string_view>
 #include "section_scan_result.hpp"
 namespace omath
@@ -22,10 +21,5 @@ namespace omath
         static std::optional<SectionScanResult>
         scan_for_pattern_in_file(const std::filesystem::path& path_to_file, const std::string_view& pattern,
                                  const std::string_view& target_section_name = "__text");
-
-        [[nodiscard]]
-        static std::optional<SectionScanResult>
-        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data, const std::string_view& pattern,
-                                        const std::string_view& target_section_name = "__text");
     };
 } // namespace omath

include/omath/utility/pe_pattern_scan.hpp

@@ -6,7 +6,6 @@
 #include <cstdint>
 #include <filesystem>
 #include <optional>
-#include <span>
 #include <string_view>
 #include "section_scan_result.hpp"
 namespace omath
@@ -24,10 +23,5 @@ namespace omath
         static std::optional<SectionScanResult>
         scan_for_pattern_in_file(const std::filesystem::path& path_to_file, const std::string_view& pattern,
                                  const std::string_view& target_section_name = ".text");
-
-        [[nodiscard]]
-        static std::optional<SectionScanResult>
-        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data, const std::string_view& pattern,
-                                        const std::string_view& target_section_name = ".text");
     };
 } // namespace omath

scripts/coverage-llvm.sh

@@ -16,42 +16,15 @@ echo "[*] Output dir: ${OUTPUT_DIR}"
 # Find llvm tools - handle versioned names (Linux) and xcrun (macOS)
 find_llvm_tool() {
     local tool_name="$1"
-
-    # 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
+    
+    # macOS: use xcrun
     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}"
@@ -60,7 +33,7 @@ find_llvm_tool() {
             return 0
         fi
     done
-
+    
     echo ""
     return 1
 }
@@ -78,18 +51,6 @@ 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 \

source/engines/cry_engine/formulas.cpp

@@ -35,15 +35,8 @@ 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, const NDCDepthRange ndc_depth_range) noexcept
+                                              const float far) noexcept
     {
-        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();
+        return mat_perspective_left_handed(field_of_view, aspect_ratio, near, far);
     }
 } // namespace omath::unity_engine

source/engines/cry_engine/traits/camera_trait.cpp

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

source/engines/frostbite_engine/formulas.cpp

@@ -35,16 +35,8 @@ 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, const NDCDepthRange ndc_depth_range) noexcept
+                                              const float far) noexcept
     {
-        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();
+        return mat_perspective_left_handed(field_of_view, aspect_ratio, near, far);
     }
 } // namespace omath::unity_engine

source/engines/frostbite_engine/traits/camera_trait.cpp

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

source/engines/iw_engine/formulas.cpp

@@ -36,27 +36,18 @@ namespace omath::iw_engine
     }
 
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
+                                              const float far) noexcept
     {
         // NOTE: Need magic number to fix fov calculation, since IW engine inherit Quake proj matrix calculation
         constexpr auto k_multiply_factor = 0.75f;
 
         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 {
-                    {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
-                    {0, 1.f / (fov_half_tan), 0, 0},
-                    {0, 0, far / (far - near), -(near * far) / (far - near)},
-                    {0, 0, 1, 0},
-            };
-        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return {
-                    {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
-                    {0, 1.f / (fov_half_tan), 0, 0},
-                    {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
-                    {0, 0, 1, 0},
-            };
-        std::unreachable();
+        return {
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
+                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
+                {0, 0, 1, 0},
+        };
     };
 } // namespace omath::iw_engine

source/engines/iw_engine/traits/camera_trait.cpp

@@ -19,9 +19,8 @@ namespace omath::iw_engine
     }
     Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                                const projection::ViewPort& view_port, const float near,
-                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
+                                               const float far) noexcept
     {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
     }
 } // 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 =
-                rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_forward);
+        const auto vec
+                = 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 =
-                rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_right);
+        const auto vec
+                = 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,16 +37,15 @@ 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, const NDCDepthRange ndc_depth_range) noexcept
+                                              const float far) noexcept
     {
-        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);
+        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
 
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return mat_perspective_right_handed<float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                        field_of_view, aspect_ratio, near, far);
-
-        std::unreachable();
+        return {
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
+                {0, 0, -(far + near) / (far - near), -(2.f * far * near) / (far - near)},
+                {0, 0, -1, 0},
+        };
     }
 } // namespace omath::opengl_engine

source/engines/opengl_engine/traits/camera_trait.cpp

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

source/engines/source_engine/formulas.cpp

@@ -36,27 +36,18 @@ namespace omath::source_engine
     }
 
     Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
+                                              const float far) noexcept
     {
         // NOTE: Need magic number to fix fov calculation, since source inherit Quake proj matrix calculation
         constexpr auto k_multiply_factor = 0.75f;
 
         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 {
-                    {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
-                    {0, 1.f / (fov_half_tan), 0, 0},
-                    {0, 0, far / (far - near), -(near * far) / (far - near)},
-                    {0, 0, 1, 0},
-            };
-        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return {
-                    {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
-                    {0, 1.f / (fov_half_tan), 0, 0},
-                    {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
-                    {0, 0, 1, 0},
-            };
-        std::unreachable();
+        return {
+                {1.f / (aspect_ratio * fov_half_tan), 0, 0, 0},
+                {0, 1.f / (fov_half_tan), 0, 0},
+                {0, 0, (far + near) / (far - near), -(2.f * far * near) / (far - near)},
+                {0, 0, 1, 0},
+        };
     }
 } // namespace omath::source_engine

source/engines/source_engine/traits/camera_trait.cpp

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

source/engines/unity_engine/formulas.cpp

@@ -35,15 +35,8 @@ 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, const NDCDepthRange ndc_depth_range) noexcept
+                                              const float far) noexcept
     {
-        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();
+        return omath::mat_perspective_right_handed(field_of_view, aspect_ratio, near, far);
     }
 } // namespace omath::unity_engine

source/engines/unity_engine/traits/camera_trait.cpp

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

source/engines/unreal_engine/formulas.cpp

@@ -35,12 +35,8 @@ namespace omath::unreal_engine
                * mat_rotation_axis_y<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, const NDCDepthRange ndc_depth_range) noexcept
+                                              const float far) noexcept
     {
-        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);
-
         return mat_perspective_left_handed(field_of_view, aspect_ratio, near, far);
     }
 } // namespace omath::unreal_engine

source/engines/unreal_engine/traits/camera_trait.cpp

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

source/hud/canvas_box.cpp

@@ -1,27 +0,0 @@
-//
-// Created by orange on 13.03.2026.
-//
-//
-// Created by Vlad on 6/17/2025.
-//
-#include "omath/hud/canvas_box.hpp"
-
-namespace omath::hud
-{
-
-    CanvasBox::CanvasBox(const Vector2<float> top, Vector2<float> bottom, const float ratio)
-    {
-        bottom.x = top.x;
-        const auto height = std::abs(top.y - bottom.y);
-
-        top_left_corner = top - Vector2<float>{height / ratio, 0};
-        top_right_corner = top + Vector2<float>{height / ratio, 0};
-
-        bottom_left_corner = bottom - Vector2<float>{height / ratio, 0};
-        bottom_right_corner = bottom + Vector2<float>{height / ratio, 0};
-    }
-    std::array<Vector2<float>, 4> CanvasBox::as_array() const
-    {
-        return {top_left_corner, top_right_corner, bottom_right_corner, bottom_left_corner};
-    }
-} // namespace ohud

source/hud/entity_overlay.cpp

@@ -1,870 +0,0 @@
-//
-// Created by orange on 13.03.2026.
-//
-#include "omath/hud/entity_overlay.hpp"
-
-namespace omath::hud
-{
-    EntityOverlay& EntityOverlay::add_2d_box(const Color& box_color, const Color& fill_color, const float thickness)
-    {
-        const auto points = m_canvas.as_array();
-
-        m_renderer->add_polyline({points.data(), points.size()}, box_color, thickness);
-
-        if (fill_color.value().w > 0.f)
-            m_renderer->add_filled_polyline({points.data(), points.size()}, fill_color);
-
-        return *this;
-    }
-    EntityOverlay& EntityOverlay::add_cornered_2d_box(const Color& box_color, const Color& fill_color,
-                                                      const float corner_ratio_len, const float thickness)
-    {
-        const auto corner_line_length =
-                std::abs((m_canvas.top_left_corner - m_canvas.top_right_corner).x * corner_ratio_len);
-
-        if (fill_color.value().w > 0.f)
-            add_2d_box(fill_color, fill_color);
-        // Left Side
-        m_renderer->add_line(m_canvas.top_left_corner,
-                             m_canvas.top_left_corner + Vector2<float>{corner_line_length, 0.f}, box_color, thickness);
-
-        m_renderer->add_line(m_canvas.top_left_corner,
-                             m_canvas.top_left_corner + Vector2<float>{0.f, corner_line_length}, box_color, thickness);
-
-        m_renderer->add_line(m_canvas.bottom_left_corner,
-                             m_canvas.bottom_left_corner - Vector2<float>{0.f, corner_line_length}, box_color,
-                             thickness);
-
-        m_renderer->add_line(m_canvas.bottom_left_corner,
-                             m_canvas.bottom_left_corner + Vector2<float>{corner_line_length, 0.f}, box_color,
-                             thickness);
-        // Right Side
-        m_renderer->add_line(m_canvas.top_right_corner,
-                             m_canvas.top_right_corner - Vector2<float>{corner_line_length, 0.f}, box_color, thickness);
-
-        m_renderer->add_line(m_canvas.top_right_corner,
-                             m_canvas.top_right_corner + Vector2<float>{0.f, corner_line_length}, box_color, thickness);
-
-        m_renderer->add_line(m_canvas.bottom_right_corner,
-                             m_canvas.bottom_right_corner - Vector2<float>{0.f, corner_line_length}, box_color,
-                             thickness);
-
-        m_renderer->add_line(m_canvas.bottom_right_corner,
-                             m_canvas.bottom_right_corner - Vector2<float>{corner_line_length, 0.f}, box_color,
-                             thickness);
-
-        return *this;
-    }
-    EntityOverlay& EntityOverlay::add_right_bar(const Color& color, const Color& outline_color, const Color& bg_color,
-                                                const float width, float ratio, const float offset)
-    {
-        ratio = std::clamp(ratio, 0.f, 1.f);
-        const auto max_bar_height = std::abs(m_canvas.top_right_corner.y - m_canvas.bottom_right_corner.y);
-
-        const auto bar_start = Vector2<float>{m_text_cursor_right.x + offset, m_canvas.bottom_right_corner.y};
-        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(width, -max_bar_height), bg_color);
-
-        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(width, -max_bar_height * ratio), color);
-        m_renderer->add_rectangle(bar_start - Vector2<float>(1.f, 0.f),
-                                  bar_start + Vector2<float>(width, -max_bar_height), outline_color);
-
-        m_text_cursor_right.x += offset + width;
-
-        return *this;
-    }
-    EntityOverlay& EntityOverlay::add_left_bar(const Color& color, const Color& outline_color, const Color& bg_color,
-                                               const float width, float ratio, const float offset)
-    {
-        ratio = std::clamp(ratio, 0.f, 1.f);
-        const auto max_bar_height = std::abs(m_canvas.top_left_corner.y - m_canvas.bottom_right_corner.y);
-
-        const auto bar_start = Vector2<float>{m_text_cursor_left.x - (offset + width), m_canvas.bottom_left_corner.y};
-        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(width, -max_bar_height), bg_color);
-
-        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(width, -max_bar_height * ratio), color);
-        m_renderer->add_rectangle(bar_start - Vector2<float>(1.f, 0.f),
-                                  bar_start + Vector2<float>(width, -max_bar_height), outline_color);
-
-        m_text_cursor_left.x -= offset + width;
-
-        return *this;
-    }
-    EntityOverlay& EntityOverlay::add_right_label(const Color& color, const float offset, const bool outlined,
-                                                  const std::string_view& text)
-    {
-        if (outlined)
-            draw_outlined_text(m_text_cursor_right + Vector2<float>{offset, 0.f}, color, text);
-        else
-            m_renderer->add_text(m_text_cursor_right + Vector2<float>{offset, 0.f}, color, text.data());
-
-        m_text_cursor_right.y += m_renderer->calc_text_size(text.data()).y;
-
-        return *this;
-    }
-    EntityOverlay& EntityOverlay::add_top_label(const Color& color, const float offset, const bool outlined,
-                                                const std::string_view text)
-    {
-        m_text_cursor_top.y -= m_renderer->calc_text_size(text.data()).y;
-
-        if (outlined)
-            draw_outlined_text(m_text_cursor_top + Vector2<float>{0.f, -offset}, color, text);
-        else
-            m_renderer->add_text(m_text_cursor_top + Vector2<float>{0.f, -offset}, color, text.data());
-
-        return *this;
-    }
-    EntityOverlay& EntityOverlay::add_top_bar(const Color& color, const Color& outline_color, const Color& bg_color,
-                                              const float height, float ratio, const float offset)
-    {
-        ratio = std::clamp(ratio, 0.f, 1.f);
-        const auto max_bar_width = std::abs(m_canvas.top_left_corner.x - m_canvas.bottom_right_corner.x);
-
-        const auto bar_start = Vector2<float>{m_canvas.top_left_corner.x, m_text_cursor_top.y - offset};
-        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width, -height), bg_color);
-
-        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width * ratio, -height), color);
-        m_renderer->add_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width, -height), outline_color);
-
-        m_text_cursor_top.y -= offset + height;
-
-        return *this;
-    }
-    EntityOverlay& EntityOverlay::add_snap_line(const Vector2<float>& start_pos, const Color& color, const float width)
-    {
-        const Vector2<float> line_end =
-                m_canvas.bottom_left_corner
-                + Vector2<float>{m_canvas.bottom_right_corner.x - m_canvas.bottom_left_corner.x, 0.f} / 2;
-        m_renderer->add_line(start_pos, line_end, color, width);
-
-        return *this;
-    }
-    void EntityOverlay::draw_dashed_fill(const Vector2<float>& origin, const Vector2<float>& step_dir,
-                                         const Vector2<float>& perp_dir, const float full_len, const float filled_len,
-                                         const Color& fill_color, const Color& split_color, const float dash_len,
-                                         const float gap_len) const
-    {
-        if (full_len <= 0.f)
-            return;
-
-        const float step = dash_len + gap_len;
-        const float n = std::floor((full_len + gap_len) / step);
-        if (n < 1.f)
-            return;
-
-        const float used = n * dash_len + (n - 1.f) * gap_len;
-        const float offset = (full_len - used) / 2.f;
-
-        const auto fill_rect = [&](const Vector2<float>& a, const Vector2<float>& b, const Color& c)
-        {
-            m_renderer->add_filled_rectangle({std::min(a.x, b.x), std::min(a.y, b.y)},
-                                             {std::max(a.x, b.x), std::max(a.y, b.y)}, c);
-        };
-
-        // Draw split lines (gaps) across the full bar first
-        // Leading gap
-        if (offset > 0.f)
-            fill_rect(origin, origin + step_dir * offset + perp_dir, split_color);
-
-        for (float i = 0.f; i < n; ++i)
-        {
-            const float dash_start = offset + i * step;
-            const float dash_end = dash_start + dash_len;
-            const float gap_start = dash_end;
-            const float gap_end = dash_start + step;
-
-            // Fill dash only up to filled_len
-            if (dash_start < filled_len)
-            {
-                const auto a = origin + step_dir * dash_start;
-                const auto b = a + step_dir * std::min(dash_len, filled_len - dash_start) + perp_dir;
-                fill_rect(a, b, fill_color);
-            }
-
-            // Split line (gap) — always drawn across full bar
-            if (i < n - 1.f && gap_start < full_len)
-            {
-                const auto a = origin + step_dir * gap_start;
-                const auto b = origin + step_dir * std::min(gap_end, full_len) + perp_dir;
-                fill_rect(a, b, split_color);
-            }
-        }
-
-        // Trailing gap
-        const float trail_start = offset + n * dash_len + (n - 1.f) * gap_len;
-        if (trail_start < full_len)
-            fill_rect(origin + step_dir * trail_start, origin + step_dir * full_len + perp_dir, split_color);
-    }
-
-    EntityOverlay& EntityOverlay::add_right_dashed_bar(const Color& color, const Color& outline_color,
-                                                       const Color& bg_color, const float width, float ratio,
-                                                       const float dash_len, const float gap_len, const float offset)
-    {
-        ratio = std::clamp(ratio, 0.f, 1.f);
-        const float height = std::abs(m_canvas.top_right_corner.y - m_canvas.bottom_right_corner.y);
-        const auto bar_start = Vector2<float>{m_text_cursor_right.x + offset, m_canvas.bottom_right_corner.y};
-
-        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>{width, -height}, bg_color);
-        draw_dashed_fill(bar_start, {0.f, -1.f}, {width, 0.f}, height, height * ratio, color, outline_color, dash_len,
-                         gap_len);
-        m_renderer->add_rectangle(bar_start - Vector2<float>{1.f, 0.f}, bar_start + Vector2<float>{width, -height},
-                                  outline_color);
-        m_text_cursor_right.x += offset + width;
-
-        return *this;
-    }
-
-    EntityOverlay& EntityOverlay::add_left_dashed_bar(const Color& color, const Color& outline_color,
-                                                      const Color& bg_color, const float width, float ratio,
-                                                      const float dash_len, const float gap_len, const float offset)
-    {
-        ratio = std::clamp(ratio, 0.f, 1.f);
-        const float height = std::abs(m_canvas.top_left_corner.y - m_canvas.bottom_left_corner.y);
-        const auto bar_start = Vector2<float>{m_text_cursor_left.x - (offset + width), m_canvas.bottom_left_corner.y};
-
-        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>{width, -height}, bg_color);
-        draw_dashed_fill(bar_start, {0.f, -1.f}, {width, 0.f}, height, height * ratio, color, outline_color, dash_len,
-                         gap_len);
-        m_renderer->add_rectangle(bar_start - Vector2<float>{1.f, 0.f}, bar_start + Vector2<float>{width, -height},
-                                  outline_color);
-        m_text_cursor_left.x -= offset + width;
-
-        return *this;
-    }
-
-    EntityOverlay& EntityOverlay::add_top_dashed_bar(const Color& color, const Color& outline_color,
-                                                     const Color& bg_color, const float height, float ratio,
-                                                     const float dash_len, const float gap_len, const float offset)
-    {
-        ratio = std::clamp(ratio, 0.f, 1.f);
-        const float bar_w = std::abs(m_canvas.top_left_corner.x - m_canvas.top_right_corner.x);
-        const auto bar_start = Vector2<float>{m_canvas.top_left_corner.x, m_text_cursor_top.y - offset};
-
-        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>{bar_w, -height}, bg_color);
-        draw_dashed_fill(bar_start, {1.f, 0.f}, {0.f, -height}, bar_w, bar_w * ratio, color, outline_color, dash_len,
-                         gap_len);
-        m_renderer->add_rectangle(bar_start, bar_start + Vector2<float>{bar_w, -height}, outline_color);
-        m_text_cursor_top.y -= offset + height;
-
-        return *this;
-    }
-
-    EntityOverlay& EntityOverlay::add_bottom_dashed_bar(const Color& color, const Color& outline_color,
-                                                        const Color& bg_color, const float height, float ratio,
-                                                        const float dash_len, const float gap_len, const float offset)
-    {
-        ratio = std::clamp(ratio, 0.f, 1.f);
-        const float bar_w = std::abs(m_canvas.bottom_left_corner.x - m_canvas.bottom_right_corner.x);
-        const auto bar_start = Vector2<float>{m_canvas.bottom_left_corner.x, m_text_cursor_bottom.y + offset};
-
-        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>{bar_w, height}, bg_color);
-        draw_dashed_fill(bar_start, {1.f, 0.f}, {0.f, height}, bar_w, bar_w * ratio, color, outline_color, dash_len,
-                         gap_len);
-        m_renderer->add_rectangle(bar_start, bar_start + Vector2<float>{bar_w, height}, outline_color);
-        m_text_cursor_bottom.y += offset + height;
-
-        return *this;
-    }
-
-    EntityOverlay& EntityOverlay::add_skeleton(const Color& color, const float thickness)
-    {
-        // Maps normalized (rx in [0,1], ry in [0,1]) to canvas screen position
-        const auto joint = [&](const float rx, const float ry) -> Vector2<float>
-        {
-            const auto top = m_canvas.top_left_corner + (m_canvas.top_right_corner - m_canvas.top_left_corner) * rx;
-            const auto bot =
-                    m_canvas.bottom_left_corner + (m_canvas.bottom_right_corner - m_canvas.bottom_left_corner) * rx;
-            return top + (bot - top) * ry;
-        };
-
-        using B = std::pair<std::pair<float, float>, std::pair<float, float>>;
-        static constexpr std::array<B, 15> k_bones{{
-                // Spine
-                {{0.50f, 0.13f}, {0.50f, 0.22f}}, // head       → neck
-                {{0.50f, 0.22f}, {0.50f, 0.38f}}, // neck       → chest
-                {{0.50f, 0.38f}, {0.50f, 0.55f}}, // chest      → pelvis
-                // Left arm
-                {{0.50f, 0.22f}, {0.25f, 0.25f}}, // neck       → L shoulder
-                {{0.25f, 0.25f}, {0.13f, 0.42f}}, // L shoulder → L elbow
-                {{0.13f, 0.42f}, {0.08f, 0.56f}}, // L elbow    → L hand
-                // Right arm
-                {{0.50f, 0.22f}, {0.75f, 0.25f}}, // neck       → R shoulder
-                {{0.75f, 0.25f}, {0.87f, 0.42f}}, // R shoulder → R elbow
-                {{0.87f, 0.42f}, {0.92f, 0.56f}}, // R elbow    → R hand
-                // Left leg
-                {{0.50f, 0.55f}, {0.36f, 0.58f}}, // pelvis     → L hip
-                {{0.36f, 0.58f}, {0.32f, 0.77f}}, // L hip      → L knee
-                {{0.32f, 0.77f}, {0.27f, 0.97f}}, // L knee     → L foot
-                // Right leg
-                {{0.50f, 0.55f}, {0.64f, 0.58f}}, // pelvis     → R hip
-                {{0.64f, 0.58f}, {0.68f, 0.77f}}, // R hip      → R knee
-                {{0.68f, 0.77f}, {0.73f, 0.97f}}, // R knee     → R foot
-        }};
-
-        for (const auto& [a, b] : k_bones)
-            m_renderer->add_line(joint(a.first, a.second), joint(b.first, b.second), color, thickness);
-
-        return *this;
-    }
-
-    void EntityOverlay::draw_dashed_line(const Vector2<float>& from, const Vector2<float>& to, const Color& color,
-                                         const float dash_len, const float gap_len, const float thickness) const
-    {
-        const auto total = (to - from).length();
-        if (total <= 0.f)
-            return;
-
-        const auto dir = (to - from).normalized();
-        const float step = dash_len + gap_len;
-
-        const float n_dashes = std::floor((total + gap_len) / step);
-        if (n_dashes < 1.f)
-            return;
-
-        const float used = n_dashes * dash_len + (n_dashes - 1.f) * gap_len;
-        const float offset = (total - used) / 2.f;
-
-        for (float i = 0.f; i < n_dashes; ++i)
-        {
-            const float pos = offset + i * step;
-            const auto dash_start = from + dir * pos;
-            const auto dash_end = from + dir * std::min(pos + dash_len, total);
-            m_renderer->add_line(dash_start, dash_end, color, thickness);
-        }
-    }
-
-    EntityOverlay& EntityOverlay::add_dashed_box(const Color& color, const float dash_len, const float gap_len,
-                                                 const float thickness)
-    {
-        const float min_edge = std::min((m_canvas.top_right_corner - m_canvas.top_left_corner).length(),
-                                        (m_canvas.bottom_right_corner - m_canvas.top_right_corner).length());
-        const float corner_len = std::min(dash_len, min_edge / 2.f);
-
-        const auto draw_edge = [&](const Vector2<float>& from, const Vector2<float>& to)
-        {
-            const auto dir = (to - from).normalized();
-
-            m_renderer->add_line(from, from + dir * corner_len, color, thickness);
-            draw_dashed_line(from + dir * corner_len, to - dir * corner_len, color, dash_len, gap_len, thickness);
-            m_renderer->add_line(to - dir * corner_len, to, color, thickness);
-        };
-
-        draw_edge(m_canvas.top_left_corner, m_canvas.top_right_corner);
-        draw_edge(m_canvas.top_right_corner, m_canvas.bottom_right_corner);
-        draw_edge(m_canvas.bottom_right_corner, m_canvas.bottom_left_corner);
-        draw_edge(m_canvas.bottom_left_corner, m_canvas.top_left_corner);
-
-        return *this;
-    }
-
-    void EntityOverlay::draw_outlined_text(const Vector2<float>& position, const Color& color,
-                                           const std::string_view& text)
-    {
-        static constexpr std::array outline_offsets = {
-                Vector2<float>{-1, -1}, Vector2<float>{-1, 0}, Vector2<float>{-1, 1}, Vector2<float>{0, -1},
-                Vector2<float>{0, 1},   Vector2<float>{1, -1}, Vector2<float>{1, 0},  Vector2<float>{1, 1}};
-
-        for (const auto& outline_offset : outline_offsets)
-            m_renderer->add_text(position + outline_offset, Color{0.f, 0.f, 0.f, 1.f}, text.data());
-        m_renderer->add_text(position, color, text.data());
-    }
-    EntityOverlay& EntityOverlay::add_bottom_bar(const Color& color, const Color& outline_color, const Color& bg_color,
-                                                 const float height, float ratio, const float offset)
-    {
-        ratio = std::clamp(ratio, 0.f, 1.f);
-        const auto max_bar_width = std::abs(m_canvas.bottom_right_corner.x - m_canvas.bottom_left_corner.x);
-
-        const auto bar_start = Vector2<float>{m_canvas.bottom_left_corner.x, m_text_cursor_bottom.y + offset};
-        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width, height), bg_color);
-        m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width * ratio, height), color);
-        m_renderer->add_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width, height), outline_color);
-
-        m_text_cursor_bottom.y += offset + height;
-
-        return *this;
-    }
-
-    EntityOverlay& EntityOverlay::add_bottom_label(const Color& color, const float offset, const bool outlined,
-                                                   const std::string_view text)
-    {
-        const auto text_size = m_renderer->calc_text_size(text);
-
-        if (outlined)
-            draw_outlined_text(m_text_cursor_bottom + Vector2<float>{0.f, offset}, color, text);
-        else
-            m_renderer->add_text(m_text_cursor_bottom + Vector2<float>{0.f, offset}, color, text);
-
-        m_text_cursor_bottom.y += text_size.y;
-
-        return *this;
-    }
-
-    EntityOverlay& EntityOverlay::add_left_label(const Color& color, const float offset, const bool outlined,
-                                                 const std::string_view& text)
-    {
-        const auto text_size = m_renderer->calc_text_size(text);
-        const auto pos = m_text_cursor_left + Vector2<float>{-(offset + text_size.x), 0.f};
-
-        if (outlined)
-            draw_outlined_text(pos, color, text);
-        else
-            m_renderer->add_text(pos, color, text);
-
-        m_text_cursor_left.y += text_size.y;
-
-        return *this;
-    }
-
-    EntityOverlay& EntityOverlay::add_centered_bottom_label(const Color& color, const float offset, const bool outlined,
-                                                            const std::string_view& text)
-    {
-        const auto text_size = m_renderer->calc_text_size(text);
-        const auto box_center_x =
-                m_canvas.bottom_left_corner.x + (m_canvas.bottom_right_corner.x - m_canvas.bottom_left_corner.x) / 2.f;
-        const auto pos = Vector2<float>{box_center_x - text_size.x / 2.f, m_text_cursor_bottom.y + offset};
-
-        if (outlined)
-            draw_outlined_text(pos, color, text);
-        else
-            m_renderer->add_text(pos, color, text);
-
-        m_text_cursor_bottom.y += text_size.y;
-
-        return *this;
-    }
-
-    EntityOverlay& EntityOverlay::add_centered_top_label(const Color& color, const float offset, const bool outlined,
-                                                         const std::string_view& text)
-    {
-        const auto text_size = m_renderer->calc_text_size(text);
-        const auto box_center_x =
-                m_canvas.top_left_corner.x + (m_canvas.top_right_corner.x - m_canvas.top_left_corner.x) / 2.f;
-
-        m_text_cursor_top.y -= text_size.y;
-        const auto pos = Vector2<float>{box_center_x - text_size.x / 2.f, m_text_cursor_top.y - offset};
-
-        if (outlined)
-            draw_outlined_text(pos, color, text);
-        else
-            m_renderer->add_text(pos, color, text);
-
-        return *this;
-    }
-
-    EntityOverlay::EntityOverlay(const Vector2<float>& top, const Vector2<float>& bottom,
-                                 const std::shared_ptr<HudRendererInterface>& renderer)
-        : m_canvas(top, bottom), m_text_cursor_right(m_canvas.top_right_corner),
-          m_text_cursor_top(m_canvas.top_left_corner), m_text_cursor_bottom(m_canvas.bottom_left_corner),
-          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)
-    {
-        add_2d_box(box.color, box.fill, box.thickness);
-    }
-
-    void EntityOverlay::dispatch(const widget::CorneredBox& cornered_box)
-    {
-        add_cornered_2d_box(cornered_box.color, cornered_box.fill, cornered_box.corner_ratio, cornered_box.thickness);
-    }
-
-    void EntityOverlay::dispatch(const widget::DashedBox& dashed_box)
-    {
-        add_dashed_box(dashed_box.color, dashed_box.dash_len, dashed_box.gap_len, dashed_box.thickness);
-    }
-
-    void EntityOverlay::dispatch(const widget::Skeleton& skeleton)
-    {
-        add_skeleton(skeleton.color, skeleton.thickness);
-    }
-
-    void EntityOverlay::dispatch(const widget::SnapLine& snap_line)
-    {
-        add_snap_line(snap_line.start, snap_line.color, snap_line.width);
-    }
-
-    void EntityOverlay::dispatch(const widget::ScanMarker& scan_marker)
-    {
-        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&)
-                            {
-                            },
-                            [this](const widget::Bar& w)
-                            {
-                                add_right_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset);
-                            },
-                            [this](const widget::DashedBar& w)
-                            {
-                                add_right_dashed_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.dash_len, w.gap_len,
-                                                     w.offset);
-                            },
-                            [this](const widget::Label& w)
-                            {
-                                add_right_label(w.color, w.offset, w.outlined, w.text);
-                            },
-                            [this](const widget::Centered<widget::Label>& w)
-                            {
-                                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& left_side)
-    {
-        for (const auto& child : left_side.children)
-            std::visit(
-                    widget::Overloaded{
-                            [](const widget::None&)
-                            {
-                            },
-                            [this](const widget::Bar& w)
-                            {
-                                add_left_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset);
-                            },
-                            [this](const widget::DashedBar& w)
-                            {
-                                add_left_dashed_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.dash_len, w.gap_len,
-                                                    w.offset);
-                            },
-                            [this](const widget::Label& w)
-                            {
-                                add_left_label(w.color, w.offset, w.outlined, w.text);
-                            },
-                            [this](const widget::Centered<widget::Label>& w)
-                            {
-                                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);
-    }
-
-    void EntityOverlay::dispatch(const widget::TopSide& top_side)
-    {
-        for (const auto& child : top_side.children)
-            std::visit(
-                    widget::Overloaded{
-                            [](const widget::None&)
-                            {
-                            },
-                            [this](const widget::Bar& w)
-                            {
-                                add_top_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset);
-                            },
-                            [this](const widget::DashedBar& w)
-                            {
-                                add_top_dashed_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.dash_len, w.gap_len,
-                                                   w.offset);
-                            },
-                            [this](const widget::Label& w)
-                            {
-                                add_top_label(w.color, w.offset, w.outlined, w.text);
-                            },
-                            [this](const widget::Centered<widget::Label>& w)
-                            {
-                                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);
-    }
-    void EntityOverlay::dispatch(const widget::BottomSide& bottom_side)
-    {
-        for (const auto& child : bottom_side.children)
-            std::visit(
-                    widget::Overloaded{
-                            [](const widget::None&)
-                            {
-                            },
-                            [this](const widget::Bar& w)
-                            {
-                                add_bottom_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset);
-                            },
-                            [this](const widget::DashedBar& w)
-                            {
-                                add_bottom_dashed_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.dash_len, w.gap_len,
-                                                      w.offset);
-                            },
-                            [this](const widget::Label& w)
-                            {
-                                add_bottom_label(w.color, w.offset, w.outlined, w.text);
-                            },
-                            [this](const widget::Centered<widget::Label>& w)
-                            {
-                                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);
-    }
-
-} // namespace omath::hud

source/hud/renderer_realizations/imgui_renderer.cpp

@@ -1,82 +0,0 @@
-//
-// Created by orange on 13.03.2026.
-//
-#include "omath/hud/renderer_realizations/imgui_renderer.hpp"
-
-#ifdef OMATH_IMGUI_INTEGRATION
-#include <imgui.h>
-
-namespace omath::hud
-{
-    ImguiHudRenderer::~ImguiHudRenderer() = default;
-
-    void ImguiHudRenderer::add_line(const Vector2<float>& line_start, const Vector2<float>& line_end,
-                                    const Color& color, const float thickness)
-    {
-        ImGui::GetBackgroundDrawList()->AddLine(line_start.to_im_vec2(), line_end.to_im_vec2(), color.to_im_color(),
-                                                thickness);
-    }
-
-    void ImguiHudRenderer::add_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color,
-                                        const float thickness)
-    {
-        ImGui::GetBackgroundDrawList()->AddPolyline(reinterpret_cast<const ImVec2*>(vertexes.data()),
-                                                    static_cast<int>(vertexes.size()), color.to_im_color(),
-                                                    ImDrawFlags_Closed, thickness);
-    }
-
-    void ImguiHudRenderer::add_filled_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color)
-    {
-        ImGui::GetBackgroundDrawList()->AddConvexPolyFilled(reinterpret_cast<const ImVec2*>(vertexes.data()),
-                                                    static_cast<int>(vertexes.size()), color.to_im_color());
-    }
-
-    void ImguiHudRenderer::add_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color)
-    {
-        ImGui::GetBackgroundDrawList()->AddRect(min.to_im_vec2(), max.to_im_vec2(), color.to_im_color());
-    }
-
-    void ImguiHudRenderer::add_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max,
-                                                const Color& color)
-    {
-        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(),
-                                                text.data() + text.size());
-    }
-    [[nodiscard]]
-    Vector2<float> ImguiHudRenderer::calc_text_size(const std::string_view& text)
-    {
-        return Vector2<float>::from_im_vec2(ImGui::CalcTextSize(text.data()));
-    }
-} // namespace omath::hud
-#endif // OMATH_IMGUI_INTEGRATION

source/lua/lua_engines.cpp

@@ -3,8 +3,6 @@
 //
 #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>
@@ -35,8 +33,6 @@ 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";
     }

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

@@ -1,92 +0,0 @@
-//
-// 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

@@ -21,7 +21,7 @@ namespace omath::projectile_prediction
         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 + projectile.m_launch_offset;
+        const Vector3 proj_origin = projectile.m_origin;
 
         constexpr int SIMD_FACTOR = 8;
         float current_time = m_simulation_time_step;
@@ -124,110 +124,6 @@ namespace omath::projectile_prediction
                 std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
 #endif
     }
-    std::optional<AimAngles>
-    ProjPredEngineAvx2::maybe_calculate_aim_angles([[maybe_unused]] const Projectile& projectile,
-                                                    [[maybe_unused]] const Target& 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{*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),

source/utility/elf_pattern_scan.cpp

@@ -5,7 +5,6 @@
 #include <array>
 #include <fstream>
 #include <omath/utility/elf_pattern_scan.hpp>
-#include <span>
 #include <utility>
 #include <variant>
 #include <vector>
@@ -141,87 +140,6 @@ namespace
         std::uintptr_t raw_base_addr{};
         std::vector<std::byte> data;
     };
-    template<FileArch arch>
-    std::optional<ExtractedSection> get_elf_section_from_memory_impl(const std::span<const std::byte> data,
-                                                                     const std::string_view& section_name)
-    {
-        using FH = typename ElfHeaders<arch>::FileHeader;
-        using SH = typename ElfHeaders<arch>::SectionHeader;
-
-        if (data.size() < sizeof(FH))
-            return std::nullopt;
-
-        const auto* file_header = reinterpret_cast<const FH*>(data.data());
-
-        const auto shoff = static_cast<std::size_t>(file_header->e_shoff);
-        const auto shnum = static_cast<std::size_t>(file_header->e_shnum);
-        const auto shstrndx = static_cast<std::size_t>(file_header->e_shstrndx);
-
-        const auto shstrtab_hdr_off = shoff + shstrndx * sizeof(SH);
-        if (shstrtab_hdr_off + sizeof(SH) > data.size())
-            return std::nullopt;
-
-        const auto* shstrtab_hdr = reinterpret_cast<const SH*>(data.data() + shstrtab_hdr_off);
-        const auto shstrtab_off = static_cast<std::size_t>(shstrtab_hdr->sh_offset);
-        const auto shstrtab_size = static_cast<std::size_t>(shstrtab_hdr->sh_size);
-
-        if (shstrtab_off + shstrtab_size > data.size())
-            return std::nullopt;
-
-        const auto* shstrtab = reinterpret_cast<const char*>(data.data() + shstrtab_off);
-
-        for (std::size_t i = 0; i < shnum; ++i)
-        {
-            const auto sect_hdr_off = shoff + i * sizeof(SH);
-            if (sect_hdr_off + sizeof(SH) > data.size())
-                continue;
-
-            const auto* section = reinterpret_cast<const SH*>(data.data() + sect_hdr_off);
-
-            if (std::cmp_greater_equal(section->sh_name, shstrtab_size))
-                continue;
-
-            if (std::string_view{shstrtab + section->sh_name} != section_name)
-                continue;
-
-            const auto raw_off = static_cast<std::size_t>(section->sh_offset);
-            const auto sec_size = static_cast<std::size_t>(section->sh_size);
-
-            if (raw_off + sec_size > data.size())
-                return std::nullopt;
-
-            ExtractedSection out;
-            out.virtual_base_addr = static_cast<std::uintptr_t>(section->sh_addr);
-            out.raw_base_addr = raw_off;
-            out.data.assign(data.data() + raw_off, data.data() + raw_off + sec_size);
-            return out;
-        }
-        return std::nullopt;
-    }
-
-    std::optional<ExtractedSection> get_elf_section_by_name_from_memory(const std::span<const std::byte> data,
-                                                                        const std::string_view& section_name)
-    {
-        constexpr std::string_view valid_elf_signature = "\x7F"
-                                                         "ELF";
-        if (data.size() < ei_nident)
-            return std::nullopt;
-
-        if (std::string_view{reinterpret_cast<const char*>(data.data()), valid_elf_signature.size()}
-            != valid_elf_signature)
-            return std::nullopt;
-
-        const auto class_byte = static_cast<uint8_t>(data[ei_class]);
-
-        if (class_byte == elfclass64)
-            return get_elf_section_from_memory_impl<FileArch::x64>(data, section_name);
-
-        if (class_byte == elfclass32)
-            return get_elf_section_from_memory_impl<FileArch::x32>(data, section_name);
-
-        return std::nullopt;
-    }
-
     [[maybe_unused]]
     std::optional<ExtractedSection> get_elf_section_by_name(const std::filesystem::path& path,
                                                             const std::string_view& section_name)
@@ -404,27 +322,4 @@ namespace omath
                                  .raw_base_addr = pe_section->raw_base_addr,
                                  .target_offset = offset};
     }
-
-    std::optional<SectionScanResult>
-    ElfPatternScanner::scan_for_pattern_in_memory_file(const std::span<const std::byte> file_data,
-                                                       const std::string_view& pattern,
-                                                       const std::string_view& target_section_name)
-    {
-        const auto section = get_elf_section_by_name_from_memory(file_data, target_section_name);
-
-        if (!section.has_value()) [[unlikely]]
-            return std::nullopt;
-
-        const auto scan_result =
-                PatternScanner::scan_for_pattern(section->data.cbegin(), section->data.cend(), pattern);
-
-        if (scan_result == section->data.cend())
-            return std::nullopt;
-
-        const auto offset = std::distance(section->data.begin(), scan_result);
-
-        return SectionScanResult{.virtual_base_addr = section->virtual_base_addr,
-                                 .raw_base_addr = section->raw_base_addr,
-                                 .target_offset = offset};
-    }
 } // namespace omath

source/utility/macho_pattern_scan.cpp

@@ -5,7 +5,6 @@
 #include "omath/utility/pattern_scan.hpp"
 #include <cstring>
 #include <fstream>
-#include <span>
 #include <variant>
 #include <vector>
 
@@ -232,96 +231,6 @@ namespace
         return std::nullopt;
     }
 
-    template<typename HeaderType, typename SegmentType, typename SectionType, std::uint32_t segment_cmd>
-    std::optional<ExtractedSection> extract_section_from_memory_impl(const std::span<const std::byte> data,
-                                                                     const std::string_view& section_name)
-    {
-        if (data.size() < sizeof(HeaderType))
-            return std::nullopt;
-
-        const auto* header = reinterpret_cast<const HeaderType*>(data.data());
-
-        std::size_t cmd_offset = sizeof(HeaderType);
-
-        for (std::uint32_t i = 0; i < header->ncmds; ++i)
-        {
-            if (cmd_offset + sizeof(LoadCommand) > data.size())
-                return std::nullopt;
-
-            const auto* lc = reinterpret_cast<const LoadCommand*>(data.data() + cmd_offset);
-
-            if (lc->cmd != segment_cmd)
-            {
-                cmd_offset += lc->cmdsize;
-                continue;
-            }
-
-            if (cmd_offset + sizeof(SegmentType) > data.size())
-                return std::nullopt;
-
-            const auto* segment = reinterpret_cast<const SegmentType*>(data.data() + cmd_offset);
-
-            if (!segment->nsects)
-            {
-                cmd_offset += lc->cmdsize;
-                continue;
-            }
-
-            std::size_t sect_offset = cmd_offset + sizeof(SegmentType);
-
-            for (std::uint32_t j = 0; j < segment->nsects; ++j)
-            {
-                if (sect_offset + sizeof(SectionType) > data.size())
-                    return std::nullopt;
-
-                const auto* section = reinterpret_cast<const SectionType*>(data.data() + sect_offset);
-
-                if (get_section_name(section->sectname) != section_name)
-                {
-                    sect_offset += sizeof(SectionType);
-                    continue;
-                }
-
-                const auto raw_off = static_cast<std::size_t>(section->offset);
-                const auto sec_size = static_cast<std::size_t>(section->size);
-
-                if (raw_off + sec_size > data.size())
-                    return std::nullopt;
-
-                ExtractedSection out;
-                out.virtual_base_addr = static_cast<std::uintptr_t>(section->addr);
-                out.raw_base_addr = raw_off;
-                out.data.assign(data.data() + raw_off, data.data() + raw_off + sec_size);
-                return out;
-            }
-
-            cmd_offset += lc->cmdsize;
-        }
-
-        return std::nullopt;
-    }
-
-    [[nodiscard]]
-    std::optional<ExtractedSection> get_macho_section_by_name_from_memory(const std::span<const std::byte> data,
-                                                                          const std::string_view& section_name)
-    {
-        if (data.size() < sizeof(std::uint32_t))
-            return std::nullopt;
-
-        std::uint32_t magic{};
-        std::memcpy(&magic, data.data(), sizeof(magic));
-
-        if (magic == mh_magic_64 || magic == mh_cigam_64)
-            return extract_section_from_memory_impl<MachHeader64, SegmentCommand64, Section64, lc_segment_64>(
-                    data, section_name);
-
-        if (magic == mh_magic_32 || magic == mh_cigam_32)
-            return extract_section_from_memory_impl<MachHeader32, SegmentCommand32, Section32, lc_segment>(data,
-                                                                                                           section_name);
-
-        return std::nullopt;
-    }
-
     [[nodiscard]]
     std::optional<ExtractedSection> get_macho_section_by_name(const std::filesystem::path& path,
                                                               const std::string_view& section_name)
@@ -437,27 +346,4 @@ namespace omath
                                  .raw_base_addr = macho_section->raw_base_addr,
                                  .target_offset = offset};
     }
-
-    std::optional<SectionScanResult>
-    MachOPatternScanner::scan_for_pattern_in_memory_file(const std::span<const std::byte> file_data,
-                                                         const std::string_view& pattern,
-                                                         const std::string_view& target_section_name)
-    {
-        const auto section = get_macho_section_by_name_from_memory(file_data, target_section_name);
-
-        if (!section.has_value()) [[unlikely]]
-            return std::nullopt;
-
-        const auto scan_result =
-                PatternScanner::scan_for_pattern(section->data.cbegin(), section->data.cend(), pattern);
-
-        if (scan_result == section->data.cend())
-            return std::nullopt;
-
-        const auto offset = std::distance(section->data.begin(), scan_result);
-
-        return SectionScanResult{.virtual_base_addr = section->virtual_base_addr,
-                                 .raw_base_addr = section->raw_base_addr,
-                                 .target_offset = offset};
-    }
 } // namespace omath

source/utility/pe_pattern_scan.cpp

@@ -7,7 +7,6 @@
 #include <span>
 #include <stdexcept>
 #include <variant>
-#include <vector>
 
 // Internal PE shit defines
 // Big thx for linuxpe sources as ref
@@ -245,78 +244,6 @@ namespace
         std::vector<std::byte> data;
     };
 
-    [[nodiscard]]
-    std::optional<ExtractedSection> extract_section_from_pe_memory(const std::span<const std::byte> data,
-                                                                   const std::string_view& section_name)
-    {
-        if (data.size() < sizeof(DosHeader))
-            return std::nullopt;
-
-        const auto* dos_header = reinterpret_cast<const DosHeader*>(data.data());
-
-        if (invalid_dos_header_file(*dos_header))
-            return std::nullopt;
-
-        const auto nt_off = static_cast<std::size_t>(dos_header->e_lfanew);
-
-        if (nt_off + sizeof(ImageNtHeaders<NtArchitecture::x32_bit>) > data.size())
-            return std::nullopt;
-
-        const auto* x86_hdrs =
-                reinterpret_cast<const ImageNtHeaders<NtArchitecture::x32_bit>*>(data.data() + nt_off);
-
-        NtHeaderVariant nt_headers;
-        if (x86_hdrs->optional_header.magic == opt_hdr32_magic)
-            nt_headers = *x86_hdrs;
-        else if (x86_hdrs->optional_header.magic == opt_hdr64_magic)
-        {
-            if (nt_off + sizeof(ImageNtHeaders<NtArchitecture::x64_bit>) > data.size())
-                return std::nullopt;
-            nt_headers = *reinterpret_cast<const ImageNtHeaders<NtArchitecture::x64_bit>*>(data.data() + nt_off);
-        }
-        else
-            return std::nullopt;
-
-        if (invalid_nt_header_file(nt_headers))
-            return std::nullopt;
-
-        return std::visit(
-                [&data, &section_name, nt_off](const auto& concrete_headers) -> std::optional<ExtractedSection>
-                {
-                    constexpr std::size_t sig_size = sizeof(concrete_headers.signature);
-                    const auto section_table_off = nt_off + sig_size + sizeof(FileHeader)
-                                                   + concrete_headers.file_header.size_optional_header;
-
-                    for (std::size_t i = 0; i < concrete_headers.file_header.num_sections; ++i)
-                    {
-                        const auto sh_off = section_table_off + i * sizeof(SectionHeader);
-                        if (sh_off + sizeof(SectionHeader) > data.size())
-                            return std::nullopt;
-
-                        const auto* section = reinterpret_cast<const SectionHeader*>(data.data() + sh_off);
-
-                        if (std::string_view(section->name) != section_name)
-                            continue;
-
-                        const auto raw_off = static_cast<std::size_t>(section->ptr_raw_data);
-                        const auto raw_size = static_cast<std::size_t>(section->size_raw_data);
-
-                        if (raw_off + raw_size > data.size())
-                            return std::nullopt;
-
-                        std::vector<std::byte> section_data(data.data() + raw_off, data.data() + raw_off + raw_size);
-
-                        return ExtractedSection{
-                                .virtual_base_addr = static_cast<std::uintptr_t>(
-                                        section->virtual_address + concrete_headers.optional_header.image_base),
-                                .raw_base_addr = raw_off,
-                                .data = std::move(section_data)};
-                    }
-                    return std::nullopt;
-                },
-                nt_headers);
-    }
-
     [[nodiscard]]
     std::optional<ExtractedSection> extract_section_from_pe_file(const std::filesystem::path& path_to_file,
                                                                  const std::string_view& section_name)
@@ -456,27 +383,4 @@ namespace omath
                                  .raw_base_addr = pe_section->raw_base_addr,
                                  .target_offset = offset};
     }
-
-    std::optional<SectionScanResult>
-    PePatternScanner::scan_for_pattern_in_memory_file(const std::span<const std::byte> file_data,
-                                                      const std::string_view& pattern,
-                                                      const std::string_view& target_section_name)
-    {
-        const auto pe_section = extract_section_from_pe_memory(file_data, target_section_name);
-
-        if (!pe_section.has_value()) [[unlikely]]
-            return std::nullopt;
-
-        const auto scan_result =
-                PatternScanner::scan_for_pattern(pe_section->data.cbegin(), pe_section->data.cend(), pattern);
-
-        if (scan_result == pe_section->data.cend())
-            return std::nullopt;
-
-        const auto offset = std::distance(pe_section->data.begin(), scan_result);
-
-        return SectionScanResult{.virtual_base_addr = pe_section->virtual_base_addr,
-                                 .raw_base_addr = pe_section->raw_base_addr,
-                                 .target_offset = offset};
-    }
 } // namespace omath

tests/CMakeLists.txt

@@ -4,7 +4,7 @@ project(unit_tests)
 
 include(GoogleTest)
 
-file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/general/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/engines/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp")
+file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/general/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/engines/*.cpp")
 add_executable(${PROJECT_NAME} ${UNIT_TESTS_SOURCES} main.cpp)
 
 set_target_properties(

tests/engines/unit_test_cry_engine.cpp

@@ -237,54 +237,4 @@ 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,51 +405,3 @@ 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);
-}