added files

fixed tests
updated contributing
2026-04-18 21:43:27 +00:00 · 2026-04-08 18:23:07 +03:00 · 2026-04-08 15:34:10 +03:00 · 2026-04-03 20:59:34 +03:00 · 2026-03-28 14:22:36 +03:00 · 2026-03-25 03:37:35 +03:00
162 changed files with 12229 additions and 1014 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -12,6 +12,7 @@ AlignConsecutiveMacros: AcrossEmptyLinesAndComments
 AlignTrailingComments: false
 AllowShortBlocksOnASingleLine: Never
 AllowShortFunctionsOnASingleLine: None
+AllowShortLambdasOnASingleLine: None
 AllowShortIfStatementsOnASingleLine: false
 AllowShortLoopsOnASingleLine: false
 BreakTemplateDeclarations: Leave
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+open_collective: libomathorg
+github: orange-cpp
--- a/.github/workflows/cmake-multi-platform.yml
+++ b/.github/workflows/cmake-multi-platform.yml
@@ -107,7 +107,7 @@ jobs:
            -DOMATH_BUILD_TESTS=ON \
            -DOMATH_BUILD_BENCHMARK=OFF \
            -DOMATH_ENABLE_COVERAGE=${{ matrix.coverage == true && 'ON' || 'OFF' }} \
-            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua"

      - name: Build
        shell: bash
@@ -193,7 +193,7 @@ jobs:
            -DOMATH_BUILD_TESTS=ON \
            -DOMATH_BUILD_BENCHMARK=OFF \
            -DOMATH_ENABLE_COVERAGE=OFF \
-            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua"

      - name: Build
        shell: bash
@@ -234,7 +234,7 @@ jobs:
            -DOMATH_ENABLE_COVERAGE=ON \
            -DOMATH_THREAT_WARNING_AS_ERROR=OFF \
            -DCMAKE_BUILD_TYPE=Debug \
-            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua"
          cmake --build cmake-build/build/${{ matrix.preset }} --config Debug --target unit_tests omath

      - name: Run Tests (Generates .profraw)
@@ -370,16 +370,19 @@ 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' }} \
-            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua"

      - name: Build
        shell: bash
        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

@@ -450,7 +453,7 @@ jobs:
            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
            -DOMATH_BUILD_TESTS=ON \
            -DOMATH_BUILD_BENCHMARK=OFF \
-            -DVCPKG_MANIFEST_FEATURES="imgui;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"

      - name: Build
        shell: bash
@@ -509,7 +512,7 @@ jobs:
            cmake --preset ${{ matrix.preset }} \
              -DOMATH_BUILD_TESTS=ON \
              -DOMATH_BUILD_BENCHMARK=OFF \
-              -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests" \
+              -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua" \
              -DVCPKG_INSTALL_OPTIONS="--allow-unsupported"
            cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
            ./out/Release/unit_tests
@@ -581,7 +584,7 @@ jobs:
            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
            -DOMATH_BUILD_TESTS=ON \
            -DOMATH_BUILD_BENCHMARK=OFF \
-            -DVCPKG_MANIFEST_FEATURES="imgui;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"

      - name: Build
        shell: bash
@@ -650,7 +653,7 @@ jobs:
            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
            -DOMATH_BUILD_TESTS=ON \
            -DOMATH_BUILD_BENCHMARK=OFF \
-            -DVCPKG_MANIFEST_FEATURES="imgui;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"

      - name: Build
        shell: bash
@@ -735,7 +738,7 @@ jobs:
            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported" \
            -DOMATH_BUILD_TESTS=ON \
            -DOMATH_BUILD_BENCHMARK=OFF \
-            -DVCPKG_MANIFEST_FEATURES="imgui;tests"
+            -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"

      - name: Build
        run: |
@@ -800,7 +803,7 @@ jobs:
            -DOMATH_BUILD_TESTS=ON \
            -DOMATH_BUILD_BENCHMARK=ON \
            -DOMATH_ENABLE_VALGRIND=ON \
-            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;benchmark"
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;lua;tests;benchmark"

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

 jobs:
+  ##############################################################################
+  # 0)  Documentation  –  MkDocs
+  ##############################################################################
+  docs-release:
+    name: Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Install mkdocs and dependencies
+        run: pip install mkdocs mkdocs-bootswatch
+
+      - name: Build documentation
+        run: mkdocs build --strict
+
+      - name: Package
+        run: tar -czf omath-docs.tar.gz -C site .
+
+      - name: Upload release asset
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: gh release upload "${{ github.event.release.tag_name }}" omath-docs.tar.gz --clobber
+
  ##############################################################################
  # 1)  Linux  –  Clang / Ninja
  ##############################################################################
--- a/.idea/editor.xml
+++ b/.idea/editor.xml
@@ -17,7 +17,7 @@
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppBoostFormatTooManyArgs/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppCStyleCast/@EntryIndexedValue" value="SUGGESTION" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppCVQualifierCanNotBeAppliedToReference/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassCanBeFinal/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassCanBeFinal/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassIsIncomplete/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassNeedsConstructorBecauseOfUninitializedMember/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppClassNeverUsed/@EntryIndexedValue" value="WARNING" type="string" />
@@ -103,14 +103,14 @@
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppImplicitDefaultConstructorNotAvailable/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppIncompatiblePointerConversion/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppIncompleteSwitchStatement/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppInconsistentNaming/@EntryIndexedValue" value="HINT" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppInconsistentNaming/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppIntegralToPointerConversion/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppInvalidLineContinuation/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppJoinDeclarationAndAssignment/@EntryIndexedValue" value="SUGGESTION" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLambdaCaptureNeverUsed/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableMayBeConst/@EntryIndexedValue" value="HINT" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableMightNotBeInitialized/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableWithNonTrivialDtorIsNeverUsed/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLocalVariableWithNonTrivialDtorIsNeverUsed/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppLongFloat/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppMemberFunctionMayBeConst/@EntryIndexedValue" value="SUGGESTION" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppMemberFunctionMayBeStatic/@EntryIndexedValue" value="SUGGESTION" type="string" />
@@ -202,7 +202,7 @@
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticDataMemberInUnnamedStruct/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStaticSpecifierOnAnonymousNamespaceMember/@EntryIndexedValue" value="SUGGESTION" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppStringLiteralToCharPointerConversion/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTabsAreDisallowed/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateArgumentsCanBeDeduced/@EntryIndexedValue" value="HINT" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterNeverUsed/@EntryIndexedValue" value="HINT" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppTemplateParameterShadowing/@EntryIndexedValue" value="WARNING" type="string" />
@@ -216,7 +216,7 @@
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaEndRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnmatchedPragmaRegionDirective/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnamedNamespaceInHeaderFile/@EntryIndexedValue" value="WARNING" type="string" />
-    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="WARNING" type="string" />
+    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnnecessaryWhitespace/@EntryIndexedValue" value="DO_NOT_SHOW" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnsignedZeroComparison/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUnusedIncludeDirective/@EntryIndexedValue" value="WARNING" type="string" />
    <option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppUseAlgorithmWithCount/@EntryIndexedValue" value="SUGGESTION" type="string" />
--- a/.luarc.json
+++ b/.luarc.json
@@ -0,0 +1,5 @@
+{
+    "diagnostics.globals": [
+        "omath"
+    ]
+}
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -31,6 +31,9 @@ option(OMATH_SUPRESS_SAFETY_CHECKS
 option(OMATH_ENABLE_COVERAGE "Enable coverage" OFF)
 option(OMATH_ENABLE_FORCE_INLINE
       "Will for compiler to make some functions to be force inlined no matter what" ON)
+
+option(OMATH_ENABLE_LUA
+        "omath bindings for lua" OFF)
 if(VCPKG_MANIFEST_FEATURES)
    foreach(omath_feature IN LISTS VCPKG_MANIFEST_FEATURES)
        if(omath_feature STREQUAL "imgui")
@@ -43,6 +46,8 @@ if(VCPKG_MANIFEST_FEATURES)
            set(OMATH_BUILD_BENCHMARK ON)
        elseif(omath_feature STREQUAL "examples")
            set(OMATH_BUILD_EXAMPLES ON)
+        elseif(omath_feature STREQUAL "lua")
+            set(OMATH_ENABLE_LUA ON)
        endif()

    endforeach()
@@ -72,6 +77,7 @@ if(${PROJECT_IS_TOP_LEVEL})
    message(STATUS "[${PROJECT_NAME}]: Building using vcpkg ${OMATH_BUILD_VIA_VCPKG}")
    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}")
 endif()

 file(GLOB_RECURSE OMATH_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp")
@@ -83,6 +89,17 @@ else()
    add_library(${PROJECT_NAME} STATIC ${OMATH_SOURCES} ${OMATH_HEADERS})
 endif()

+if (OMATH_ENABLE_LUA)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_LUA)
+
+    find_package(Lua REQUIRED)
+    target_include_directories(${PROJECT_NAME} PRIVATE ${LUA_INCLUDE_DIR})
+    target_link_libraries(${PROJECT_NAME} PRIVATE ${LUA_LIBRARIES})
+
+    find_path(SOL2_INCLUDE_DIRS "sol/abort.hpp")
+    target_include_directories(${PROJECT_NAME} PRIVATE ${SOL2_INCLUDE_DIRS})
+endif ()
+
 add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})

 target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_VERSION="${PROJECT_VERSION}")
@@ -174,6 +191,12 @@ elseif(OMATH_THREAT_WARNING_AS_ERROR)
    target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Wextra -Wpedantic -Werror)
 endif()

+if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+    target_compile_options(${PROJECT_NAME} PRIVATE /bigobj)
+endif()
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_HOST_SYSTEM_NAME EQUAL "Windows")
+    target_compile_options(${PROJECT_NAME} PRIVATE -mbig-obj)
+endif()
 # Windows SDK redefine min/max via preprocessor and break std::min and std::max
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
    target_compile_definitions(${PROJECT_NAME} INTERFACE NOMINMAX)
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -145,7 +145,7 @@
      "hidden": true,
      "inherits": ["linux-base", "vcpkg-base"],
      "cacheVariables": {
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2"
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;lua"
      }
    },
    {
@@ -235,7 +235,7 @@
      "hidden": true,
      "inherits": ["darwin-base", "vcpkg-base"],
      "cacheVariables": {
-        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples"
+        "VCPKG_MANIFEST_FEATURES": "tests;imgui;avx2;examples;lua"
      }
    },
    {
--- a/37
+++ b/37
@@ -0,0 +1,37 @@
+##   List of maintainers for the omath library
+
+## This file purpose is to give newcomers to the project the responsible
+## developers when submitting a pull request on GitHub, or opening a bug
+## report in issues.
+
+## This file will notably establish who is responsible for a specific
+## area of omath. Being a maintainer means the following:
+##  - that person has good knownledge in the area
+##  - that person is able to enforce consistency in the area
+##  - that person may be available for giving help in the area
+##  - that person has push access on the repository
+## Being a maintainer does not mean the following:
+##  - that person is dedicated to the area
+##  - that person is working full-time on the area/on omath
+##  - that person is paid
+##  - that person is always available
+
+
+# omath core source code
+/source @orange-cpp
+/include @orange-cpp
+
+# Tests and becnchmarks
+/benchmark @orange-cpp
+/tests @orange-cpp @luadebug
+
+# Examples and documentation
+/examples @luadebug @orange-cpp
+/docs @orange-cpp
+
+# Misc like formating
+/scripts @luadebug
+/pixi @luadebug
+
+# CI/CD
+/.github/workflows @luadbg @orange-cpp
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,32 +1,36 @@
-## 🤝 Contributing to OMath or other Orange's Projects
+# Contributing

-### ❕ Prerequisites
+## Prerequisites

- A working up-to-date OMath installation
- C++ 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))
+- 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)

-### ⏬ Setting up OMath
+For questions, create a draft PR or reach out via [Telegram](https://t.me/orange_cpp).

-Please read INSTALL.md file in repository
+## Workflow

-### 🔀 Pull requests and Branches
+1. [Fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo) the repository.
+2. Create a feature branch from `main`.
+3. Make your changes, ensuring tests pass.
+4. Open a [pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork) against `main`.

-In order to send code back to the official OMath repository, you must first create a copy of OMath on your github
-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.
+## Code Style

-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.
+Follow the project `.clang-format`. Run `clang-format` before committing.

-### 📜 Code-Style
+## Building

-The orange code-style can be found in `.clang-format`.
+Use one of the CMake presets defined in `CMakePresets.json`:

-### 📦 Building
+```bash
+cmake --preset <preset-name> -DOMATH_BUILD_TESTS=ON
+cmake --build --preset <preset-name>
+```

-OMath has already created the  `cmake-build` and `out` directories where cmake/bin files are located. By default, you
-can build OMath by running `cmake --build cmake-build/build/windows-release --target omath -j 6` in the source
-directory.
+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.
--- a/CREDITS.md
+++ b/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!

--- a/INSTALL.md
+++ b/INSTALL.md
@@ -1,6 +1,6 @@
 # 📥Installation Guide

-## <img width="28px" src="https://vcpkg.io/assets/mark/mark.svg" /> Using vcpkg
+## <img width="28px" src="https://vcpkg.io/assets/mark/mark.svg" /> Using vcpkg (recomended)
 **Note**: Support vcpkg for package management
 1. Install [vcpkg](https://github.com/microsoft/vcpkg)
 2. Run the following command to install the orange-math package:
@@ -28,6 +28,69 @@ target("...")
    add_packages("omath")
 ```

+## <img width="28px" src="https://conan.io/favicon.png" /> Using Conan
+**Note**: Support Conan for package management
+1. Install [Conan](https://conan.io/downloads)
+2. Run the following command to install the omath package:
+```
+conan install --requires="omath/[*]" --build=missing
+```
+conanfile.txt
+```ini
+[requires]
+omath/[*]
+
+[generators]
+CMakeDeps
+CMakeToolchain
+```
+CMakeLists.txt
+```cmake
+find_package(omath CONFIG REQUIRED)
+target_link_libraries(main PRIVATE omath::omath)
+```
+For more details, see the [Conan documentation](https://docs.conan.io/2/).
+
+## <img width="28px" src="https://github.githubassets.com/favicons/favicon.svg" /> Using prebuilt binaries (GitHub Releases)
+
+**Note**: This is the fastest option if you don’t want to build from source.
+
+1. **Go to the Releases page**
+   - Open the project’s GitHub **Releases** page and choose the latest version.
+
+2. **Download the correct asset for your platform**
+   - Pick the archive that matches your OS and architecture (for example: Windows x64 / Linux x64 / macOS arm64).
+
+3. **Extract the archive**
+   - You should end up with something like:
+     - `include/` (headers)
+     - `lib/` or `bin/` (library files / DLLs)
+     - sometimes `cmake/` (CMake package config)
+
+4. **Use it in your project**
+
+   ### Option A: CMake package (recommended if the release includes CMake config files)
+   If the extracted folder contains something like `lib/cmake/omath` or `cmake/omath`, you can point CMake to it:
+
+   ```cmake
+   # Example: set this to the extracted prebuilt folder
+   list(APPEND CMAKE_PREFIX_PATH "path/to/omath-prebuilt")
+
+   find_package(omath CONFIG REQUIRED)
+   target_link_libraries(main PRIVATE omath::omath)
+   ```
+   ### Option B: Manual include + link (works with any layout)
+   If there’s no CMake package config, link it manually:
+   ```cmake
+   target_include_directories(main PRIVATE "path/to/omath-prebuilt/include")
+
+    # Choose ONE depending on what you downloaded:
+    # - Static library: .lib / .a
+    # - Shared library: .dll + .lib import (Windows), .so (Linux), .dylib (macOS)
+    
+    target_link_directories(main PRIVATE "path/to/omath-prebuilt/lib")
+    target_link_libraries(main PRIVATE omath)  # or the actual library filename
+    ```
 ## <img width="28px" src="https://upload.wikimedia.org/wikipedia/commons/e/ef/CMake_logo.svg?" /> Build from source using CMake 
 1. **Preparation**
   
--- a/README.md
+++ b/README.md
@@ -9,11 +9,12 @@
 [![CodeFactor](https://www.codefactor.io/repository/github/orange-cpp/omath/badge)](https://www.codefactor.io/repository/github/orange-cpp/omath)
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/orange-cpp/omath/cmake-multi-platform.yml)
 [![Vcpkg package](https://repology.org/badge/version-for-repo/vcpkg/orange-math.svg)](https://repology.org/project/orange-math/versions)
+![Conan Center](https://img.shields.io/conan/v/omath)
 ![GitHub forks](https://img.shields.io/github/forks/orange-cpp/omath)
 [![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 library that doesn't have legacy C++ code.
+OMath is a 100% independent, constexpr template blazingly fast math/physics/games/mods/cheats development framework 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>
@@ -83,6 +84,8 @@ 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.
 - **Battle tested**: It's already used by some big players on the market like wraith.su and bluedream.ltd
 <div align = center>
 
--- a/benchmark/benchmark_collision.cpp
+++ b/benchmark/benchmark_collision.cpp
@@ -0,0 +1,161 @@
+//
+// Created by Vlad on 3/2/2026.
+//
+#include <benchmark/benchmark.h>
+#include <memory_resource>
+#include <omath/collision/epa_algorithm.hpp>
+#include <omath/collision/gjk_algorithm.hpp>
+#include <omath/engines/source_engine/collider.hpp>
+#include <omath/engines/source_engine/mesh.hpp>
+
+using Mesh = omath::source_engine::Mesh;
+using Collider = omath::source_engine::MeshCollider;
+using Gjk = omath::collision::GjkAlgorithm<Collider>;
+using Epa = omath::collision::Epa<Collider>;
+
+namespace
+{
+    // Unit cube with half-extent 1 — 8 vertices in [-1,1]^3.
+    const std::vector<omath::primitives::Vertex<>> k_cube_vbo = {
+        { { -1.f, -1.f, -1.f }, {}, {} },
+        { { -1.f, -1.f,  1.f }, {}, {} },
+        { { -1.f,  1.f, -1.f }, {}, {} },
+        { { -1.f,  1.f,  1.f }, {}, {} },
+        { {  1.f,  1.f,  1.f }, {}, {} },
+        { {  1.f,  1.f, -1.f }, {}, {} },
+        { {  1.f, -1.f,  1.f }, {}, {} },
+        { {  1.f, -1.f, -1.f }, {}, {} },
+    };
+    const std::vector<omath::Vector3<std::uint32_t>> k_empty_vao{};
+} // namespace
+
+// ---------------------------------------------------------------------------
+// GJK benchmarks
+// ---------------------------------------------------------------------------
+
+// Separated cubes — origin distance 2.1, no overlap.
+// Exercises the early-exit path and the centroid-based initial direction.
+static void BM_Gjk_Separated(benchmark::State& state)
+{
+    const Collider a{Mesh{k_cube_vbo, k_empty_vao}};
+
+    Mesh mesh_b{k_cube_vbo, k_empty_vao};
+    mesh_b.set_origin({0.f, 2.1f, 0.f});
+    const Collider b{mesh_b};
+
+    for ([[maybe_unused]] auto _ : state)
+        benchmark::DoNotOptimize(Gjk::is_collide(a, b));
+}
+
+// Overlapping cubes — B offset by 0.5 along X, ~1.5 units penetration depth.
+static void BM_Gjk_Overlapping(benchmark::State& state)
+{
+    const Collider a{Mesh{k_cube_vbo, k_empty_vao}};
+
+    Mesh mesh_b{k_cube_vbo, k_empty_vao};
+    mesh_b.set_origin({0.5f, 0.f, 0.f});
+    const Collider b{mesh_b};
+
+    for ([[maybe_unused]] auto _ : state)
+        benchmark::DoNotOptimize(Gjk::is_collide(a, b));
+}
+
+// Identical cubes at the same origin — deep overlap / worst case for GJK.
+static void BM_Gjk_SameOrigin(benchmark::State& state)
+{
+    const Collider a{Mesh{k_cube_vbo, k_empty_vao}};
+    const Collider b{Mesh{k_cube_vbo, k_empty_vao}};
+
+    for ([[maybe_unused]] auto _ : state)
+        benchmark::DoNotOptimize(Gjk::is_collide(a, b));
+}
+
+// ---------------------------------------------------------------------------
+// EPA benchmarks
+// ---------------------------------------------------------------------------
+
+// EPA with a pre-allocated monotonic buffer (reset each iteration).
+// Isolates algorithmic cost from allocator overhead.
+static void BM_Epa_MonotonicBuffer(benchmark::State& state)
+{
+    const Collider a{Mesh{k_cube_vbo, k_empty_vao}};
+
+    Mesh mesh_b{k_cube_vbo, k_empty_vao};
+    mesh_b.set_origin({0.5f, 0.f, 0.f});
+    const Collider b{mesh_b};
+
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+    if (!hit)
+        return; // shouldn't happen, but guard for safety
+
+    constexpr Epa::Params params{.max_iterations = 64, .tolerance = 1e-4f};
+
+    // Pre-allocate a 32 KiB stack buffer — enough for typical polytope growth.
+    constexpr std::size_t k_buf_size = 32768;
+    alignas(std::max_align_t) char buf[k_buf_size];
+    std::pmr::monotonic_buffer_resource mr{buf, k_buf_size, std::pmr::null_memory_resource()};
+
+    for ([[maybe_unused]] auto _ : state)
+    {
+        mr.release(); // reset the buffer without touching the upstream resource
+        benchmark::DoNotOptimize(Epa::solve(a, b, simplex, params, mr));
+    }
+}
+
+// EPA with the default (malloc-backed) memory resource.
+// Shows total cost including allocator pressure.
+static void BM_Epa_DefaultResource(benchmark::State& state)
+{
+    const Collider a{Mesh{k_cube_vbo, k_empty_vao}};
+
+    Mesh mesh_b{k_cube_vbo, k_empty_vao};
+    mesh_b.set_origin({0.5f, 0.f, 0.f});
+    const Collider b{mesh_b};
+
+    const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+    if (!hit)
+        return;
+
+    constexpr Epa::Params params{.max_iterations = 64, .tolerance = 1e-4f};
+
+    for ([[maybe_unused]] auto _ : state)
+        benchmark::DoNotOptimize(Epa::solve(a, b, simplex, params));
+}
+
+// ---------------------------------------------------------------------------
+// Combined GJK + EPA pipeline
+// ---------------------------------------------------------------------------
+
+// Full collision pipeline: GJK detects contact, EPA resolves penetration.
+// This is the hot path in a physics engine tick.
+static void BM_GjkEpa_Pipeline(benchmark::State& state)
+{
+    const Collider a{Mesh{k_cube_vbo, k_empty_vao}};
+
+    Mesh mesh_b{k_cube_vbo, k_empty_vao};
+    mesh_b.set_origin({0.5f, 0.f, 0.f});
+    const Collider b{mesh_b};
+
+    constexpr Epa::Params params{.max_iterations = 64, .tolerance = 1e-4f};
+
+    constexpr std::size_t k_buf_size = 32768;
+    alignas(std::max_align_t) char buf[k_buf_size];
+    std::pmr::monotonic_buffer_resource mr{buf, k_buf_size, std::pmr::null_memory_resource()};
+
+    for ([[maybe_unused]] auto _ : state)
+    {
+        mr.release();
+        const auto [hit, simplex] = Gjk::is_collide_with_simplex_info(a, b);
+        if (hit)
+            benchmark::DoNotOptimize(Epa::solve(a, b, simplex, params, mr));
+    }
+}
+
+BENCHMARK(BM_Gjk_Separated)->Iterations(100'000);
+BENCHMARK(BM_Gjk_Overlapping)->Iterations(100'000);
+BENCHMARK(BM_Gjk_SameOrigin)->Iterations(100'000);
+
+BENCHMARK(BM_Epa_MonotonicBuffer)->Iterations(100'000);
+BENCHMARK(BM_Epa_DefaultResource)->Iterations(100'000);
+
+BENCHMARK(BM_GjkEpa_Pipeline)->Iterations(100'000);
--- a/docs/install.md
+++ b/docs/install.md
@@ -1,6 +1,6 @@
-# Installation
+# Installation Guide

-## <img width="28px" src="https://vcpkg.io/assets/mark/mark.svg" /> Using vcpkg
+## <img width="28px" src="https://vcpkg.io/assets/mark/mark.svg" /> Using vcpkg (recomended)
 **Note**: Support vcpkg for package management
 1. Install [vcpkg](https://github.com/microsoft/vcpkg)
 2. Run the following command to install the orange-math package:
@@ -28,6 +28,69 @@ target("...")
    add_packages("omath")
 ```

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

@@ -62,7 +125,7 @@ target("...")
   Use **\<platform\>-\<build configuration\>** preset to build suitable version for yourself. Like **windows-release** or **linux-release**.

   | Platform Name | Build Config  |
-          |---------------|---------------|
+       |---------------|---------------|
   | windows       | release/debug |
   | linux         | release/debug |
   | darwin        | release/debug |
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -2,6 +2,7 @@ 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)
--- a/examples/example_barycentric/example_barycentric.cpp
+++ b/examples/example_barycentric/example_barycentric.cpp
@@ -71,18 +71,18 @@ void drawChar(char c, float x, float y, float scale, const Color& color, std::ve
        lines.push_back(x + x1 * w);
        lines.push_back(y + y1 * h);
        lines.push_back(0.0f);
-        lines.push_back(color.x);
-        lines.push_back(color.y);
-        lines.push_back(color.z);
+        lines.push_back(color.value().x);
+        lines.push_back(color.value().y);
+        lines.push_back(color.value().z);
        lines.push_back(1.0f); // size
        lines.push_back(1.0f); // isLine

        lines.push_back(x + x2 * w);
        lines.push_back(y + y2 * h);
        lines.push_back(0.0f);
-        lines.push_back(color.x);
-        lines.push_back(color.y);
-        lines.push_back(color.z);
+        lines.push_back(color.value().x);
+        lines.push_back(color.value().y);
+        lines.push_back(color.value().z);
        lines.push_back(1.0f); // size
        lines.push_back(1.0f); // isLine
    };
--- a/examples/example_hud/CMakeLists.txt
+++ b/examples/example_hud/CMakeLists.txt
@@ -0,0 +1,16 @@
+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)
--- a/examples/example_hud/gui/main_window.cpp
+++ b/examples/example_hud/gui/main_window.cpp
@@ -0,0 +1,263 @@
+//
+// 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
--- a/examples/example_hud/gui/main_window.hpp
+++ b/examples/example_hud/gui/main_window.hpp
@@ -0,0 +1,94 @@
+//
+// 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
--- a/examples/example_hud/main.cpp
+++ b/examples/example_hud/main.cpp
@@ -0,0 +1,8 @@
+//
+// Created by orange on 13.03.2026.
+//
+#include "gui/main_window.hpp"
+int main()
+{
+    imgui_desktop::gui::MainWindow("omath::hud", 800, 600).Run();
+}
--- a/include/omath/3d_primitives/aabb.hpp
+++ b/include/omath/3d_primitives/aabb.hpp
@@ -0,0 +1,28 @@
+//
+// 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
--- a/include/omath/algorithm/targeting.hpp
+++ b/include/omath/algorithm/targeting.hpp
@@ -0,0 +1,98 @@
+//
+// Created by Vladislav on 19.03.2026.
+//
+
+#pragma once
+#include "omath/linear_algebra/vector3.hpp"
+#include <functional>
+#include <iterator>
+#include <optional>
+#include <ranges>
+
+namespace omath::algorithm
+{
+    template<class CameraType, std::input_or_output_iterator IteratorType, class FilterT>
+    requires std::is_invocable_r_v<bool, std::function<FilterT>, std::iter_reference_t<IteratorType>>
+    [[nodiscard]]
+    IteratorType get_closest_target_by_fov(const IteratorType& begin, const IteratorType& end, const CameraType& camera,
+                                           auto get_position,
+                                           const std::optional<std::function<FilterT>>& filter_func = std::nullopt)
+    {
+        auto best_target = end;
+        const auto& camera_angles = camera.get_view_angles();
+        const Vector2<float> camera_angles_vec = {camera_angles.pitch.as_degrees(), camera_angles.yaw.as_degrees()};
+
+        for (auto current = begin; current != end; current = std::next(current))
+        {
+            if (filter_func && !filter_func.value()(*current))
+                continue;
+
+            if (best_target == end)
+            {
+                best_target = current;
+                continue;
+            }
+            const auto current_target_angles = camera.calc_look_at_angles(get_position(*current));
+            const auto best_target_angles = camera.calc_look_at_angles(get_position(*best_target));
+
+            const auto current_target_distance = camera_angles_vec.distance_to(current_target_angles.as_vector3());
+            const auto best_target_distance = camera_angles.as_vector3().distance_to(best_target_angles.as_vector3());
+            if (current_target_distance < best_target_distance)
+                best_target = current;
+        }
+        return best_target;
+    }
+
+    template<class CameraType, std::ranges::range RangeType, class FilterT>
+    requires std::is_invocable_r_v<bool, std::function<FilterT>,
+                                   std::ranges::range_reference_t<const RangeType>>
+    [[nodiscard]]
+    auto get_closest_target_by_fov(const RangeType& range, const CameraType& camera,
+                                   auto get_position,
+                                   const std::optional<std::function<FilterT>>& filter_func = std::nullopt)
+    {
+        return get_closest_target_by_fov<CameraType, decltype(std::ranges::begin(range)), FilterT>(
+                std::ranges::begin(range), std::ranges::end(range), camera, get_position, filter_func);
+    }
+
+    // ── By world-space distance ───────────────────────────────────────────────
+
+    template<std::input_or_output_iterator IteratorType, class FilterT>
+    requires std::is_invocable_r_v<bool, std::function<FilterT>, std::iter_reference_t<IteratorType>>
+    [[nodiscard]]
+    IteratorType get_closest_target_by_distance(const IteratorType& begin, const IteratorType& end,
+                                                const Vector3<float>& origin, auto get_position,
+                                                const std::optional<std::function<FilterT>>& filter_func = std::nullopt)
+    {
+        auto best_target = end;
+
+        for (auto current = begin; current != end; current = std::next(current))
+        {
+            if (filter_func && !filter_func.value()(*current))
+                continue;
+
+            if (best_target == end)
+            {
+                best_target = current;
+                continue;
+            }
+
+            if (origin.distance_to(get_position(*current)) < origin.distance_to(get_position(*best_target)))
+                best_target = current;
+        }
+        return best_target;
+    }
+
+    template<std::ranges::range RangeType, class FilterT>
+    requires std::is_invocable_r_v<bool, std::function<FilterT>,
+                                   std::ranges::range_reference_t<const RangeType>>
+    [[nodiscard]]
+    auto get_closest_target_by_distance(const RangeType& range, const Vector3<float>& origin,
+                                        auto get_position,
+                                        const std::optional<std::function<FilterT>>& filter_func = std::nullopt)
+    {
+        return get_closest_target_by_distance<decltype(std::ranges::begin(range)), FilterT>(
+                std::ranges::begin(range), std::ranges::end(range), origin, get_position, filter_func);
+    }
+
+} // namespace omath::algorithm
--- a/include/omath/collision/bvh_tree.hpp
+++ b/include/omath/collision/bvh_tree.hpp
@@ -0,0 +1,412 @@
+//
+// Created by Orange on 04/08/2026.
+//
+
+#pragma once
+#include "omath/3d_primitives/aabb.hpp"
+#include "omath/collision/line_tracer.hpp"
+#include <algorithm>
+#include <cstdint>
+#include <numeric>
+#include <span>
+#include <vector>
+
+namespace omath::collision
+{
+    template<class Type = float>
+    class BvhTree final
+    {
+    public:
+        using AabbType = primitives::Aabb<Type>;
+
+        struct HitResult
+        {
+            std::size_t object_index;
+            Type distance_sqr;
+        };
+
+        BvhTree() = default;
+
+        explicit BvhTree(std::span<const AabbType> aabbs)
+            : m_aabbs(aabbs.begin(), aabbs.end())
+        {
+            if (aabbs.empty())
+                return;
+
+            m_indices.resize(aabbs.size());
+            std::iota(m_indices.begin(), m_indices.end(), std::size_t{0});
+
+            m_nodes.reserve(aabbs.size() * 2);
+
+            build(m_aabbs, 0, aabbs.size());
+        }
+
+        [[nodiscard]]
+        std::vector<std::size_t> query_overlaps(const AabbType& query_aabb) const
+        {
+            std::vector<std::size_t> results;
+
+            if (m_nodes.empty())
+                return results;
+
+            query_overlaps_impl(0, query_aabb, results);
+            return results;
+        }
+
+        template<class RayType = Ray<>>
+        [[nodiscard]]
+        std::vector<HitResult> query_ray(const RayType& ray) const
+        {
+            std::vector<HitResult> results;
+
+            if (m_nodes.empty())
+                return results;
+
+            query_ray_impl(0, ray, results);
+
+            std::ranges::sort(results, [](const HitResult& a, const HitResult& b)
+                              { return a.distance_sqr < b.distance_sqr; });
+            return results;
+        }
+
+        [[nodiscard]]
+        std::size_t node_count() const noexcept
+        {
+            return m_nodes.size();
+        }
+
+        [[nodiscard]]
+        bool empty() const noexcept
+        {
+            return m_nodes.empty();
+        }
+
+    private:
+        static constexpr std::size_t k_sah_bucket_count = 12;
+        static constexpr std::size_t k_leaf_threshold = 1;
+        static constexpr std::size_t k_null_index = std::numeric_limits<std::size_t>::max();
+
+        struct Node
+        {
+            AabbType bounds;
+            std::size_t left = k_null_index;
+            std::size_t right = k_null_index;
+
+            // For leaf nodes: index range into m_indices
+            std::size_t first_index = 0;
+            std::size_t index_count = 0;
+
+            [[nodiscard]]
+            bool is_leaf() const noexcept
+            {
+                return left == k_null_index;
+            }
+        };
+
+        struct SahBucket
+        {
+            AabbType bounds = {
+                {std::numeric_limits<Type>::max(), std::numeric_limits<Type>::max(),
+                 std::numeric_limits<Type>::max()},
+                {std::numeric_limits<Type>::lowest(), std::numeric_limits<Type>::lowest(),
+                 std::numeric_limits<Type>::lowest()}
+            };
+            std::size_t count = 0;
+        };
+
+        [[nodiscard]]
+        static constexpr Type surface_area(const AabbType& aabb) noexcept
+        {
+            const auto d = aabb.max - aabb.min;
+            return static_cast<Type>(2) * (d.x * d.y + d.y * d.z + d.z * d.x);
+        }
+
+        [[nodiscard]]
+        static constexpr AabbType merge(const AabbType& a, const AabbType& b) noexcept
+        {
+            return {
+                {std::min(a.min.x, b.min.x), std::min(a.min.y, b.min.y), std::min(a.min.z, b.min.z)},
+                {std::max(a.max.x, b.max.x), std::max(a.max.y, b.max.y), std::max(a.max.z, b.max.z)}
+            };
+        }
+
+        [[nodiscard]]
+        static constexpr bool overlaps(const AabbType& a, const AabbType& b) noexcept
+        {
+            return a.min.x <= b.max.x && a.max.x >= b.min.x
+                && a.min.y <= b.max.y && a.max.y >= b.min.y
+                && a.min.z <= b.max.z && a.max.z >= b.min.z;
+        }
+
+        std::size_t build(std::span<const AabbType> aabbs, std::size_t begin, std::size_t end)
+        {
+            const auto node_idx = m_nodes.size();
+            m_nodes.emplace_back();
+
+            auto& node = m_nodes[node_idx];
+            node.bounds = compute_bounds(aabbs, begin, end);
+
+            const auto count = end - begin;
+
+            if (count <= k_leaf_threshold)
+            {
+                node.first_index = begin;
+                node.index_count = count;
+                return node_idx;
+            }
+
+            // Find best SAH split
+            const auto centroid_bounds = compute_centroid_bounds(aabbs, begin, end);
+            const auto split = find_best_split(aabbs, begin, end, node.bounds, centroid_bounds);
+
+            // If SAH says don't split, make a leaf
+            if (!split.has_value())
+            {
+                node.first_index = begin;
+                node.index_count = count;
+                return node_idx;
+            }
+
+            const auto [axis, split_pos] = split.value();
+
+            // Partition indices around the split
+            const auto mid = partition_indices(aabbs, begin, end, axis, split_pos);
+
+            // Degenerate partition fallback: split in the middle
+            const auto actual_mid = (mid == begin || mid == end) ? begin + count / 2 : mid;
+
+            // Build children — careful: m_nodes may reallocate, so don't hold references across build calls
+            const auto left_idx = build(aabbs, begin, actual_mid);
+            const auto right_idx = build(aabbs, actual_mid, end);
+
+            m_nodes[node_idx].left = left_idx;
+            m_nodes[node_idx].right = right_idx;
+            m_nodes[node_idx].index_count = 0;
+
+            return node_idx;
+        }
+
+        [[nodiscard]]
+        AabbType compute_bounds(std::span<const AabbType> aabbs, std::size_t begin, std::size_t end) const
+        {
+            AabbType bounds = {
+                {std::numeric_limits<Type>::max(), std::numeric_limits<Type>::max(),
+                 std::numeric_limits<Type>::max()},
+                {std::numeric_limits<Type>::lowest(), std::numeric_limits<Type>::lowest(),
+                 std::numeric_limits<Type>::lowest()}
+            };
+
+            for (auto i = begin; i < end; ++i)
+                bounds = merge(bounds, aabbs[m_indices[i]]);
+
+            return bounds;
+        }
+
+        [[nodiscard]]
+        AabbType compute_centroid_bounds(std::span<const AabbType> aabbs, std::size_t begin, std::size_t end) const
+        {
+            AabbType bounds = {
+                {std::numeric_limits<Type>::max(), std::numeric_limits<Type>::max(),
+                 std::numeric_limits<Type>::max()},
+                {std::numeric_limits<Type>::lowest(), std::numeric_limits<Type>::lowest(),
+                 std::numeric_limits<Type>::lowest()}
+            };
+
+            for (auto i = begin; i < end; ++i)
+            {
+                const auto c = aabbs[m_indices[i]].center();
+                bounds.min.x = std::min(bounds.min.x, c.x);
+                bounds.min.y = std::min(bounds.min.y, c.y);
+                bounds.min.z = std::min(bounds.min.z, c.z);
+                bounds.max.x = std::max(bounds.max.x, c.x);
+                bounds.max.y = std::max(bounds.max.y, c.y);
+                bounds.max.z = std::max(bounds.max.z, c.z);
+            }
+
+            return bounds;
+        }
+
+        struct SplitResult
+        {
+            int axis;
+            Type position;
+        };
+
+        [[nodiscard]]
+        std::optional<SplitResult> find_best_split(std::span<const AabbType> aabbs, std::size_t begin,
+                                                   std::size_t end, const AabbType& node_bounds,
+                                                   const AabbType& centroid_bounds) const
+        {
+            const auto count = end - begin;
+            const auto leaf_cost = static_cast<Type>(count);
+            auto best_cost = leaf_cost;
+            std::optional<SplitResult> best_split;
+
+            for (int axis = 0; axis < 3; ++axis)
+            {
+                const auto axis_min = get_component(centroid_bounds.min, axis);
+                const auto axis_max = get_component(centroid_bounds.max, axis);
+
+                if (axis_max - axis_min < std::numeric_limits<Type>::epsilon())
+                    continue;
+
+                SahBucket buckets[k_sah_bucket_count] = {};
+
+                const auto inv_extent = static_cast<Type>(k_sah_bucket_count) / (axis_max - axis_min);
+
+                // Fill buckets
+                for (auto i = begin; i < end; ++i)
+                {
+                    const auto centroid = get_component(aabbs[m_indices[i]].center(), axis);
+                    auto bucket_idx = static_cast<std::size_t>((centroid - axis_min) * inv_extent);
+                    bucket_idx = std::min(bucket_idx, k_sah_bucket_count - 1);
+
+                    buckets[bucket_idx].count++;
+                    if (buckets[bucket_idx].count == 1)
+                        buckets[bucket_idx].bounds = aabbs[m_indices[i]];
+                    else
+                        buckets[bucket_idx].bounds = merge(buckets[bucket_idx].bounds, aabbs[m_indices[i]]);
+                }
+
+                // Evaluate split costs using prefix/suffix sweeps
+                AabbType prefix_bounds[k_sah_bucket_count - 1];
+                std::size_t prefix_count[k_sah_bucket_count - 1];
+
+                prefix_bounds[0] = buckets[0].bounds;
+                prefix_count[0] = buckets[0].count;
+                for (std::size_t i = 1; i < k_sah_bucket_count - 1; ++i)
+                {
+                    prefix_bounds[i] = (buckets[i].count > 0)
+                                           ? merge(prefix_bounds[i - 1], buckets[i].bounds)
+                                           : prefix_bounds[i - 1];
+                    prefix_count[i] = prefix_count[i - 1] + buckets[i].count;
+                }
+
+                AabbType suffix_bounds = buckets[k_sah_bucket_count - 1].bounds;
+                std::size_t suffix_count = buckets[k_sah_bucket_count - 1].count;
+
+                const auto parent_area = surface_area(node_bounds);
+                const auto inv_parent_area = static_cast<Type>(1) / parent_area;
+
+                for (auto i = static_cast<int>(k_sah_bucket_count) - 2; i >= 0; --i)
+                {
+                    const auto left_count = prefix_count[i];
+                    const auto right_count = suffix_count;
+
+                    if (left_count == 0 || right_count == 0)
+                    {
+                        if (i > 0)
+                        {
+                            suffix_bounds = (buckets[i].count > 0)
+                                                ? merge(suffix_bounds, buckets[i].bounds)
+                                                : suffix_bounds;
+                            suffix_count += buckets[i].count;
+                        }
+                        continue;
+                    }
+
+                    const auto cost = static_cast<Type>(1)
+                                      + (static_cast<Type>(left_count) * surface_area(prefix_bounds[i])
+                                         + static_cast<Type>(right_count) * surface_area(suffix_bounds))
+                                            * inv_parent_area;
+
+                    if (cost < best_cost)
+                    {
+                        best_cost = cost;
+                        best_split = SplitResult{
+                            axis,
+                            axis_min + static_cast<Type>(i + 1) * (axis_max - axis_min)
+                                           / static_cast<Type>(k_sah_bucket_count)
+                        };
+                    }
+
+                    suffix_bounds = (buckets[i].count > 0)
+                                        ? merge(suffix_bounds, buckets[i].bounds)
+                                        : suffix_bounds;
+                    suffix_count += buckets[i].count;
+                }
+            }
+
+            return best_split;
+        }
+
+        std::size_t partition_indices(std::span<const AabbType> aabbs, std::size_t begin, std::size_t end,
+                                      int axis, Type split_pos)
+        {
+            auto it = std::partition(m_indices.begin() + static_cast<std::ptrdiff_t>(begin),
+                                     m_indices.begin() + static_cast<std::ptrdiff_t>(end),
+                                     [&](std::size_t idx)
+                                     { return get_component(aabbs[idx].center(), axis) < split_pos; });
+
+            return static_cast<std::size_t>(std::distance(m_indices.begin(), it));
+        }
+
+        [[nodiscard]]
+        static constexpr Type get_component(const Vector3<Type>& v, int axis) noexcept
+        {
+            switch (axis)
+            {
+            case 0:
+                return v.x;
+            case 1:
+                return v.y;
+            default:
+                return v.z;
+            }
+        }
+
+        void query_overlaps_impl(std::size_t node_idx, const AabbType& query_aabb,
+                                 std::vector<std::size_t>& results) const
+        {
+            const auto& node = m_nodes[node_idx];
+
+            if (!overlaps(node.bounds, query_aabb))
+                return;
+
+            if (node.is_leaf())
+            {
+                for (auto i = node.first_index; i < node.first_index + node.index_count; ++i)
+                    if (overlaps(query_aabb, m_aabbs[m_indices[i]]))
+                        results.push_back(m_indices[i]);
+                return;
+            }
+
+            query_overlaps_impl(node.left, query_aabb, results);
+            query_overlaps_impl(node.right, query_aabb, results);
+        }
+
+        template<class RayType>
+        void query_ray_impl(std::size_t node_idx, const RayType& ray,
+                            std::vector<HitResult>& results) const
+        {
+            const auto& node = m_nodes[node_idx];
+
+            // Quick AABB-ray rejection using the slab method
+            const auto hit = LineTracer<RayType>::get_ray_hit_point(ray, node.bounds);
+            if (hit == ray.end)
+                return;
+
+            if (node.is_leaf())
+            {
+                for (auto i = node.first_index; i < node.first_index + node.index_count; ++i)
+                {
+                    const auto leaf_hit = LineTracer<RayType>::get_ray_hit_point(
+                        ray, m_aabbs[m_indices[i]]);
+                    if (leaf_hit != ray.end)
+                    {
+                        const auto diff = leaf_hit - ray.start;
+                        results.push_back({m_indices[i], diff.dot(diff)});
+                    }
+                }
+                return;
+            }
+
+            query_ray_impl(node.left, ray, results);
+            query_ray_impl(node.right, ray, results);
+        }
+
+        std::vector<Node> m_nodes;
+        std::vector<std::size_t> m_indices;
+        std::vector<AabbType> m_aabbs;
+    };
+} // namespace omath::collision
--- a/include/omath/collision/epa_algorithm.hpp
+++ b/include/omath/collision/epa_algorithm.hpp
@@ -8,6 +8,7 @@
 #include <memory>
 #include <memory_resource>
 #include <queue>
+#include <unordered_map>
 #include <utility>
 #include <vector>

@@ -56,83 +57,76 @@ namespace omath::collision
                                           const Simplex<VectorType>& simplex, const Params params = {},
                                           std::pmr::memory_resource& mem_resource = *std::pmr::get_default_resource())
        {
-            // --- Build initial polytope from simplex (4 points) ---
            std::pmr::vector<VectorType> vertexes = build_initial_polytope_from_simplex(simplex, mem_resource);
-
-            // Initial tetra faces (windings corrected in make_face)
            std::pmr::vector<Face> faces = create_initial_tetra_faces(mem_resource, vertexes);

-            auto heap = rebuild_heap(faces, mem_resource);
+            // Build initial min-heap by distance.
+            Heap heap = rebuild_heap(faces, mem_resource);

            Result out{};

+            // Hoisted outside the loop to reuse bucket allocation across iterations.
+            // Initial bucket count 16 covers a typical horizon without rehashing.
+            BoundaryMap boundary{16, &mem_resource};
+
            for (int it = 0; it < params.max_iterations; ++it)
            {
-                // If heap might be stale after face edits, rebuild lazily.
-                if (heap.empty())
-                    break;
-                // Rebuild when the "closest" face changed (simple cheap guard)
-                // (We could keep face handles; this is fine for small Ns.)
-
-                if (const auto top = heap.top(); faces[top.idx].d != top.d)
-                    heap = rebuild_heap(faces, mem_resource);
+                // Lazily discard stale (deleted or index-mismatched) heap entries.
+                discard_stale_heap_entries(faces, heap);

                if (heap.empty())
                    break;

-                // FIXME: STORE REF VALUE, DO NOT USE
-                //  AFTER IF STATEMENT BLOCK
                const Face& face = faces[heap.top().idx];

-                // Get the furthest point in face normal direction
                const VectorType p = support_point(a, b, face.n);
                const auto p_dist = face.n.dot(p);

-                // Converged if we can’t push the face closer than tolerance
+                // Converged: new support can't push the face closer than tolerance.
                if (p_dist - face.d <= params.tolerance)
                {
                    out.normal = face.n;
-                    out.depth = face.d; // along unit normal
+                    out.depth = face.d;
                    out.iterations = it + 1;
                    out.num_vertices = static_cast<int>(vertexes.size());
                    out.num_faces = static_cast<int>(faces.size());
-
                    out.penetration_vector = out.normal * out.depth;
                    return out;
                }

-                // Add new vertex
                const int new_idx = static_cast<int>(vertexes.size());
                vertexes.emplace_back(p);

-                const auto [to_delete, boundary] = mark_visible_and_collect_horizon(faces, p);
+                // Tombstone visible faces and collect the horizon boundary.
+                // This avoids copying the faces array (O(n)) each iteration.
+                tombstone_visible_faces(faces, boundary, p);

-                erase_marked(faces, to_delete);
-
-                // Stitch new faces around the horizon
-                for (const auto& e : boundary)
+                // Stitch new faces around the horizon and push them directly onto the
+                // heap — no full O(n log n) rebuild needed.
+                for (const auto& [key, e] : boundary)
+                {
+                    const int fi = static_cast<int>(faces.size());
                    faces.emplace_back(make_face(vertexes, e.a, e.b, new_idx));
-
-                // Rebuild heap after topology change
-                heap = rebuild_heap(faces, mem_resource);
+                    heap.emplace(faces.back().d, fi);
+                }

                if (!std::isfinite(vertexes.back().dot(vertexes.back())))
                    break; // safety
+
                out.iterations = it + 1;
            }

-            if (faces.empty())
+            // Find the best surviving (non-deleted) face.
+            const Face* best = find_best_surviving_face(faces);
+
+            if (!best)
                return std::nullopt;

-            const auto best = *std::ranges::min_element(faces, [](const auto& first, const auto& second)
-                                                        { return first.d < second.d; });
-            out.normal = best.n;
-            out.depth = best.d;
+            out.normal = best->n;
+            out.depth = best->d;
            out.num_vertices = static_cast<int>(vertexes.size());
            out.num_faces = static_cast<int>(faces.size());
-
            out.penetration_vector = out.normal * out.depth;
-
            return out;
        }

@@ -141,7 +135,8 @@ namespace omath::collision
        {
            int i0, i1, i2;
            VectorType n; // unit outward normal
-            FloatingType d; // n · v0  (>=0 ideally because origin is inside)
+            FloatingType d; // n · v0  (>= 0 ideally because origin is inside)
+            bool deleted{false}; // tombstone flag — avoids O(n) compaction per iteration
        };

        struct Edge final
@@ -154,6 +149,7 @@ namespace omath::collision
            FloatingType d;
            int idx;
        };
+
        struct HeapCmp final
        {
            [[nodiscard]]
@@ -165,35 +161,44 @@ namespace omath::collision

        using Heap = std::priority_queue<HeapItem, std::pmr::vector<HeapItem>, HeapCmp>;

+        // Horizon boundary: maps packed(a,b) → Edge.
+        // Opposite edges cancel in O(1) via hash lookup instead of O(h) linear scan.
+        using BoundaryMap = std::pmr::unordered_map<std::int64_t, Edge>;
+
+        [[nodiscard]]
+        static constexpr std::int64_t pack_edge(const int a, const int b) noexcept
+        {
+            return (static_cast<std::int64_t>(a) << 32) | static_cast<std::uint32_t>(b);
+        }
+
        [[nodiscard]]
        static Heap rebuild_heap(const std::pmr::vector<Face>& faces, auto& memory_resource)
        {
            std::pmr::vector<HeapItem> storage{&memory_resource};
-            storage.reserve(faces.size()); // optional but recommended
-
+            storage.reserve(faces.size());
            Heap h{HeapCmp{}, std::move(storage)};
-
            for (int i = 0; i < static_cast<int>(faces.size()); ++i)
-                h.emplace(faces[i].d, i);
-
-            return h; // allocator is preserved
+                if (!faces[i].deleted)
+                    h.emplace(faces[i].d, i);
+            return h;
        }

        [[nodiscard]]
        static bool visible_from(const Face& f, const VectorType& p)
        {
-            // positive if p is in front of the face
            return f.n.dot(p) - f.d > static_cast<FloatingType>(1e-7);
        }

-        static void add_edge_boundary(std::pmr::vector<Edge>& boundary, int a, int b)
+        static void add_edge_boundary(BoundaryMap& boundary, int a, int b)
        {
-            // Keep edges that appear only once; erase if opposite already present
-            auto itb = std::ranges::find_if(boundary, [&](const Edge& e) { return e.a == b && e.b == a; });
-            if (itb != boundary.end())
-                boundary.erase(itb); // internal edge cancels out
+            // O(1) cancel: if the opposite edge (b→a) is already in the map it is an
+            // internal edge shared by two visible faces and must be removed.
+            // Otherwise this is a horizon edge and we insert it.
+            const std::int64_t rev = pack_edge(b, a);
+            if (const auto it = boundary.find(rev); it != boundary.end())
+                boundary.erase(it);
            else
-                boundary.emplace_back(a, b); // horizon edge (directed)
+                boundary.emplace(pack_edge(a, b), Edge{a, b});
        }

        [[nodiscard]]
@@ -204,9 +209,7 @@ namespace omath::collision
            const VectorType& a2 = vertexes[i2];
            VectorType n = (a1 - a0).cross(a2 - a0);
            if (n.dot(n) <= static_cast<FloatingType>(1e-30))
-            {
                n = any_perp_vec(a1 - a0); // degenerate guard
-            }
            // Ensure normal points outward (away from origin): require n·a0 >= 0
            if (n.dot(a0) < static_cast<FloatingType>(0.0))
            {
@@ -243,6 +246,7 @@ namespace omath::collision
                    return d;
            return V{1, 0, 0};
        }
+
        [[nodiscard]]
        static std::pmr::vector<Face> create_initial_tetra_faces(std::pmr::memory_resource& mem_resource,
                                                                 const std::pmr::vector<VectorType>& vertexes)
@@ -262,48 +266,45 @@ namespace omath::collision
        {
            std::pmr::vector<VectorType> vertexes{&mem_resource};
            vertexes.reserve(simplex.size());
-
            for (std::size_t i = 0; i < simplex.size(); ++i)
                vertexes.emplace_back(simplex[i]);
-
            return vertexes;
        }
-        static void erase_marked(std::pmr::vector<Face>& faces, const std::pmr::vector<bool>& to_delete)
+
+        static const Face* find_best_surviving_face(const std::pmr::vector<Face>& faces)
        {
-            auto* mr = faces.get_allocator().resource(); // keep same resource
-            std::pmr::vector<Face> kept{mr};
-            kept.reserve(faces.size());
-
-            for (std::size_t i = 0; i < faces.size(); ++i)
-                if (!to_delete[i])
-                    kept.emplace_back(faces[i]);
-
-            faces.swap(kept);
+            const Face* best = nullptr;
+            for (const auto& f : faces)
+                if (!f.deleted && (best == nullptr || f.d < best->d))
+                    best = &f;
+            return best;
        }
-        struct Horizon
+        static void tombstone_visible_faces(std::pmr::vector<Face>& faces, BoundaryMap& boundary,
+                                            const VectorType& p)
        {
-            std::pmr::vector<bool> to_delete;
-            std::pmr::vector<Edge> boundary;
-        };
-
-        static Horizon mark_visible_and_collect_horizon(const std::pmr::vector<Face>& faces, const VectorType& p)
-        {
-            auto* mr = faces.get_allocator().resource();
-
-            Horizon horizon{std::pmr::vector<bool>(faces.size(), false, mr), std::pmr::vector<Edge>(mr)};
-            horizon.boundary.reserve(faces.size());
-
-            for (std::size_t i = 0; i < faces.size(); ++i)
-                if (visible_from(faces[i], p))
+            boundary.clear();
+            for (auto& f : faces)
+            {
+                if (!f.deleted && visible_from(f, p))
                {
-                    const auto& rf = faces[i];
-                    horizon.to_delete[i] = true;
-                    add_edge_boundary(horizon.boundary, rf.i0, rf.i1);
-                    add_edge_boundary(horizon.boundary, rf.i1, rf.i2);
-                    add_edge_boundary(horizon.boundary, rf.i2, rf.i0);
+                    f.deleted = true;
+                    add_edge_boundary(boundary, f.i0, f.i1);
+                    add_edge_boundary(boundary, f.i1, f.i2);
+                    add_edge_boundary(boundary, f.i2, f.i0);
                }
+            }
+        }

-            return horizon;
+        static void discard_stale_heap_entries(const std::pmr::vector<Face>& faces,
+                                               std::priority_queue<HeapItem, std::pmr::vector<HeapItem>, HeapCmp>& heap)
+        {
+            while (!heap.empty())
+            {
+                const auto& top = heap.top();
+                if (!faces[top.idx].deleted && faces[top.idx].d == top.d)
+                    break;
+                heap.pop();
+            }
        }
    };
 } // namespace omath::collision
--- a/include/omath/collision/gjk_algorithm.hpp
+++ b/include/omath/collision/gjk_algorithm.hpp
@@ -14,11 +14,15 @@ namespace omath::collision
        Simplex<VertexType> simplex; // valid only if hit == true and size==4
    };

+    struct GjkSettings final
+    {
+        float epsilon = 1e-6f;
+        std::size_t max_iterations = 64;
+    };
    template<class ColliderInterfaceType>
    class GjkAlgorithm final
    {
        using VectorType = ColliderInterfaceType::VectorType;
-
    public:
        [[nodiscard]]
        static VectorType find_support_vertex(const ColliderInterfaceType& collider_a,
@@ -36,20 +40,34 @@ namespace omath::collision

        [[nodiscard]]
        static GjkHitInfo<VectorType> is_collide_with_simplex_info(const ColliderInterfaceType& collider_a,
-                                                                   const ColliderInterfaceType& collider_b)
+                                                                   const ColliderInterfaceType& collider_b,
+                                                                   const GjkSettings& settings = {})
        {
-            auto support = find_support_vertex(collider_a, collider_b, VectorType{1, 0, 0});
+            // Use centroid difference as initial direction — greatly reduces iterations for separated shapes.
+            VectorType initial_dir;
+            if constexpr (requires { collider_b.get_origin() - collider_a.get_origin(); })
+            {
+                initial_dir = collider_b.get_origin() - collider_a.get_origin();
+                if (initial_dir.dot(initial_dir) < settings.epsilon * settings.epsilon)
+                    initial_dir = VectorType{1, 0, 0};
+            }
+            else
+            {
+                initial_dir = VectorType{1, 0, 0};
+            }
+
+            auto support = find_support_vertex(collider_a, collider_b, initial_dir);

            Simplex<VectorType> simplex;
            simplex.push_front(support);

            auto direction = -support;

-            while (true)
+            for (std::size_t iteration = 0; iteration < settings.max_iterations; ++iteration)
            {
                support = find_support_vertex(collider_a, collider_b, direction);

-                if (support.dot(direction) <= 0.f)
+                if (support.dot(direction) <= settings.epsilon)
                    return {false, simplex};

                simplex.push_front(support);
@@ -57,6 +75,7 @@ namespace omath::collision
                if (simplex.handle(direction))
                    return {true, simplex};
            }
+            return {false, simplex};
        }
    };
 } // namespace omath::collision
--- a/include/omath/collision/line_tracer.hpp
+++ b/include/omath/collision/line_tracer.hpp
@@ -3,6 +3,7 @@
 //
 #pragma once

+#include "omath/3d_primitives/aabb.hpp"
 #include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"

@@ -34,6 +35,7 @@ namespace omath::collision
    class LineTracer final
    {
        using TriangleType = Triangle<typename RayType::VectorType>;
+        using AABBType = primitives::Aabb<typename RayType::VectorType::ContainedType>;

    public:
        LineTracer() = delete;
@@ -87,6 +89,54 @@ namespace omath::collision
            return ray.start + ray_dir * t_hit;
        }

+        // Slab method ray-AABB intersection
+        // Returns the hit point on the AABB surface, or ray.end if no intersection
+        [[nodiscard]]
+        constexpr static auto get_ray_hit_point(const RayType& ray, const AABBType& aabb) noexcept
+        {
+            using T = typename RayType::VectorType::ContainedType;
+            const auto dir = ray.direction_vector();
+
+            auto t_min = -std::numeric_limits<T>::infinity();
+            auto t_max = std::numeric_limits<T>::infinity();
+
+            const auto process_axis = [&](const T& d, const T& origin, const T& box_min,
+                                          const T& box_max) -> bool
+            {
+                constexpr T k_epsilon = std::numeric_limits<T>::epsilon();
+                if (std::abs(d) < k_epsilon)
+                    return origin >= box_min && origin <= box_max;
+
+                const T inv = T(1) / d;
+                T t0 = (box_min - origin) * inv;
+                T t1 = (box_max - origin) * inv;
+                if (t0 > t1)
+                    std::swap(t0, t1);
+
+                t_min = std::max(t_min, t0);
+                t_max = std::min(t_max, t1);
+                return t_min <= t_max;
+            };
+
+            if (!process_axis(dir.x, ray.start.x, aabb.min.x, aabb.max.x))
+                return ray.end;
+            if (!process_axis(dir.y, ray.start.y, aabb.min.y, aabb.max.y))
+                return ray.end;
+            if (!process_axis(dir.z, ray.start.z, aabb.min.z, aabb.max.z))
+                return ray.end;
+
+            // t_hit: use entry point if in front of origin, otherwise 0 (started inside)
+            const T t_hit = std::max(T(0), t_min);
+
+            if (t_max < T(0))
+                return ray.end; // box entirely behind origin
+
+            if (!ray.infinite_length && t_hit > T(1))
+                return ray.end; // box beyond ray endpoint
+
+            return ray.start + dir * t_hit;
+        }
+
        template<class MeshType>
        [[nodiscard]]
        constexpr static auto get_ray_hit_point(const RayType& ray, const MeshType& mesh) noexcept
--- a/include/omath/collision/mesh_collider.hpp
+++ b/include/omath/collision/mesh_collider.hpp
@@ -42,13 +42,40 @@ namespace omath::collision
            m_mesh.set_origin(new_origin);
        }

+        [[nodiscard]]
+        const MeshType& get_mesh() const
+        {
+            return m_mesh;
+        }
+        [[nodiscard]]
+        MeshType& get_mesh()
+        {
+            return m_mesh;
+        }
    private:
        [[nodiscard]]
        const VertexType& find_furthest_vertex(const VectorType& direction) const
        {
-            return *std::ranges::max_element(
-                    m_mesh.m_vertex_buffer, [&direction](const auto& first, const auto& second)
-                    { return first.position.dot(direction) < second.position.dot(direction); });
+            // The support query arrives in world space, but vertex positions are stored
+            // in local space.  We need argmax_v { world(v) · d }.
+            //
+            // world(v) = M·v  (ignoring translation, which is constant across vertices)
+            // world(v) · d = v · Mᵀ·d
+            //
+            // So we transform the direction to local space once — O(1) — then compare
+            // raw local positions, which is far cheaper than calling
+            // vertex_position_to_world_space (full 4×4 multiply) for every vertex.
+            //
+            // d_local = upper-left 3×3 of M, transposed, times d_world:
+            //   d_local[j] = sum_i  M.at(i,j) * d[i]   (i.e. column j of M dotted with d)
+            const auto& m = m_mesh.get_to_world_matrix();
+            const VectorType d_local = {
+                    m[0, 0] * direction.x + m[1, 0] * direction.y + m[2, 0] * direction.z,
+                    m[0, 1] * direction.x + m[1, 1] * direction.y + m[2, 1] * direction.z,
+                    m[0, 2] * direction.x + m[1, 2] * direction.y + m[2, 2] * direction.z,
+            };
+            return *std::ranges::max_element(m_mesh.m_vertex_buffer, [&d_local](const auto& first, const auto& second)
+                                             { return first.position.dot(d_local) < second.position.dot(d_local); });
        }
        MeshType m_mesh;
    };
--- a/include/omath/containers/encrypted_variable.hpp
+++ b/include/omath/containers/encrypted_variable.hpp
@@ -62,20 +62,13 @@ namespace omath::detail
        return splitmix64(base_seed() + 0xD1B54A32D192ED03ull * (Stream + 1));
    }

-    [[nodiscard]]
-    consteval std::uint64_t bounded_u64(const std::uint64_t x, const std::uint64_t bound)
-    {
-        return (x * bound) >> 64;
-    }
-
    template<std::int64_t Lo, std::int64_t Hi, std::uint64_t Stream>
    [[nodiscard]]
    consteval std::int64_t rand_uint8_t()
    {
        static_assert(Lo <= Hi);
-        const std::uint64_t span = static_cast<std::uint64_t>(Hi - Lo) + 1ull;
        const std::uint64_t r = rand_u64<Stream>();
-        return static_cast<std::int64_t>(bounded_u64(r, span)) + Lo;
+        return static_cast<std::int64_t>(r) + Lo;
    }
    [[nodiscard]]
    consteval std::uint64_t rand_u64(const std::uint64_t seed, const std::uint64_t i)
--- a/include/omath/engines/cry_engine/camera.hpp
+++ b/include/omath/engines/cry_engine/camera.hpp
@@ -9,5 +9,5 @@

 namespace omath::cry_engine
 {
-    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait, false, NDCDepthRange::ZERO_TO_ONE>;
 } // namespace omath::cry_engine
--- a/include/omath/engines/cry_engine/formulas.hpp
+++ b/include/omath/engines/cry_engine/formulas.hpp
@@ -22,7 +22,8 @@ namespace omath::cry_engine
    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;

    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;

    template<class FloatingType>
    requires std::is_floating_point_v<FloatingType>
--- a/include/omath/engines/cry_engine/traits/camera_trait.hpp
+++ b/include/omath/engines/cry_engine/traits/camera_trait.hpp
@@ -18,7 +18,7 @@ namespace omath::cry_engine
        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
        [[nodiscard]]
        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
    };

 } // namespace omath::cry_engine
--- a/include/omath/engines/cry_engine/traits/pred_engine_trait.hpp
+++ b/include/omath/engines/cry_engine/traits/pred_engine_trait.hpp
@@ -16,7 +16,8 @@ namespace omath::cry_engine
                                                                    const float pitch, const float yaw,
                                                                    const float time, const float gravity) noexcept
        {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                 RollAngle::from_degrees(0)})
                                         * projectile.m_launch_speed * time;
--- a/include/omath/engines/frostbite_engine/camera.hpp
+++ b/include/omath/engines/frostbite_engine/camera.hpp
@@ -9,5 +9,5 @@

 namespace omath::frostbite_engine
 {
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait, false, NDCDepthRange::ZERO_TO_ONE>;
 } // namespace omath::unity_engine
--- a/include/omath/engines/frostbite_engine/formulas.hpp
+++ b/include/omath/engines/frostbite_engine/formulas.hpp
@@ -22,7 +22,8 @@ namespace omath::frostbite_engine
    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;

    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;

    template<class FloatingType>
    requires std::is_floating_point_v<FloatingType>
--- a/include/omath/engines/frostbite_engine/traits/camera_trait.hpp
+++ b/include/omath/engines/frostbite_engine/traits/camera_trait.hpp
@@ -18,7 +18,7 @@ namespace omath::frostbite_engine
        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
        [[nodiscard]]
        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
    };

 } // namespace omath::unreal_engine
--- a/include/omath/engines/frostbite_engine/traits/pred_engine_trait.hpp
+++ b/include/omath/engines/frostbite_engine/traits/pred_engine_trait.hpp
@@ -16,7 +16,8 @@ namespace omath::frostbite_engine
                                                                    const float pitch, const float yaw,
                                                                    const float time, const float gravity) noexcept
        {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                 RollAngle::from_degrees(0)})
                                         * projectile.m_launch_speed * time;
--- a/include/omath/engines/iw_engine/camera.hpp
+++ b/include/omath/engines/iw_engine/camera.hpp
@@ -9,5 +9,5 @@

 namespace omath::iw_engine
 {
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait, false, NDCDepthRange::ZERO_TO_ONE>;
 } // namespace omath::iw_engine
--- a/include/omath/engines/iw_engine/formulas.hpp
+++ b/include/omath/engines/iw_engine/formulas.hpp
@@ -22,7 +22,8 @@ namespace omath::iw_engine
    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;

    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;

    template<class FloatingType>
    requires std::is_floating_point_v<FloatingType>
--- a/include/omath/engines/iw_engine/traits/camera_trait.hpp
+++ b/include/omath/engines/iw_engine/traits/camera_trait.hpp
@@ -18,7 +18,7 @@ namespace omath::iw_engine
        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
        [[nodiscard]]
        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
    };

 } // namespace omath::iw_engine
--- a/include/omath/engines/iw_engine/traits/pred_engine_trait.hpp
+++ b/include/omath/engines/iw_engine/traits/pred_engine_trait.hpp
@@ -17,7 +17,8 @@ namespace omath::iw_engine
                                                                    const float pitch, const float yaw,
                                                                    const float time, const float gravity) noexcept
        {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                 RollAngle::from_degrees(0)})
                                         * projectile.m_launch_speed * time;
--- a/include/omath/engines/opengl_engine/camera.hpp
+++ b/include/omath/engines/opengl_engine/camera.hpp
@@ -8,5 +8,5 @@

 namespace omath::opengl_engine
 {
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait, true>;
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait, true, NDCDepthRange::NEGATIVE_ONE_TO_ONE>;
 } // namespace omath::opengl_engine
--- a/include/omath/engines/opengl_engine/formulas.hpp
+++ b/include/omath/engines/opengl_engine/formulas.hpp
@@ -21,7 +21,8 @@ namespace omath::opengl_engine
    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;

    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;

    template<class FloatingType>
    requires std::is_floating_point_v<FloatingType>
--- a/include/omath/engines/opengl_engine/traits/camera_trait.hpp
+++ b/include/omath/engines/opengl_engine/traits/camera_trait.hpp
@@ -18,7 +18,7 @@ namespace omath::opengl_engine
        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
        [[nodiscard]]
        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
    };

 } // namespace omath::opengl_engine
--- a/include/omath/engines/opengl_engine/traits/pred_engine_trait.hpp
+++ b/include/omath/engines/opengl_engine/traits/pred_engine_trait.hpp
@@ -16,7 +16,8 @@ namespace omath::opengl_engine
                                                                    const float pitch, const float yaw,
                                                                    const float time, const float gravity) noexcept
        {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                 RollAngle::from_degrees(0)})
                                         * projectile.m_launch_speed * time;
--- a/include/omath/engines/source_engine/camera.hpp
+++ b/include/omath/engines/source_engine/camera.hpp
@@ -7,5 +7,5 @@
 #include "traits/camera_trait.hpp"
 namespace omath::source_engine
 {
-    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera =  projection::Camera<Mat4X4, ViewAngles, CameraTrait, false, NDCDepthRange::ZERO_TO_ONE>;
 } // namespace omath::source_engine
--- a/include/omath/engines/source_engine/formulas.hpp
+++ b/include/omath/engines/source_engine/formulas.hpp
@@ -21,7 +21,8 @@ namespace omath::source_engine
    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;

    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;

    template<class FloatingType>
    requires std::is_floating_point_v<FloatingType>
--- a/include/omath/engines/source_engine/traits/camera_trait.hpp
+++ b/include/omath/engines/source_engine/traits/camera_trait.hpp
@@ -18,7 +18,7 @@ namespace omath::source_engine
        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
        [[nodiscard]]
        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
    };

 } // namespace omath::source_engine
--- a/include/omath/engines/source_engine/traits/pred_engine_trait.hpp
+++ b/include/omath/engines/source_engine/traits/pred_engine_trait.hpp
@@ -17,7 +17,8 @@ namespace omath::source_engine
                                                                    const float pitch, const float yaw,
                                                                    const float time, const float gravity) noexcept
        {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                 RollAngle::from_degrees(0)})
                                         * projectile.m_launch_speed * time;
--- a/include/omath/engines/unity_engine/camera.hpp
+++ b/include/omath/engines/unity_engine/camera.hpp
@@ -9,5 +9,5 @@

 namespace omath::unity_engine
 {
-    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait, false, NDCDepthRange::ZERO_TO_ONE>;
 } // namespace omath::unity_engine
--- a/include/omath/engines/unity_engine/formulas.hpp
+++ b/include/omath/engines/unity_engine/formulas.hpp
@@ -22,7 +22,8 @@ namespace omath::unity_engine
    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;

    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;

    template<class FloatingType>
    requires std::is_floating_point_v<FloatingType>
--- a/include/omath/engines/unity_engine/traits/camera_trait.hpp
+++ b/include/omath/engines/unity_engine/traits/camera_trait.hpp
@@ -18,7 +18,7 @@ namespace omath::unity_engine
        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
        [[nodiscard]]
        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
    };

 } // namespace omath::unity_engine
--- a/include/omath/engines/unity_engine/traits/pred_engine_trait.hpp
+++ b/include/omath/engines/unity_engine/traits/pred_engine_trait.hpp
@@ -16,7 +16,8 @@ namespace omath::unity_engine
                                                                    const float pitch, const float yaw,
                                                                    const float time, const float gravity) noexcept
        {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                 RollAngle::from_degrees(0)})
                                         * projectile.m_launch_speed * time;
--- a/include/omath/engines/unreal_engine/camera.hpp
+++ b/include/omath/engines/unreal_engine/camera.hpp
@@ -9,5 +9,5 @@

 namespace omath::unreal_engine
 {
-    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait>;
+    using Camera = projection::Camera<Mat4X4, ViewAngles, CameraTrait, false, NDCDepthRange::ZERO_TO_ONE>;
 } // namespace omath::unreal_engine
--- a/include/omath/engines/unreal_engine/formulas.hpp
+++ b/include/omath/engines/unreal_engine/formulas.hpp
@@ -22,7 +22,8 @@ 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) noexcept;
+    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
+                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;

    template<class FloatingType>
    requires std::is_floating_point_v<FloatingType>
--- a/include/omath/engines/unreal_engine/traits/camera_trait.hpp
+++ b/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) noexcept;
+                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
    };

 } // namespace omath::unreal_engine
--- a/include/omath/engines/unreal_engine/traits/pred_engine_trait.hpp
+++ b/include/omath/engines/unreal_engine/traits/pred_engine_trait.hpp
@@ -16,7 +16,8 @@ namespace omath::unreal_engine
                                                                    const float pitch, const float yaw,
                                                                    const float time, const float gravity) noexcept
        {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                 RollAngle::from_degrees(0)})
                                         * projectile.m_launch_speed * time;
--- a/include/omath/hud/canvas_box.hpp
+++ b/include/omath/hud/canvas_box.hpp
@@ -0,0 +1,23 @@
+//
+// 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
--- a/include/omath/hud/entity_overlay.hpp
+++ b/include/omath/hud/entity_overlay.hpp
@@ -0,0 +1,202 @@
+//
+// 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
--- a/include/omath/hud/entity_overlay_widgets.hpp
+++ b/include/omath/hud/entity_overlay_widgets.hpp
@@ -0,0 +1,233 @@
+//
+// 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
--- a/include/omath/hud/hud_renderer_interface.hpp
+++ b/include/omath/hud/hud_renderer_interface.hpp
@@ -0,0 +1,47 @@
+//
+// 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
--- a/include/omath/hud/renderer_realizations/imgui_renderer.hpp
+++ b/include/omath/hud/renderer_realizations/imgui_renderer.hpp
@@ -0,0 +1,33 @@
+//
+// 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
--- a/include/omath/linear_algebra/mat.hpp
+++ b/include/omath/linear_algebra/mat.hpp
@@ -37,6 +37,12 @@ namespace omath
        COLUMN_MAJOR
    };

+    enum class NDCDepthRange : uint8_t
+    {
+        NEGATIVE_ONE_TO_ONE = 0, // OpenGL: [-1.0, 1.0]
+        ZERO_TO_ONE              // DirectX / Vulkan: [0.0, 1.0]
+    };
+
    template<typename M1, typename M2> concept MatTemplateEqual
            = (M1::rows == M2::rows) && (M1::columns == M2::columns)
              && std::is_same_v<typename M1::value_type, typename M2::value_type> && (M1::store_type == M2::store_type);
@@ -658,56 +664,98 @@ namespace omath
        } * mat_translation<Type, St>(-camera_origin);
    }

-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
+             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
    [[nodiscard]]
    Mat<4, 4, Type, St> mat_perspective_left_handed(const float field_of_view, const float aspect_ratio,
                                                    const float near, const float far) noexcept
    {
        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);

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

-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
+             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
    [[nodiscard]]
    Mat<4, 4, Type, St> mat_perspective_right_handed(const float field_of_view, const float aspect_ratio,
                                                     const float near, const float far) noexcept
    {
        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);

-        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}};
+        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();
    }
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
+             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
    [[nodiscard]]
    Mat<4, 4, Type, St> mat_ortho_left_handed(const Type left, const Type right, const Type bottom, const Type top,
                                              const Type near, const Type far) noexcept
    {
-        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                             }
-        };
+        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();
    }
-    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
+    template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
+             NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
    [[nodiscard]]
    Mat<4, 4, Type, St> mat_ortho_right_handed(const Type left, const Type right, const Type bottom, const Type top,
                                               const Type near, const Type far) noexcept
    {
-        return
-        {
-                { 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                             }
-        };
+        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();
    }
    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)
--- a/include/omath/linear_algebra/quaternion.hpp
+++ b/include/omath/linear_algebra/quaternion.hpp
@@ -0,0 +1,219 @@
+//
+// Created by vlad on 3/1/2026.
+//
+#pragma once
+
+#include "omath/linear_algebra/mat.hpp"
+#include "omath/linear_algebra/vector3.hpp"
+#include <array>
+#include <cmath>
+#include <format>
+
+namespace omath
+{
+    template<class Type>
+    requires std::is_arithmetic_v<Type>
+    class Quaternion
+    {
+    public:
+        using ContainedType = Type;
+
+        Type x = static_cast<Type>(0);
+        Type y = static_cast<Type>(0);
+        Type z = static_cast<Type>(0);
+        Type w = static_cast<Type>(1);  // identity quaternion
+
+        constexpr Quaternion() noexcept = default;
+
+        constexpr Quaternion(const Type& x, const Type& y, const Type& z, const Type& w) noexcept
+            : x(x), y(y), z(z), w(w)
+        {
+        }
+
+        // Factory: build from a normalized axis and an angle in radians
+        [[nodiscard]]
+        static Quaternion from_axis_angle(const Vector3<Type>& axis, const Type& angle_rad) noexcept
+        {
+            const Type half = angle_rad / static_cast<Type>(2);
+            const Type s = std::sin(half);
+            return {axis.x * s, axis.y * s, axis.z * s, std::cos(half)};
+        }
+
+        [[nodiscard]] constexpr bool operator==(const Quaternion& other) const noexcept
+        {
+            return x == other.x && y == other.y && z == other.z && w == other.w;
+        }
+
+        [[nodiscard]] constexpr bool operator!=(const Quaternion& other) const noexcept
+        {
+            return !(*this == other);
+        }
+
+        // Hamilton product: this * other
+        [[nodiscard]] constexpr Quaternion operator*(const Quaternion& other) const noexcept
+        {
+            return {
+                w * other.x + x * other.w + y * other.z - z * other.y,
+                w * other.y - x * other.z + y * other.w + z * other.x,
+                w * other.z + x * other.y - y * other.x + z * other.w,
+                w * other.w - x * other.x - y * other.y - z * other.z,
+            };
+        }
+
+        constexpr Quaternion& operator*=(const Quaternion& other) noexcept
+        {
+            return *this = *this * other;
+        }
+
+        [[nodiscard]] constexpr Quaternion operator*(const Type& scalar) const noexcept
+        {
+            return {x * scalar, y * scalar, z * scalar, w * scalar};
+        }
+
+        constexpr Quaternion& operator*=(const Type& scalar) noexcept
+        {
+            x *= scalar;
+            y *= scalar;
+            z *= scalar;
+            w *= scalar;
+            return *this;
+        }
+
+        [[nodiscard]] constexpr Quaternion operator+(const Quaternion& other) const noexcept
+        {
+            return {x + other.x, y + other.y, z + other.z, w + other.w};
+        }
+
+        constexpr Quaternion& operator+=(const Quaternion& other) noexcept
+        {
+            x += other.x;
+            y += other.y;
+            z += other.z;
+            w += other.w;
+            return *this;
+        }
+
+        [[nodiscard]] constexpr Quaternion operator-() const noexcept
+        {
+            return {-x, -y, -z, -w};
+        }
+
+        // Conjugate: negates the vector part (x, y, z)
+        [[nodiscard]] constexpr Quaternion conjugate() const noexcept
+        {
+            return {-x, -y, -z, w};
+        }
+
+        [[nodiscard]] constexpr Type dot(const Quaternion& other) const noexcept
+        {
+            return x * other.x + y * other.y + z * other.z + w * other.w;
+        }
+
+        [[nodiscard]] constexpr Type length_sqr() const noexcept
+        {
+            return x * x + y * y + z * z + w * w;
+        }
+
+#ifndef _MSC_VER
+        [[nodiscard]] constexpr Type length() const noexcept
+        {
+            return std::sqrt(length_sqr());
+        }
+
+        [[nodiscard]] constexpr Quaternion normalized() const noexcept
+        {
+            const Type len = length();
+            return len != static_cast<Type>(0) ? *this * (static_cast<Type>(1) / len) : *this;
+        }
+#else
+        [[nodiscard]] Type length() const noexcept
+        {
+            return std::sqrt(length_sqr());
+        }
+
+        [[nodiscard]] Quaternion normalized() const noexcept
+        {
+            const Type len = length();
+            return len != static_cast<Type>(0) ? *this * (static_cast<Type>(1) / len) : *this;
+        }
+#endif
+
+        // Inverse: q* / |q|^2  (for unit quaternions inverse == conjugate)
+        [[nodiscard]] constexpr Quaternion inverse() const noexcept
+        {
+            return conjugate() * (static_cast<Type>(1) / length_sqr());
+        }
+
+        // Rotate a 3D vector: v' = q * pure(v) * q^-1
+        // Computed via Rodrigues' formula to avoid full quaternion product overhead
+        [[nodiscard]] constexpr Vector3<Type> rotate(const Vector3<Type>& v) const noexcept
+        {
+            const Vector3<Type> q_vec{x, y, z};
+            const Vector3<Type> cross = q_vec.cross(v);
+            return v + cross * (static_cast<Type>(2) * w) + q_vec.cross(cross) * static_cast<Type>(2);
+        }
+
+        // 3x3 rotation matrix from this (unit) quaternion
+        [[nodiscard]] constexpr Mat<3, 3, Type> to_rotation_matrix3() const noexcept
+        {
+            const Type xx = x * x, yy = y * y, zz = z * z;
+            const Type xy = x * y, xz = x * z, yz = y * z;
+            const Type wx = w * x, wy = w * y, wz = w * z;
+            const Type one = static_cast<Type>(1);
+            const Type two = static_cast<Type>(2);
+
+            return {
+                {one - two * (yy + zz), two * (xy - wz),       two * (xz + wy)      },
+                {two * (xy + wz),       one - two * (xx + zz), two * (yz - wx)      },
+                {two * (xz - wy),       two * (yz + wx),       one - two * (xx + yy)},
+            };
+        }
+
+        // 4x4 rotation matrix (with homogeneous row/column)
+        [[nodiscard]] constexpr Mat<4, 4, Type> to_rotation_matrix4() const noexcept
+        {
+            const Type xx = x * x, yy = y * y, zz = z * z;
+            const Type xy = x * y, xz = x * z, yz = y * z;
+            const Type wx = w * x, wy = w * y, wz = w * z;
+            const Type one = static_cast<Type>(1);
+            const Type two = static_cast<Type>(2);
+            const Type zero = static_cast<Type>(0);
+
+            return {
+                {one - two * (yy + zz), two * (xy - wz),       two * (xz + wy),       zero},
+                {two * (xy + wz),       one - two * (xx + zz), two * (yz - wx),       zero},
+                {two * (xz - wy),       two * (yz + wx),       one - two * (xx + yy), zero},
+                {zero,                  zero,                   zero,                  one },
+            };
+        }
+
+        [[nodiscard]] constexpr std::array<Type, 4> as_array() const noexcept
+        {
+            return {x, y, z, w};
+        }
+    };
+} // namespace omath
+
+template<class Type>
+struct std::formatter<omath::Quaternion<Type>> // NOLINT(*-dcl58-cpp)
+{
+    [[nodiscard]]
+    static constexpr auto parse(std::format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<class FormatContext>
+    [[nodiscard]]
+    static auto format(const omath::Quaternion<Type>& q, FormatContext& ctx)
+    {
+        if constexpr (std::is_same_v<typename FormatContext::char_type, char>)
+            return std::format_to(ctx.out(), "[{}, {}, {}, {}]", q.x, q.y, q.z, q.w);
+
+        if constexpr (std::is_same_v<typename FormatContext::char_type, wchar_t>)
+            return std::format_to(ctx.out(), L"[{}, {}, {}, {}]", q.x, q.y, q.z, q.w);
+
+        if constexpr (std::is_same_v<typename FormatContext::char_type, char8_t>)
+            return std::format_to(ctx.out(), u8"[{}, {}, {}, {}]", q.x, q.y, q.z, q.w);
+    }
+};
--- a/include/omath/lua/lua.hpp
+++ b/include/omath/lua/lua.hpp
@@ -0,0 +1,25 @@
+//
+// Created by orange on 07.03.2026.
+//
+#pragma once
+#ifdef OMATH_ENABLE_LUA
+#include <sol/forward.hpp>
+namespace omath::lua
+{
+    class LuaInterpreter final
+    {
+    public:
+        static void register_lib(lua_State* lua_state);
+
+    private:
+        static void register_vec2(sol::table& omath_table);
+        static void register_vec3(sol::table& omath_table);
+        static void register_vec4(sol::table& omath_table);
+        static void register_color(sol::table& omath_table);
+        static void register_triangle(sol::table& omath_table);
+        static void register_shared_types(sol::table& omath_table);
+        static void register_engines(sol::table& omath_table);
+        static void register_pattern_scan(sol::table& omath_table);
+    };
+}
+#endif
--- a/include/omath/omath.hpp
+++ b/include/omath/omath.hpp
@@ -17,6 +17,9 @@
 // Matrix classes
 #include "omath/linear_algebra/mat.hpp"

+// Quaternion
+#include "omath/linear_algebra/quaternion.hpp"
+
 // Color functionality
 #include "omath/utility/color.hpp"

@@ -32,6 +35,7 @@
 #include "omath/collision/line_tracer.hpp"
 #include "omath/collision/gjk_algorithm.hpp"
 #include "omath/collision/epa_algorithm.hpp"
+#include "omath/collision/bvh_tree.hpp"
 // Pathfinding algorithms
 #include "omath/pathfinding/a_star.hpp"
 #include "omath/pathfinding/navigation_mesh.hpp"
--- a/include/omath/pathfinding/navigation_mesh.hpp
+++ b/include/omath/pathfinding/navigation_mesh.hpp
@@ -6,7 +6,9 @@

 #include "omath/linear_algebra/vector3.hpp"
 #include <expected>
+#include <optional>
 #include <string>
+#include <unordered_map>
 #include <vector>

 namespace omath::pathfinding
@@ -28,10 +30,20 @@ namespace omath::pathfinding
        [[nodiscard]]
        bool empty() const;

-        [[nodiscard]] std::vector<uint8_t> serialize() const noexcept;
+        // Events -- per-vertex optional tag (e.g. "jump", "teleport")
+        void set_event(const Vector3<float>& vertex, const std::string_view& event_id);
+        void clear_event(const Vector3<float>& vertex);

-        void deserialize(const std::vector<uint8_t>& raw) noexcept;
+        [[nodiscard]]
+        std::optional<std::string> get_event(const Vector3<float>& vertex) const noexcept;
+
+        [[nodiscard]] std::string serialize() const noexcept;
+
+        void deserialize(const std::string& raw);

        std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_vertex_map;
+
+    private:
+        std::unordered_map<Vector3<float>, std::string> m_vertex_events;
    };
 } // namespace omath::pathfinding
--- a/include/omath/projectile_prediction/proj_pred_engine.hpp
+++ b/include/omath/projectile_prediction/proj_pred_engine.hpp
@@ -8,12 +8,23 @@

 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
--- a/include/omath/projectile_prediction/proj_pred_engine_avx2.hpp
+++ b/include/omath/projectile_prediction/proj_pred_engine_avx2.hpp
@@ -12,6 +12,9 @@ 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;

--- a/include/omath/projectile_prediction/proj_pred_engine_legacy.hpp
+++ b/include/omath/projectile_prediction/proj_pred_engine_legacy.hpp
@@ -54,6 +54,36 @@ 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)
            {
@@ -70,12 +100,11 @@ namespace omath::projectile_prediction
                                                  time))
                    continue;

-                return EngineTrait::calc_viewpoint_from_angles(projectile, predicted_target_position, projectile_pitch);
+                return Solution{predicted_target_position, projectile_pitch.value()};
            }
            return std::nullopt;
        }

-    private:
        const float m_gravity_constant;
        const float m_simulation_time_step;
        const float m_maximum_simulation_time;
@@ -100,10 +129,12 @@ namespace omath::projectile_prediction
        {
            const auto bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;

-            if (bullet_gravity == 0.f)
-                return EngineTrait::calc_direct_pitch_angle(projectile.m_origin, target_position);
+            const auto launch_origin = projectile.m_origin + projectile.m_launch_offset;

-            const auto delta = target_position - projectile.m_origin;
+            if (bullet_gravity == 0.f)
+                return EngineTrait::calc_direct_pitch_angle(launch_origin, target_position);
+
+            const auto delta = target_position - launch_origin;

            const auto distance2d = EngineTrait::calc_vector_2d_distance(delta);
            const auto distance2d_sqr = distance2d * distance2d;
@@ -126,7 +157,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, target_position);
+            const auto yaw = EngineTrait::calc_direct_yaw_angle(projectile.m_origin + projectile.m_launch_offset, target_position);
            const auto projectile_position =
                    EngineTrait::predict_projectile_position(projectile, pitch, yaw, time, m_gravity_constant);

--- a/include/omath/projectile_prediction/projectile.hpp
+++ b/include/omath/projectile_prediction/projectile.hpp
@@ -11,6 +11,7 @@ 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{};
    };
--- a/include/omath/projection/camera.hpp
+++ b/include/omath/projection/camera.hpp
@@ -4,6 +4,7 @@

 #pragma once

+#include "omath/3d_primitives/aabb.hpp"
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
@@ -36,23 +37,29 @@ namespace omath::projection
        }
    };
    using FieldOfView = Angle<float, 0.f, 180.f, AngleFlags::Clamped>;
-
+    enum class ViewPortClipping
+    {
+        AUTO,
+        MANUAL,
+    };
    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) {
+                     const FieldOfView& fov, const ViewPort& viewport, float znear, float zfar,
+                     NDCDepthRange ndc_depth_range) {
                // Presence + return types
                { T::calc_look_at_angle(cam_origin, look_at) } -> std::same_as<ViewAnglesType>;
                { T::calc_view_matrix(angles, cam_origin) } -> std::same_as<MatType>;
-                { T::calc_projection_matrix(fov, viewport, znear, zfar) } -> std::same_as<MatType>;
+                { T::calc_projection_matrix(fov, viewport, znear, zfar, ndc_depth_range) } -> 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));
+                requires noexcept(T::calc_projection_matrix(fov, viewport, znear, zfar, ndc_depth_range));
            };

-    template<class Mat4X4Type, class ViewAnglesType, class TraitClass, bool inverted_z = false>
+    template<class Mat4X4Type, class ViewAnglesType, class TraitClass, bool inverted_z = false,
+             NDCDepthRange depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
    requires CameraEngineConcept<TraitClass, Mat4X4Type, ViewAnglesType>
    class Camera final
    {
@@ -82,6 +89,11 @@ namespace omath::projection
            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
@@ -126,7 +138,8 @@ 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);
+                                                                         m_near_plane_distance, m_far_plane_distance,
+                                                                         depth_range);

            return m_projection_matrix.value();
        }
@@ -138,16 +151,16 @@ namespace omath::projection
            m_projection_matrix = std::nullopt;
        }

-        void set_near_plane(const float near) noexcept
+        void set_near_plane(const float near_plane) noexcept
        {
-            m_near_plane_distance = near;
+            m_near_plane_distance = near_plane;
            m_view_projection_matrix = std::nullopt;
            m_projection_matrix = std::nullopt;
        }

-        void set_far_plane(const float far) noexcept
+        void set_far_plane(const float far_plane) noexcept
        {
-            m_far_plane_distance = far;
+            m_far_plane_distance = far_plane;
            m_view_projection_matrix = std::nullopt;
            m_projection_matrix = std::nullopt;
        }
@@ -213,6 +226,22 @@ 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
        {
@@ -246,40 +275,127 @@ namespace omath::projection
                return a[axis] < -a[3] && b[axis] < -b[3] && c[axis] < -c[3];
            };

-            // Clip volume in clip space (OpenGL-style):
+            // Clip volume in clip space:
            // -w <= x <= w
            // -w <= y <= w
-            // -w <= z <= w
+            // z_min <= z <= w  (z_min = -w for [-1,1], 0 for [0,1])

-            for (int i = 0; i < 3; i++)
+            // x and y planes
+            for (int i = 0; i < 2; i++)
            {
                if (all_outside_plane(i, c0, c1, c2, false))
-                    return true; // x < -w (left)
+                    return true;
                if (all_outside_plane(i, c0, c1, c2, true))
-                    return true; // x >  w (right)
+                    return true;
+            }
+
+            // z far plane: z > w
+            if (all_outside_plane(2, c0, c1, c2, true))
+                return true;
+
+            // z near plane
+            if constexpr (depth_range == NDCDepthRange::ZERO_TO_ONE)
+            {
+                // 0 <= z, so reject if z < 0 for all vertices
+                if (c0[2] < 0.f && c1[2] < 0.f && c2[2] < 0.f)
+                    return true;
+            }
+            else
+            {
+                // -w <= z
+                if (all_outside_plane(2, c0, c1, c2, false))
+                    return true;
            }
            return false;
        }

+        [[nodiscard]] 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 noexcept
+        world_to_view_port(const Vector3<float>& world_position,
+                           const ViewPortClipping& clipping = ViewPortClipping::AUTO) const noexcept
        {
            auto projected = get_view_projection_matrix()
                             * mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(world_position);

            const auto& w = projected.at(3, 0);
-            if (w <= std::numeric_limits<float>::epsilon())
-                return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
+            constexpr auto eps = std::numeric_limits<float>::epsilon();
+            if (w <= eps)
+                return std::unexpected(Error::PERSPECTIVE_DIVIDER_LESS_EQ_ZERO);

            projected /= w;

-            if (is_ndc_out_of_bounds(projected))
+            // ReSharper disable once CppTooWideScope
+            const auto clipped_automatically = clipping == ViewPortClipping::AUTO && is_ndc_out_of_bounds(projected);
+            if (clipped_automatically)
+                return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
+
+            // 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)
                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_screen(const Vector3<float>& ndc) const noexcept
+        std::expected<Vector3<float>, Error> view_port_to_world(const Vector3<float>& ndc) const noexcept
        {
            const auto inv_view_proj = get_view_projection_matrix().inverted();

@@ -304,7 +420,7 @@ namespace omath::projection
        [[nodiscard]]
        std::expected<Vector3<float>, Error> screen_to_world(const Vector3<float>& screen_pos) const noexcept
        {
-            return view_port_to_screen(screen_to_ndc<screen_start>(screen_pos));
+            return view_port_to_world(screen_to_ndc<screen_start>(screen_pos));
        }

        template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
@@ -333,8 +449,26 @@ namespace omath::projection
        [[nodiscard]] constexpr static bool is_ndc_out_of_bounds(const Type& ndc) noexcept
        {
            constexpr auto eps = std::numeric_limits<float>::epsilon();
-            return std::ranges::any_of(ndc.raw_array(),
-                                       [](const auto& val) { return val < -1.0f - eps || val > 1.0f + eps; });
+
+            const auto& data = ndc.raw_array();
+            // x and y are always in [-1, 1]
+            if (data[0] < -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();
        }

        // NDC REPRESENTATION:
--- a/include/omath/projection/error_codes.hpp
+++ b/include/omath/projection/error_codes.hpp
@@ -11,5 +11,6 @@ namespace omath::projection
    {
        WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS,
        INV_VIEW_PROJ_MAT_DET_EQ_ZERO,
+        PERSPECTIVE_DIVIDER_LESS_EQ_ZERO,
    };
 }
--- a/include/omath/rev_eng/internal_rev_object.hpp
+++ b/include/omath/rev_eng/internal_rev_object.hpp
@@ -3,11 +3,43 @@
 //

 #pragma once
+#include <cassert>
 #include <cstddef>
 #include <cstdint>
+#include <string_view>
+
+#ifdef _WIN32
+#include "omath/utility/pe_pattern_scan.hpp"
+#include <windows.h>
+#elif defined(__APPLE__)
+#include "omath/utility/macho_pattern_scan.hpp"
+#include <mach-o/dyld.h>
+#else
+#include "omath/utility/elf_pattern_scan.hpp"
+#include <link.h>
+#endif

 namespace omath::rev_eng
 {
+    template<std::size_t N>
+    struct FixedString final
+    {
+        char data[N]{};
+        // ReSharper disable once CppNonExplicitConvertingConstructor
+        constexpr FixedString(const char (&str)[N]) noexcept // NOLINT(*-explicit-constructor)
+        {
+            for (std::size_t i = 0; i < N; ++i)
+                data[i] = str[i];
+        }
+        // ReSharper disable once CppNonExplicitConversionOperator
+        constexpr operator std::string_view() const noexcept // NOLINT(*-explicit-constructor)
+        {
+            return {data, N - 1};
+        }
+    };
+    template<std::size_t N>
+    FixedString(const char (&)[N]) -> FixedString<N>;
+
    class InternalReverseEngineeredObject
    {
    protected:
@@ -23,26 +55,150 @@ namespace omath::rev_eng
            return *reinterpret_cast<Type*>(reinterpret_cast<std::uintptr_t>(this) + offset);
        }

-        template<std::size_t id, class ReturnType>
+        template<class ReturnType>
+        ReturnType call_method(const void* ptr, auto... arg_list)
+        {
+#ifdef _MSC_VER
+            using MethodType = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
+#else
+            using MethodType = ReturnType (*)(void*, decltype(arg_list)...);
+#endif
+            return reinterpret_cast<MethodType>(const_cast<void*>(ptr))(this, arg_list...);
+        }
+        template<class ReturnType>
+        ReturnType call_method(const void* ptr, auto... arg_list) const
+        {
+#ifdef _MSC_VER
+            using MethodType = ReturnType(__thiscall*)(const void*, decltype(arg_list)...);
+#else
+            using MethodType = ReturnType (*)(const void*, decltype(arg_list)...);
+#endif
+            return reinterpret_cast<MethodType>(const_cast<void*>(ptr))(this, arg_list...);
+        }
+
+        template<FixedString ModuleName, FixedString Pattern, class ReturnType>
+        ReturnType call_method(auto... arg_list)
+        {
+            static const auto* address = resolve_pattern(ModuleName, Pattern);
+            return call_method<ReturnType>(address, arg_list...);
+        }
+
+        template<FixedString ModuleName, FixedString Pattern, class ReturnType>
+        ReturnType call_method(auto... arg_list) const
+        {
+            static const auto* address = resolve_pattern(ModuleName, Pattern);
+            return call_method<ReturnType>(address, arg_list...);
+        }
+
+        template<class ReturnType>
+        ReturnType call_method(const std::string_view& module_name,const std::string_view& pattern, auto... arg_list)
+        {
+            static const auto* address = resolve_pattern(module_name, pattern);
+            return call_method<ReturnType>(address, arg_list...);
+        }
+
+        template<class ReturnType>
+        ReturnType call_method(const std::string_view& module_name,const std::string_view& pattern, auto... arg_list) const
+        {
+            static const auto* address = resolve_pattern(module_name, pattern);
+            return call_method<ReturnType>(address, arg_list...);
+        }
+        template<std::size_t Id, class ReturnType>
        ReturnType call_virtual_method(auto... arg_list)
        {
-#ifdef _MSC_VER
-            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...);
+            const auto vtable = *reinterpret_cast<void***>(this);
+            return call_method<ReturnType>(vtable[Id], arg_list...);
        }
-        template<std::size_t id, class ReturnType>
+        template<std::size_t Id, class ReturnType>
        ReturnType call_virtual_method(auto... arg_list) const
        {
+            const auto vtable = *reinterpret_cast<void* const* const*>(this);
+            return call_method<ReturnType>(vtable[Id], arg_list...);
+        }
+
+        template<std::ptrdiff_t TableOffset, std::size_t Id, class ReturnType>
+        ReturnType call_virtual_method(auto... arg_list)
+        {
+            auto sub_this = reinterpret_cast<void*>(
+                reinterpret_cast<std::uintptr_t>(this) + TableOffset);
+            const auto vtable = *reinterpret_cast<void***>(sub_this);
 #ifdef _MSC_VER
-            using VirtualMethodType = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
+            using Fn = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
 #else
-            using VirtualMethodType = ReturnType (*)(void*, decltype(arg_list)...);
+            using Fn = ReturnType(*)(void*, decltype(arg_list)...);
+#endif
+            return reinterpret_cast<Fn>(vtable[Id])(sub_this, arg_list...);
+        }
+        template<std::ptrdiff_t TableOffset, std::size_t Id, class ReturnType>
+        ReturnType call_virtual_method(auto... arg_list) const
+        {
+            auto sub_this = reinterpret_cast<const void*>(
+                reinterpret_cast<std::uintptr_t>(this) + TableOffset);
+            const auto vtable = *reinterpret_cast<void* const* const*>(sub_this);
+#ifdef _MSC_VER
+            using Fn = ReturnType(__thiscall*)(const void*, decltype(arg_list)...);
+#else
+            using Fn = ReturnType(*)(const void*, decltype(arg_list)...);
+#endif
+            return reinterpret_cast<Fn>(vtable[Id])(sub_this, arg_list...);
+        }
+
+    private:
+        [[nodiscard]]
+        static const void* resolve_pattern(const std::string_view module_name, const std::string_view pattern)
+        {
+            const auto* base = get_module_base(module_name);
+            assert(base && "Failed to find module");
+
+#ifdef _WIN32
+            const auto result = PePatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+#elif defined(__APPLE__)
+            const auto result = MachOPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+#else
+            const auto result = ElfPatternScanner::scan_for_pattern_in_loaded_module(base, pattern);
+#endif
+            assert(result.has_value() && "Pattern scan failed");
+            return reinterpret_cast<const void*>(*result);
+        }
+
+        [[nodiscard]]
+        static const void* get_module_base(const std::string_view module_name)
+        {
+#ifdef _WIN32
+            return GetModuleHandleA(module_name.data());
+#elif defined(__APPLE__)
+            // On macOS, iterate loaded images to find the module by name
+            const auto count = _dyld_image_count();
+            for (std::uint32_t i = 0; i < count; ++i)
+            {
+                const auto* name = _dyld_get_image_name(i);
+                if (name && std::string_view{name}.find(module_name) != std::string_view::npos)
+                    return static_cast<const void*>(_dyld_get_image_header(i));
+            }
+            return nullptr;
+#else
+            // On Linux, use dl_iterate_phdr to find loaded module by name
+            struct CallbackData
+            {
+                std::string_view name;
+                const void* base;
+            } cb_data{module_name, nullptr};
+
+            dl_iterate_phdr(
+                    [](dl_phdr_info* info, std::size_t, void* data) -> int
+                    {
+                        auto* cb = static_cast<CallbackData*>(data);
+                        if (info->dlpi_name
+                            && std::string_view{info->dlpi_name}.find(cb->name) != std::string_view::npos)
+                        {
+                            cb->base = reinterpret_cast<const void*>(info->dlpi_addr);
+                            return 1;
+                        }
+                        return 0;
+                    },
+                    &cb_data);
+            return cb_data.base;
 #endif
-            return (*static_cast<VirtualMethodType**>((void*)(this)))[id](
-                    const_cast<void*>(static_cast<const void*>(this)), arg_list...);
        }
    };
 } // namespace omath::rev_eng
--- a/include/omath/trigonometry/angle.hpp
+++ b/include/omath/trigonometry/angle.hpp
@@ -36,6 +36,7 @@ namespace omath
        }

    public:
+        using ArithmeticType = Type;
        [[nodiscard]]
        constexpr static Angle from_degrees(const Type& degrees) noexcept
        {
--- a/include/omath/trigonometry/view_angles.hpp
+++ b/include/omath/trigonometry/view_angles.hpp
@@ -2,14 +2,25 @@
 // Created by Orange on 11/30/2024.
 //
 #pragma once
-
+#include "omath/linear_algebra/vector3.hpp"
+#include <type_traits>
 namespace omath
 {
    template<class PitchType, class YawType, class RollType>
+    requires std::is_same_v<typename PitchType::ArithmeticType, typename YawType::ArithmeticType>
+             && std::is_same_v<typename YawType::ArithmeticType, typename RollType::ArithmeticType>
    struct ViewAngles
    {
+        using ArithmeticType = PitchType::ArithmeticType;
+
        PitchType pitch;
        YawType yaw;
        RollType roll;
+
+        [[nodiscard]]
+        Vector3<ArithmeticType> as_vector3() const
+        {
+            return {pitch.as_degrees(), yaw.as_degrees(), roll.as_degrees()};
+        }
    };
 } // namespace omath
--- a/include/omath/utility/color.hpp
+++ b/include/omath/utility/color.hpp
@@ -16,19 +16,28 @@ namespace omath
        float value{};
    };

-    class Color final : public Vector4<float>
+    class Color final
    {
+        Vector4<float> m_value;
    public:
-        constexpr Color(const float r, const float g, const float b, const float a) noexcept: Vector4(r, g, b, a)
+        constexpr const Vector4<float>& value() const
        {
-            clamp(0.f, 1.f);
+            return m_value;
+        }
+        constexpr Color(const float r, const float g, const float b, const float a) noexcept: m_value(r, g, b, a)
+        {
+            m_value.clamp(0.f, 1.f);
        }

+        constexpr explicit Color(const Vector4<float>& value) : m_value(value)
+        {
+            m_value.clamp(0.f, 1.f);
+        }
        constexpr explicit Color() noexcept = default;
        [[nodiscard]]
        constexpr static Color from_rgba(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a) noexcept
        {
-            return Color{Vector4(r, g, b, a) / 255.f};
+            return Color(Vector4<float>(r, g, b, a) / 255.f);
        }

        [[nodiscard]]
@@ -82,9 +91,9 @@ namespace omath
        {
            Hsv hsv_data;

-            const float& red = x;
-            const float& green = y;
-            const float& blue = z;
+            const float& red = m_value.x;
+            const float& green = m_value.y;
+            const float& blue = m_value.z;

            const float max = std::max({red, green, blue});
            const float min = std::min({red, green, blue});
@@ -109,11 +118,6 @@ namespace omath

            return hsv_data;
        }
-
-        constexpr explicit Color(const Vector4& vec) noexcept: Vector4(vec)
-        {
-            clamp(0.f, 1.f);
-        }
        constexpr void set_hue(const float hue) noexcept
        {
            auto hsv = to_hsv();
@@ -141,7 +145,7 @@ namespace omath
        constexpr Color blend(const Color& other, float ratio) const noexcept
        {
            ratio = std::clamp(ratio, 0.f, 1.f);
-            return Color(*this * (1.f - ratio) + other * ratio);
+            return Color(this->m_value * (1.f - ratio) + other.m_value * ratio);
        }

        [[nodiscard]] static constexpr Color red()
@@ -160,16 +164,26 @@ namespace omath
        [[nodiscard]]
        ImColor to_im_color() const noexcept
        {
-            return {to_im_vec4()};
+            return {m_value.to_im_vec4()};
        }
 #endif
        [[nodiscard]] std::string to_string() const noexcept
        {
            return std::format("[r:{}, g:{}, b:{}, a:{}]",
-                            static_cast<int>(x * 255.f),
-                            static_cast<int>(y * 255.f),
-                            static_cast<int>(z * 255.f),
-                            static_cast<int>(w * 255.f));
+                            static_cast<int>(m_value.x * 255.f),
+                            static_cast<int>(m_value.y * 255.f),
+                            static_cast<int>(m_value.z * 255.f),
+                            static_cast<int>(m_value.w * 255.f));
+        }
+        [[nodiscard]] std::string to_rgbf_string() const noexcept
+        {
+            return std::format("[r:{}, g:{}, b:{}, a:{}]",
+                            m_value.x, m_value.y, m_value.z, m_value.w);
+        }
+        [[nodiscard]] std::string to_hsv_string() const noexcept
+        {
+            const auto [hue, saturation, value] = to_hsv();
+            return std::format("[h:{}, s:{}, v:{}]", hue, saturation, value);
        }
        [[nodiscard]] std::wstring to_wstring() const noexcept
        {
@@ -188,23 +202,55 @@ namespace omath
 template<>
 struct std::formatter<omath::Color> // NOLINT(*-dcl58-cpp)
 {
-    [[nodiscard]]
-    static constexpr auto parse(const std::format_parse_context& ctx)
+    enum class ColorFormat { rgb, rgbf, hsv };
+    ColorFormat color_format = ColorFormat::rgb;
+
+    constexpr auto parse(std::format_parse_context& ctx)
    {
-        return ctx.begin();
+        const auto it = ctx.begin();
+        const auto end = ctx.end();
+
+        if (it == end || *it == '}')
+            return it;
+
+        const std::string_view spec(it, end);
+
+        if (spec.starts_with("rgbf"))
+        {
+            color_format = ColorFormat::rgbf;
+            return it + 4;
+        }
+        if (spec.starts_with("rgb"))
+        {
+            color_format = ColorFormat::rgb;
+            return it + 3;
+        }
+        if (spec.starts_with("hsv"))
+        {
+            color_format = ColorFormat::hsv;
+            return it + 3;
+        }
+
+        throw std::format_error("Invalid format specifier for omath::Color. Use rgb, rgbf, or hsv.");
    }

    template<class FormatContext>
-    [[nodiscard]]
-    static auto format(const omath::Color& col, FormatContext& ctx)
+    auto format(const omath::Color& col, FormatContext& ctx) const
    {
-        if constexpr (std::is_same_v<typename FormatContext::char_type, char>)
-            return std::format_to(ctx.out(), "{}", col.to_string());
-        if constexpr (std::is_same_v<typename FormatContext::char_type, wchar_t>)
-            return std::format_to(ctx.out(), L"{}", col.to_wstring());
+        std::string str;
+        switch (color_format)
+        {
+            case ColorFormat::rgb:  str = col.to_string();      break;
+            case ColorFormat::rgbf: str = col.to_rgbf_string(); break;
+            case ColorFormat::hsv:  str = col.to_hsv_string();  break;
+        }

+        if constexpr (std::is_same_v<typename FormatContext::char_type, char>)
+            return std::format_to(ctx.out(), "{}", str);
+        if constexpr (std::is_same_v<typename FormatContext::char_type, wchar_t>)
+            return std::format_to(ctx.out(), L"{}", std::wstring(str.cbegin(), str.cend()));
        if constexpr (std::is_same_v<typename FormatContext::char_type, char8_t>)
-            return std::format_to(ctx.out(), u8"{}", col.to_u8string());
+            return std::format_to(ctx.out(), u8"{}", std::u8string(str.cbegin(), str.cend()));

        std::unreachable();
    }
--- a/include/omath/utility/elf_pattern_scan.hpp
+++ b/include/omath/utility/elf_pattern_scan.hpp
@@ -5,6 +5,7 @@
 #include <cstdint>
 #include <filesystem>
 #include <optional>
+#include <span>
 #include <string_view>
 #include "section_scan_result.hpp"
 namespace omath
@@ -21,5 +22,10 @@ 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
--- a/include/omath/utility/macho_pattern_scan.hpp
+++ b/include/omath/utility/macho_pattern_scan.hpp
@@ -5,6 +5,7 @@
 #include <cstdint>
 #include <filesystem>
 #include <optional>
+#include <span>
 #include <string_view>
 #include "section_scan_result.hpp"
 namespace omath
@@ -21,5 +22,10 @@ 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
--- a/include/omath/utility/pe_pattern_scan.hpp
+++ b/include/omath/utility/pe_pattern_scan.hpp
@@ -6,6 +6,7 @@
 #include <cstdint>
 #include <filesystem>
 #include <optional>
+#include <span>
 #include <string_view>
 #include "section_scan_result.hpp"
 namespace omath
@@ -23,5 +24,10 @@ 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
--- a/scripts/coverage-llvm.sh
+++ b/scripts/coverage-llvm.sh
@@ -17,8 +17,35 @@ echo "[*] Output dir: ${OUTPUT_DIR}"
 find_llvm_tool() {
    local tool_name="$1"

-    # macOS: use xcrun
+    # First priority: derive from the actual compiler used by cmake (CMakeCache.txt).
+    # This guarantees the profraw format version matches the instrumented binary.
+    local cache_file="${BINARY_DIR}/CMakeCache.txt"
+    if [[ -f "$cache_file" ]]; then
+        local cmake_cxx
+        cmake_cxx=$(grep '^CMAKE_CXX_COMPILER:' "$cache_file" | cut -d= -f2)
+        if [[ -n "$cmake_cxx" && -x "$cmake_cxx" ]]; then
+            local tool_path
+            tool_path="$(dirname "$cmake_cxx")/${tool_name}"
+            if [[ -x "$tool_path" ]]; then
+                echo "$tool_path"
+                return 0
+            fi
+        fi
+    fi
+
+    # macOS: derive from xcrun clang as fallback
    if [[ "$(uname)" == "Darwin" ]]; then
+        local clang_path
+        clang_path=$(xcrun --find clang 2>/dev/null)
+        if [[ -n "$clang_path" ]]; then
+            local tool_path
+            tool_path="$(dirname "$clang_path")/${tool_name}"
+            if [[ -x "$tool_path" ]]; then
+                echo "$tool_path"
+                return 0
+            fi
+        fi
+        # Fallback: xcrun
        if xcrun --find "${tool_name}" &>/dev/null; then
            echo "xcrun ${tool_name}"
            return 0
@@ -51,6 +78,18 @@ fi
 echo "[*] Using: ${LLVM_PROFDATA}"
 echo "[*] Using: ${LLVM_COV}"

+# Print version info for debugging version mismatches
+if [[ "$(uname)" == "Darwin" ]]; then
+    echo "[*] Default clang: $(xcrun clang --version 2>&1 | head -1)"
+    # Show actual compiler used by the build (from CMakeCache.txt if available)
+    CACHE_FILE="${BINARY_DIR}/CMakeCache.txt"
+    if [[ -f "$CACHE_FILE" ]]; then
+        ACTUAL_CXX=$(grep '^CMAKE_CXX_COMPILER:' "$CACHE_FILE" | cut -d= -f2)
+        echo "[*] Build compiler: ${ACTUAL_CXX} ($(${ACTUAL_CXX} --version 2>&1 | head -1))"
+    fi
+    echo "[*] profdata: $(${LLVM_PROFDATA} show --version 2>&1 | head -1 || true)"
+fi
+
 # Find test binary
 if [[ -z "${TEST_BINARY}" ]]; then
    for path in \
--- a/source/engines/cry_engine/formulas.cpp
+++ b/source/engines/cry_engine/formulas.cpp
@@ -35,8 +35,15 @@ namespace omath::cry_engine
               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
    }
    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
-        return mat_perspective_left_handed(field_of_view, aspect_ratio, near, far);
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
+
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
+        std::unreachable();
    }
 } // namespace omath::unity_engine
--- a/source/engines/cry_engine/traits/camera_trait.cpp
+++ b/source/engines/cry_engine/traits/camera_trait.cpp
@@ -19,8 +19,9 @@ namespace omath::cry_engine
    }
    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                               const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
    }
 } // namespace omath::unity_engine
--- a/source/engines/frostbite_engine/formulas.cpp
+++ b/source/engines/frostbite_engine/formulas.cpp
@@ -35,8 +35,16 @@ namespace omath::frostbite_engine
               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
    }
    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
-        return mat_perspective_left_handed(field_of_view, aspect_ratio, near, far);
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
+
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
+
+        std::unreachable();
    }
 } // namespace omath::unity_engine
--- a/source/engines/frostbite_engine/traits/camera_trait.cpp
+++ b/source/engines/frostbite_engine/traits/camera_trait.cpp
@@ -19,8 +19,9 @@ namespace omath::frostbite_engine
    }
    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                               const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
    }
 } // namespace omath::unity_engine
--- a/source/engines/iw_engine/formulas.cpp
+++ b/source/engines/iw_engine/formulas.cpp
@@ -36,18 +36,27 @@ namespace omath::iw_engine
    }

    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
        // NOTE: Need magic number to fix fov calculation, since IW engine inherit Quake proj matrix calculation
        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;

-        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},
-        };
+        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();
    };
 } // namespace omath::iw_engine
--- a/source/engines/iw_engine/traits/camera_trait.cpp
+++ b/source/engines/iw_engine/traits/camera_trait.cpp
@@ -19,8 +19,9 @@ namespace omath::iw_engine
    }
    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                               const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
    }
 } // namespace omath::iw_engine
--- a/source/engines/opengl_engine/formulas.cpp
+++ b/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,15 +37,16 @@ namespace omath::opengl_engine
               * mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(angles.pitch);
    }
    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
-        const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_right_handed<float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);

-        return {
-                {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},
-        };
+        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();
    }
 } // namespace omath::opengl_engine
--- a/source/engines/opengl_engine/traits/camera_trait.cpp
+++ b/source/engines/opengl_engine/traits/camera_trait.cpp
@@ -20,8 +20,9 @@ namespace omath::opengl_engine
    }
    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                               const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
    }
 } // namespace omath::opengl_engine
--- a/source/engines/source_engine/formulas.cpp
+++ b/source/engines/source_engine/formulas.cpp
@@ -36,18 +36,27 @@ namespace omath::source_engine
    }

    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
        // NOTE: Need magic number to fix fov calculation, since source inherit Quake proj matrix calculation
        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;

-        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},
-        };
+        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();
    }
 } // namespace omath::source_engine
--- a/source/engines/source_engine/traits/camera_trait.cpp
+++ b/source/engines/source_engine/traits/camera_trait.cpp
@@ -20,8 +20,9 @@ namespace omath::source_engine
    }
    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                               const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
    }
 } // namespace omath::source_engine
--- a/source/engines/unity_engine/formulas.cpp
+++ b/source/engines/unity_engine/formulas.cpp
@@ -35,8 +35,15 @@ namespace omath::unity_engine
               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
    }
    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
-        return omath::mat_perspective_right_handed(field_of_view, aspect_ratio, near, far);
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return omath::mat_perspective_right_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near, far);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return omath::mat_perspective_right_handed<float, MatStoreType::ROW_MAJOR,
+                                                       NDCDepthRange::NEGATIVE_ONE_TO_ONE>(field_of_view, aspect_ratio,
+                                                                                           near, far);
+        std::unreachable();
    }
 } // namespace omath::unity_engine
--- a/source/engines/unity_engine/traits/camera_trait.cpp
+++ b/source/engines/unity_engine/traits/camera_trait.cpp
@@ -19,8 +19,9 @@ namespace omath::unity_engine
    }
    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                               const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
    }
 } // namespace omath::unity_engine
--- a/source/engines/unreal_engine/formulas.cpp
+++ b/source/engines/unreal_engine/formulas.cpp
@@ -35,8 +35,12 @@ 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) noexcept
+                                              const float far, const NDCDepthRange ndc_depth_range) 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
--- a/source/engines/unreal_engine/traits/camera_trait.cpp
+++ b/source/engines/unreal_engine/traits/camera_trait.cpp
@@ -19,8 +19,9 @@ namespace omath::unreal_engine
    }
    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
                                               const projection::ViewPort& view_port, const float near,
-                                               const float far) noexcept
+                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far);
+        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
+                                                  ndc_depth_range);
    }
 } // namespace omath::unreal_engine
--- a/source/hud/canvas_box.cpp
+++ b/source/hud/canvas_box.cpp
@@ -0,0 +1,27 @@
+//
+// 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
--- a/source/hud/entity_overlay.cpp
+++ b/source/hud/entity_overlay.cpp
@@ -0,0 +1,870 @@
+//
+// 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
--- a/source/hud/renderer_realizations/imgui_renderer.cpp
+++ b/source/hud/renderer_realizations/imgui_renderer.cpp
@@ -0,0 +1,82 @@
+//
+// 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
--- a/source/lua/lua.cpp
+++ b/source/lua/lua.cpp
@@ -0,0 +1,27 @@
+//
+// Created by orange on 07.03.2026.
+//
+#ifdef OMATH_ENABLE_LUA
+#include "lua.hpp"
+#include <sol/sol.hpp>
+#include "omath/lua/lua.hpp"
+
+namespace omath::lua
+{
+    void LuaInterpreter::register_lib(lua_State* lua_state)
+    {
+        sol::state_view lua(lua_state);
+
+        auto omath_table = lua["omath"].get_or_create<sol::table>();
+
+        register_vec2(omath_table);
+        register_vec3(omath_table);
+        register_vec4(omath_table);
+        register_color(omath_table);
+        register_triangle(omath_table);
+        register_shared_types(omath_table);
+        register_engines(omath_table);
+        register_pattern_scan(omath_table);
+    }
+} // namespace omath::lua
+#endif
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Orange	dd421e329e	added files	2026-04-08 18:23:07 +03:00
Orange	8f65183882	fixed tests	2026-04-08 15:34:10 +03:00
Orange	327db8d441	updated contributing	2026-04-03 20:59:34 +03:00
Orange	d8188de736	keeping 1 AABB type	2026-03-28 14:22:36 +03:00
Orange++	33cd3f64e4	Merge pull request #180 from orange-cpp/feature/aabb-linetrace added aabb line trace	2026-03-25 03:37:35 +03:00
Orange	67a07eed45	added aabb line trace	2026-03-25 03:14:22 +03:00
Orange++	0b52b2847b	Merge pull request #179 from orange-cpp/feature/aabb_check added AABB check	2026-03-24 10:45:00 +03:00
Orange	d38895e4d7	added AABB check	2026-03-24 10:20:50 +03:00
Orange	04203d46ff	patch	2026-03-24 06:44:10 +03:00
Orange	bcbb5c1a8d	fixed index	2026-03-24 06:05:56 +03:00
Orange	ba46c86664	simplified method	2026-03-24 06:03:35 +03:00
Orange++	3b0470cc11	Merge pull request #178 from orange-cpp/feature/imrovements Feature/imrovements	2026-03-24 05:55:47 +03:00
Orange	8562c5d1f2	added more unreachable checks	2026-03-24 05:28:01 +03:00
Orange	8daba25c29	added ureachable	2026-03-24 05:21:00 +03:00
Orange++	29b7ac6450	Merge pull request #177 from orange-cpp/feature/custom_ndc_z_range Feature/custom ndc z range	2026-03-24 04:20:57 +03:00
Orange	89df10b778	specifeid ndc for game engines	2026-03-24 00:08:06 +03:00
Orange	8fb96b83db	removed dead code	2026-03-23 23:52:41 +03:00
Orange	4b6db0c402	updated z range	2026-03-23 23:36:19 +03:00
Orange	a9ff7868cf	simplified code	2026-03-23 05:52:35 +03:00
Orange	be80a5d243	added as_vector3 to view angles	2026-03-23 05:23:53 +03:00
Orange	881d3b9a2a	added fields	2026-03-22 19:07:38 +03:00
Orange	f60e18b6ba	replaced with table offset	2026-03-22 18:58:07 +03:00
Orange	0769d3d079	replaced with auto	2026-03-22 17:30:25 +03:00
Orange	b6755e21f9	fix	2026-03-22 16:32:00 +03:00
Orange++	2287602fa2	Merge pull request #176 from orange-cpp/feature/vtable_index added stuff	2026-03-22 16:21:39 +03:00
Orange	663890706e	test fix	2026-03-22 16:06:57 +03:00
Orange	ab103f626b	swaped to std::uintptr_t	2026-03-22 16:05:09 +03:00
Orange	cc4e01b100	added stuff	2026-03-22 16:00:35 +03:00
Orange	308f7ed481	forgot return	2026-03-21 16:43:18 +03:00
Orange	8802ad9af1	fix	2026-03-21 16:41:03 +03:00
Orange	2ac508d6e8	fixed tests	2026-03-21 16:28:48 +03:00
Orange	eb1ca6055b	added additional error code	2026-03-21 16:15:48 +03:00
Orange	b528e41de3	fixed test names	2026-03-21 15:45:22 +03:00
Orange	8615ab2b7c	changed name, fixed bug	2026-03-21 15:22:02 +03:00
Orange	5a4c042fec	replaced enum	2026-03-21 14:53:04 +03:00
Orange	8063c1697a	improved interface	2026-03-21 14:41:07 +03:00
Orange++	7567501f00	Merge pull request #175 from orange-cpp/feature/w2s_no_clip added clip option	2026-03-21 14:12:07 +03:00
Orange	46d999f846	added clip option	2026-03-21 13:58:06 +03:00
Orange	b54601132b	added doc build to release	2026-03-21 06:32:05 +03:00
Orange++	5c8ce2d163	Merge pull request #174 from orange-cpp/feature/docs-pipelines added docs pipeline	2026-03-21 06:26:21 +03:00
Orange	04a86739b4	added docs pipeline	2026-03-21 06:11:20 +03:00
Orange	575b411863	updated install md	2026-03-21 06:05:29 +03:00
Orange	5a91151bc0	fix	2026-03-19 20:27:25 +03:00
Orange	66d4df0524	fix	2026-03-19 20:17:10 +03:00
Orange	54e14760ca	fix	2026-03-19 20:09:07 +03:00
Orange++	ee61c47d7d	Merge pull request #173 from orange-cpp/feature/targeting_algorithms Feature/targeting algorithms	2026-03-19 19:52:22 +03:00
Orange	d737aee1c5	added by distance targeting	2026-03-19 19:29:01 +03:00
Orange	ef422f0a86	added overload	2026-03-19 19:23:39 +03:00
Orange	e99ca0bc2b	update	2026-03-19 19:19:42 +03:00
Orange	5f94e36965	fix for windows specific suff related to far near macroses	2026-03-19 15:32:05 +03:00
Orange	29510cf9e7	Removed from credit by own request	2026-03-19 15:24:35 +03:00
Orange++	927508a76b	Merge pull request #172 from orange-cpp/feaute/methods_calling_improvement Feaute/methods calling improvement	2026-03-19 01:33:42 +03:00
Orange	f390b386d7	fix	2026-03-19 01:06:16 +03:00
Orange	012d837e8b	fix windows x32 bit	2026-03-19 00:57:54 +03:00
Orange	6236c8fd68	added nodiscard	2026-03-18 21:24:35 +03:00
Orange	06dc36089f	added overload	2026-03-18 21:19:09 +03:00
Orange	91136a61c4	improvement	2026-03-18 21:12:18 +03:00
Orange	9cdffcbdb1	added tests	2026-03-18 20:12:46 +03:00
Orange	a3e93ac259	added nttp	2026-03-18 20:05:32 +03:00
Orange	59f6d7a361	added call_method	2026-03-18 19:58:52 +03:00
Orange++	dcf1ef1ea9	Merge pull request #171 from orange-cpp/feaute/projectile_pred_improvement Feaute/projectile pred improvement	2026-03-17 21:58:59 +03:00
orange	89bd879187	added tolerance depending on arch	2026-03-17 21:15:39 +03:00
orange	aa08c7cb65	improved projectile prediction	2026-03-17 20:43:26 +03:00
orange	a5c0ca0cbd	added stuff	2026-03-17 20:31:46 +03:00
orange	624683aed6	added unreachanble	2026-03-17 19:53:15 +03:00
Orange++	f46672b2c6	Merge pull request #170 from orange-cpp/feature/projectile_aim_widget add projectile	2026-03-17 19:51:12 +03:00
orange	b8e61f49fa	add projectile	2026-03-17 19:36:35 +03:00
Orange++	37ea091282	Merge pull request #169 from orange-cpp/feaute/hud_features Feaute/hud features	2026-03-16 14:39:58 +03:00
Orange	29a2743728	renamed args	2026-03-16 13:17:16 +03:00
Orange	1117eb37f1	added icon	2026-03-16 13:13:41 +03:00
Orange	b6b0d4db13	added aim dot	2026-03-16 03:24:53 +03:00
Orange	2e8a74aaaf	imroved spacer	2026-03-16 03:06:14 +03:00
Orange	d8632dc74c	added progress ring	2026-03-16 03:03:23 +03:00
Orange	fd531c930c	added spacer	2026-03-16 02:21:24 +03:00
Orange	a91673216d	added const	2026-03-16 02:10:05 +03:00
Orange	6487554844	corrected code style	2026-03-16 01:54:45 +03:00
Orange	1744172694	updated credits	2026-03-15 20:42:13 +03:00
Orange++	114b2a6e58	Update README to enhance library description and features	2026-03-15 20:21:08 +03:00
Orange++	d90a85d8b6	Merge pull request #168 from orange-cpp/feature/hud_declarative Feature/hud declarative	2026-03-15 20:02:32 +03:00
Orange	e0a7179812	fix	2026-03-15 19:43:55 +03:00
Orange	a99dd24d6b	improvement	2026-03-15 19:39:02 +03:00
Orange	d62dec9a8f	changed api	2026-03-15 19:10:15 +03:00
Orange	1a176d8f09	fix	2026-03-15 18:48:22 +03:00
Orange	8e6ed19abf	added dashed bar	2026-03-15 18:39:40 +03:00
Orange++	311ab45722	Merge pull request #167 from orange-cpp/feaute/sig_scan_file_in_mem added stuff	2026-03-15 17:37:42 +03:00
orange	130277c1ae	refactored test	2026-03-15 17:20:28 +03:00
orange	4f1c42d6f6	tests fix	2026-03-15 17:04:21 +03:00
orange	ccea4a0f0d	added stuff	2026-03-15 16:54:47 +03:00
Orange++	3fb98397e4	Merge pull request #166 from orange-cpp/feature/hud_improvement Feature/hud improvement	2026-03-15 14:01:33 +03:00
Orange	56256c40fb	cleaned code	2026-03-15 13:47:41 +03:00
Orange	46c94ae541	decomposed Run	2026-03-15 13:44:25 +03:00
Orange	a45f095b9c	added skeleton	2026-03-15 04:59:47 +03:00
Orange	e849d23c47	improved dashed box	2026-03-15 04:56:10 +03:00
Orange	adad66599a	adde dash box	2026-03-15 04:49:01 +03:00
Orange	69bdfc3307	improved example	2026-03-15 04:43:19 +03:00
Orange	55304c5df1	fixed bug	2026-03-15 04:28:56 +03:00
Orange	19d796cd4e	improvement	2026-03-15 04:23:07 +03:00
Orange	d31ea6ed4d	added more stuff	2026-03-15 04:17:30 +03:00
orange	977d772687	fix	2026-03-13 22:20:57 +03:00
orange	746f1b84a8	hot fix	2026-03-13 22:16:42 +03:00
Orange++	af399a14ed	Merge pull request #165 from orange-cpp/feature/hud Feature/hud	2026-03-13 22:11:26 +03:00
orange	6fb420642b	updated props	2026-03-13 21:58:14 +03:00
orange	6a2b4b90b4	fix	2026-03-13 21:49:56 +03:00
orange	371d8154ee	fix	2026-03-13 21:40:30 +03:00
orange	d6a2165f83	fix	2026-03-13 21:37:03 +03:00
orange	bb1b5ad14a	removed shit	2026-03-13 21:32:44 +03:00
orange	f188257e0f	added stuff	2026-03-13 21:28:16 +03:00
orange	87966c82b9	added realization	2026-03-13 21:09:12 +03:00
orange	9da19582b5	added files	2026-03-13 20:51:59 +03:00
Orange++	29f3e2565d	Merge pull request #164 from orange-cpp/feaute/disk_optimization avoid saving files on disk	2026-03-13 03:55:56 +03:00
orange	e083b15e0b	update	2026-03-13 03:42:12 +03:00
orange	ed9da79d08	avoid saving files on disk	2026-03-13 03:33:57 +03:00
Orange++	2002bcca83	Merge pull request #163 from orange-cpp/feature/serailization Feature/serailization	2026-03-11 14:47:23 +03:00
orange	ffacba71e2	changed to string view	2026-03-11 14:31:45 +03:00
orange	6081a9c426	added throw test	2026-03-11 14:30:01 +03:00
orange	8bbd504356	added check	2026-03-11 14:23:12 +03:00
orange	1d54039f57	added events	2026-03-11 14:19:58 +03:00
orange	93fc93d4f6	added more tests	2026-03-11 14:16:26 +03:00
Orange	b8a578774c	improved serialization	2026-03-11 14:12:52 +03:00
Orange++	bfa6c77776	Merge pull request #162 from orange-cpp/feature/scanner_example Auto stash before checking out "origin/main"	2026-03-10 21:39:20 +03:00
Orange	1341ef9925	Auto stash before checking out "origin/main"	2026-03-10 20:06:00 +03:00
Orange++	3ccbb0b25b	Merge pull request #161 from orange-cpp/feature/lua-bindings Feature/lua bindings	2026-03-10 19:41:34 +03:00
Orange	68993db48a	updated read me	2026-03-10 19:22:39 +03:00
Orange	337204b3bf	fixed missing source	2026-03-10 19:09:29 +03:00
Orange	1e601d2d8f	android fix	2026-03-10 19:01:54 +03:00
Orange	2b4a75d011	added lua status to build logs	2026-03-10 19:00:36 +03:00
Orange	99a30e8fdf	added pattern scan to lua	2026-03-10 18:55:55 +03:00
Orange	0cdd1d021f	added triangle to lua	2026-03-10 18:39:20 +03:00
Orange	a79ac9743a	added badge, added triangle	2026-03-10 18:39:10 +03:00
Orange	f26afb703b	added bigobj for msvc and mingw	2026-03-10 18:29:13 +03:00
Orange	f237ee5f6a	removed useless headers	2026-03-10 18:15:54 +03:00
Orange	9058ea9b39	refactored to class	2026-03-10 18:14:29 +03:00
Orange	f707ac1adb	fixed forward decl	2026-03-10 18:04:31 +03:00
Orange	cbdabd3fc2	removed useless header	2026-03-10 17:57:11 +03:00
Orange	30e3feb4f8	fix	2026-03-10 16:38:00 +03:00
Orange	0726fdef32	webasm fix	2026-03-10 16:31:49 +03:00
Orange	0ffe0c2bdc	potential fix	2026-03-10 16:24:21 +03:00
Orange	e9600ad42b	splited lua into multiple sources	2026-03-10 16:15:02 +03:00
Orange	673835618c	restructurized stuff	2026-03-10 15:57:22 +03:00
orange	afb2a13dd6	added color	2026-03-08 23:08:23 +03:00
orange	943472cf64	migrated to sol2 decomposed method added vector2, vector4 refactored tests added opengl engine to lua added other engines added source tests removed tons of lua files	2026-03-08 12:55:35 +03:00
Orange++	9752accb14	Merge pull request #160 from orange-cpp/feaure/gjk-epa-improvement Feaure/gjk epa improvement	2026-03-03 18:25:37 +03:00
orange	7373e6d3df	added std namspace to int64_t type	2026-03-03 10:00:46 +03:00
orange	68f4c8cc72	added nodiscard	2026-03-03 09:38:05 +03:00
orange	2dafc8a49d	added additional method	2026-03-03 09:22:11 +03:00
orange	11fe49e801	added const	2026-03-03 08:51:13 +03:00
orange	dee705a391	improvement	2026-03-03 08:43:30 +03:00
orange	bfe147ef80	Merge remote-tracking branch 'orange-cpp/feaure/gjk-epa-improvement' into feaure/gjk-epa-improvement	2026-03-03 08:27:50 +03:00
orange	2c70288a8f	added epa tests	2026-03-03 08:27:26 +03:00
Orange	529322fe34	decomposed method	2026-03-03 08:14:12 +03:00
orange	414b2af289	added gjk tests	2026-03-02 19:58:31 +03:00
orange	a79ad6948c	optimized	2026-03-02 19:40:45 +03:00
orange	ea2c7c3d7f	added benchmark	2026-03-02 19:40:37 +03:00
Orange++	91c2e0d74b	Merge pull request #159 from orange-cpp/feature/color_update Feature/color update	2026-03-01 13:53:18 +03:00
Orange	52e9b906ff	added const	2026-03-01 13:32:13 +03:00
Orange	cc6d625c2d	added more formaters	2026-03-01 13:30:32 +03:00
Orange	5eaec70846	fixed tests	2026-03-01 13:22:15 +03:00
Orange	2063c4d33a	updated color	2026-03-01 13:15:09 +03:00
Orange	60bf8ca30f	moved file	2026-03-01 13:00:24 +03:00
Orange++	6fca106edc	Merge pull request #158 from orange-cpp/feature/quaternions added files	2026-03-01 09:04:18 +03:00
orange	78cb644920	added files	2026-03-01 08:23:26 +03:00
orange	646a920e4c	fixed potential deadlock	2026-02-27 08:47:46 +03:00
Orange	52687a70c7	fixed formating	2026-02-27 07:41:05 +03:00
Orange++	a9eff7d320	Merge pull request #157 from orange-cpp/feature/mesh_improvement Feature/mesh improvement	2026-02-26 16:39:21 +03:00
orange	211e4c3d9b	optimization	2026-02-26 16:19:54 +03:00
orange	74dc2234f7	fixed collider when rotated	2026-02-26 16:17:41 +03:00
Orange	7ebbed6763	added funding edit	2026-02-23 07:18:25 +03:00
Orange	e271bccaf5	added codeowners	2026-02-23 06:45:43 +03:00
orange	50765f69c5	removed unused var	2026-02-23 04:36:48 +03:00
orange	1169534133	fix	2026-02-23 04:32:13 +03:00
Orange++	783501aab9	Enhance installation guide with prebuilt binaries section Updated vcpkg section and added instructions for using prebuilt binaries from GitHub Releases.	2026-02-21 10:00:19 +03:00