fix

Add missing `find_dependency` calls.

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

@@ -87,6 +87,9 @@ jobs:
         shell: bash
         run: ${{ matrix.install_cmd }}
 
+      - name: Set up CMake and Ninja
+        uses: lukka/get-cmake@v4.3.4
+
       - name: Checkout repository (with sub-modules)
         uses: actions/checkout@v4
         with:
@@ -245,72 +248,37 @@ jobs:
         run: |
           ./out/Debug/unit_tests.exe
 
-      - name: Process Coverage (llvm-profdata & llvm-cov)
+      - name: Process and render coverage
         if: ${{ matrix.triplet == 'x64-windows' }}
         shell: pwsh
         run: |
-          $BUILD_DIR = "cmake-build/build/${{ matrix.preset }}"
-          $EXE_PATH = "./out/Debug/unit_tests.exe"
+          $buildDir = "cmake-build/build/${{ matrix.preset }}"
+          $exePath = "./out/Debug/unit_tests.exe"
+          $profile = "$buildDir/unit_tests.profdata"
+          $htmlDir = "$buildDir/coverage-html"
 
-          # 1. Merge raw profile data (essential step)
           & "C:/Program Files/LLVM/bin/llvm-profdata.exe" merge `
-            -sparse "$BUILD_DIR/unit_tests.profraw" `
-            -o "$BUILD_DIR/unit_tests.profdata"
+            -sparse "$buildDir/unit_tests.profraw" `
+            -o $profile
 
-          # 2. Export to LCOV format
-          #    NOTE: We explicitly ignore vcpkg_installed and system headers
-          & "C:/Program Files/LLVM/bin/llvm-cov.exe" export "$EXE_PATH" `
-            -instr-profile="$BUILD_DIR/unit_tests.profdata" `
-            -format=lcov `
-            -ignore-filename-regex="vcpkg_installed|external|tests" `
-            > "$BUILD_DIR/lcov.info"
-
-          if (Test-Path "$BUILD_DIR/lcov.info") {
-            Write-Host "✅ LCOV info created at $BUILD_DIR/lcov.info"
-          } else {
-            Write-Error "Failed to create LCOV info"
-            exit 1
+          if ($LASTEXITCODE -ne 0) {
+            exit $LASTEXITCODE
           }
 
-      - name: Install LCOV (for genhtml)
-        if: ${{ matrix.triplet == 'x64-windows' }}
-        run: choco install lcov -y
+          & "C:/Program Files/LLVM/bin/llvm-cov.exe" show $exePath `
+            "-instr-profile=$profile" `
+            "-format=html" `
+            "-output-dir=$htmlDir" `
+            "-ignore-filename-regex=vcpkg_installed|external|tests" `
+            "-show-branches=count"
 
-      - name: Generate HTML Report
-        if: ${{ matrix.triplet == 'x64-windows' }}
-        shell: bash
-        run: |
-          BUILD_DIR="cmake-build/build/${{ matrix.preset }}"
-          LCOV_INFO="${BUILD_DIR}/lcov.info"
-          HTML_DIR="${BUILD_DIR}/coverage-html"
+          if ($LASTEXITCODE -ne 0) {
+            exit $LASTEXITCODE
+          }
 
-          # Fix paths for genhtml (Perl hates backslashes)
-          sed -i 's|\\|/|g' "${LCOV_INFO}"
-          
-          # Locate genhtml provided by 'choco install lcov'
-          # It is typically in ProgramData/chocolatey/lib/lcov/tools/bin
-          GENHTML=$(find /c/ProgramData/chocolatey -name genhtml -print -quit)
-          
-          if [ -z "$GENHTML" ]; then
-            echo "Error: genhtml executable not found"
-            exit 1
-          fi
-          
-          echo "Using genhtml: $GENHTML"
-          mkdir -p "$HTML_DIR"
-          
-          # Run genhtml
-          # Added --demangle-cpp if your version supports it, otherwise remove it
-          perl "$GENHTML" \
-            "${LCOV_INFO}" \
-            --output-directory "$HTML_DIR" \
-            --title "OMath Coverage Report" \
-            --legend \
-            --show-details \
-            --branch-coverage \
-            --ignore-errors source
-            
-          echo "✅ LCOV HTML report generated at $HTML_DIR"
+          if (-not (Test-Path "$htmlDir/index.html")) {
+            throw "LLVM coverage report was not generated"
+          }
 
       - name: Upload Coverage (HTML Report)
         if: ${{ matrix.triplet == 'x64-windows' }}
@@ -741,8 +709,7 @@ jobs:
             -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"
 
       - name: Build
-        run: |
-          cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
+        run: cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
 
       - name: Run unit_tests.exe
         run: |

.github/workflows/release.yml

@@ -116,6 +116,9 @@ jobs:
         shell: bash
         run: ${{ matrix.install_cmd }}
 
+      - name: Set up CMake and Ninja
+        uses: lukka/get-cmake@v4.3.4
+
       - name: Checkout repository (with sub-modules)
         uses: actions/checkout@v4
         with:

CMakeLists.txt

@@ -33,6 +33,7 @@ option(OMATH_ENABLE_FORCE_INLINE
 option(OMATH_ENABLE_LUA
         "omath bindings for lua" OFF)
 option(OMATH_ENABLE_HOOKING "omath will HooksManager that can hook DirectX/OpenGL automatically" OFF)
+option(OMATH_ENABLE_MODULES "Build omath C++ module interface" OFF)
 
 if(VCPKG_MANIFEST_FEATURES)
     foreach(omath_feature IN LISTS VCPKG_MANIFEST_FEATURES)
@@ -80,6 +81,7 @@ if(${PROJECT_IS_TOP_LEVEL})
     message(STATUS "[${PROJECT_NAME}]: Coverage feature status ${OMATH_ENABLE_COVERAGE}")
     message(STATUS "[${PROJECT_NAME}]: Valgrind feature status ${OMATH_ENABLE_VALGRIND}")
     message(STATUS "[${PROJECT_NAME}]: Lua feature status ${OMATH_ENABLE_LUA}")
+    message(STATUS "[${PROJECT_NAME}]: Modules feature status ${OMATH_ENABLE_MODULES}")
 endif()
 
 if(OMATH_STATIC_MSVC_RUNTIME_LIBRARY)
@@ -95,6 +97,20 @@ else()
     add_library(${PROJECT_NAME} STATIC ${OMATH_SOURCES} ${OMATH_HEADERS})
 endif()
 
+if(OMATH_ENABLE_MODULES)
+    if(CMAKE_VERSION VERSION_LESS 3.28)
+        message(FATAL_ERROR "OMATH_ENABLE_MODULES requires CMake 3.28 or newer")
+    endif()
+    set_target_properties(${PROJECT_NAME} PROPERTIES CXX_SCAN_FOR_MODULES ON)
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+        target_compile_options(${PROJECT_NAME} PRIVATE /wd5244)
+    endif()
+    target_sources(
+        ${PROJECT_NAME}
+        PUBLIC FILE_SET omath_modules TYPE CXX_MODULES BASE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/modules"
+               FILES "${CMAKE_CURRENT_SOURCE_DIR}/modules/omath.cppm")
+endif()
+
 if (OMATH_ENABLE_LUA)
     target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_ENABLE_LUA)
 
@@ -120,6 +136,7 @@ if (OMATH_ENABLE_HOOKING)
     endif ()
 endif ()
 
+
 add_library(${PROJECT_NAME}::${PROJECT_NAME} ALIAS ${PROJECT_NAME})
 
 target_compile_definitions(${PROJECT_NAME} PUBLIC OMATH_VERSION="${PROJECT_VERSION}")
@@ -229,6 +246,10 @@ target_include_directories(
 
 # Installation rules
 
+if(OMATH_ENABLE_MODULES)
+    set(OMATH_MODULE_FILE_SET FILE_SET omath_modules DESTINATION modules)
+endif()
+
 # Install the library
 install(
     TARGETS ${PROJECT_NAME}
@@ -237,6 +258,7 @@ install(
     LIBRARY DESTINATION lib COMPONENT ${PROJECT_NAME} # For shared libraries
     RUNTIME DESTINATION bin COMPONENT ${PROJECT_NAME} # For executables (on
                                                       # Windows)
+    ${OMATH_MODULE_FILE_SET}
     )
 
 # Install headers as part of omath_component

CREDITS.md

@@ -4,7 +4,8 @@ Thanks to everyone who made this possible, including:
 
 - Saikari aka luadebug for VCPKG port and awesome new initial logo design.
 - 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
+- Alex2772 for reference of AUI declarative interface design for omath::hud.
+- Keith O'Hara aka kthohr for a C++ generalized constant expression-based math library that was used as reference.
 
 And a big hand to everyone else who has contributed over the past!
 

VERSION

@@ -1 +1 @@
-5.2.0
+5.5.1

benchmark/benchmark_mat.cpp

@@ -2,11 +2,9 @@
 // Created by Vlad on 9/17/2025.
 //
 #include <benchmark/benchmark.h>
-
 #include <omath/omath.hpp>
 using namespace omath;
 
-
 void mat_float_multiplication_col_major(benchmark::State& state)
 {
     using MatType = Mat<128, 128, float, MatStoreType::COLUMN_MAJOR>;
@@ -15,9 +13,12 @@ void mat_float_multiplication_col_major(benchmark::State& state)
     a.set(3.f);
     b.set(7.f);
 
-
     for ([[maybe_unused]] const auto _ : state)
-        std::ignore = a * b;
+    {
+        benchmark::DoNotOptimize(a);
+        benchmark::DoNotOptimize(b);
+        benchmark::DoNotOptimize(a * b);
+    }
 }
 void mat_float_multiplication_row_major(benchmark::State& state)
 {
@@ -27,9 +28,12 @@ void mat_float_multiplication_row_major(benchmark::State& state)
     a.set(3.f);
     b.set(7.f);
 
-
     for ([[maybe_unused]] const auto _ : state)
-        std::ignore = a * b;
+    {
+        benchmark::DoNotOptimize(a);
+        benchmark::DoNotOptimize(b);
+        benchmark::DoNotOptimize(a * b);
+    }
 }
 
 void mat_double_multiplication_row_major(benchmark::State& state)
@@ -40,9 +44,12 @@ void mat_double_multiplication_row_major(benchmark::State& state)
     a.set(3.f);
     b.set(7.f);
 
-
     for ([[maybe_unused]] const auto _ : state)
-        std::ignore = a * b;
+    {
+        benchmark::DoNotOptimize(a);
+        benchmark::DoNotOptimize(b);
+        benchmark::DoNotOptimize(a * b);
+    }
 }
 
 void mat_double_multiplication_col_major(benchmark::State& state)
@@ -53,9 +60,12 @@ void mat_double_multiplication_col_major(benchmark::State& state)
     a.set(3.f);
     b.set(7.f);
 
-
     for ([[maybe_unused]] const auto _ : state)
-        std::ignore = a * b;
+    {
+        benchmark::DoNotOptimize(a);
+        benchmark::DoNotOptimize(b);
+        benchmark::DoNotOptimize(a * b);
+    }
 }
 
 BENCHMARK(mat_float_multiplication_col_major)->Iterations(5000);

cmake/omathConfig.cmake.in

@@ -6,6 +6,17 @@ if (@OMATH_IMGUI_INTEGRATION@)
     find_dependency(imgui CONFIG)
 endif()
 
+if (@OMATH_ENABLE_LUA@)
+    find_dependency(Lua)
+endif()
+
+if (@OMATH_ENABLE_HOOKING@)
+    find_dependency(safetyhook CONFIG)
+    if (NOT WIN32 AND (UNIX AND NOT APPLE))
+        find_dependency(OpenGL)
+    endif()
+endif()
+
 # Load the targets for the omath library
 include("${CMAKE_CURRENT_LIST_DIR}/omathTargets.cmake")
 check_required_components(omath)

docs/trigonometry/angle.md

@@ -3,8 +3,8 @@
 > Header: `omath/trigonometry/angle.hpp`
 > Namespace: `omath`
 > Template: `Angle<Type = float, min = 0, max = 360, flags = AngleFlags::Normalized>`
-> Requires: `std::is_arithmetic_v<Type>`
-> Formatters: `std::formatter` for `char`, `wchar_t`, `char8_t` → `"{}deg"`
+> Requires: `std::is_floating_point_v<Type>`
+> Formatters: `std::formatter` for `char` and `wchar_t` → `"{}deg"`
 
 ---
 
@@ -14,7 +14,7 @@
 
 Two behaviors via `AngleFlags`:
 
-* `AngleFlags::Normalized` (default): values are wrapped into `[min, max]` using `angles::wrap_angle`.
+* `AngleFlags::Normalized` (default): values are wrapped into `[min, max)` using `angles::wrap_angle`.
 * `AngleFlags::Clamped`: values are clamped to `[min, max]` using `std::clamp`.
 
 ---
@@ -28,12 +28,16 @@ enum class AngleFlags { Normalized = 0, Clamped = 1 };
 
 template<class Type = float, Type min = Type(0), Type max = Type(360),
          AngleFlags flags = AngleFlags::Normalized>
-requires std::is_arithmetic_v<Type>
+requires std::is_floating_point_v<Type>
 class Angle {
 public:
   // Construction
   static constexpr Angle from_degrees(const Type& deg) noexcept;
   static constexpr Angle from_radians(const Type& rad) noexcept;
+  static constexpr Angle from_asin(const Type& value) noexcept;
+  static constexpr Angle from_acos(const Type& value) noexcept;
+  static constexpr Angle from_atan(const Type& value) noexcept;
+  static constexpr Angle from_atan2(const Type& y, const Type& x) noexcept;
   constexpr Angle() noexcept;                  // 0 deg, adjusted by flags/range
 
   // Accessors / conversions (degrees stored internally)
@@ -45,10 +49,9 @@ public:
   Type sin() const noexcept;
   Type cos() const noexcept;
   Type tan() const noexcept;
-  Type atan() const noexcept;  // atan(as_radians())  (rarely used)
   Type cot() const noexcept;   // cos()/sin()  (watch sin≈0)
 
-  // Arithmetic (wraps or clamps per flags and [min,max])
+  // Arithmetic (wraps or clamps per flags and configured range)
   constexpr Angle& operator+=(const Angle&) noexcept;
   constexpr Angle& operator-=(const Angle&) noexcept;
   constexpr Angle  operator+(const Angle&) noexcept;
@@ -68,7 +71,7 @@ public:
 std::format("{}", Angle<float>::from_degrees(45)); // "45deg"
 ```
 
-Formatters exist for `char`, `wchar_t`, and `char8_t`.
+Formatters exist for `char` and `wchar_t`.
 
 ---
 
@@ -116,10 +119,9 @@ float deg = *yaw;                                // same as yaw.as_degrees()
 ## Semantics & notes
 
 * **Storage & units:** Internally stores **degrees** (`Type m_angle`). `as_radians()`/`from_radians()` use the project helpers in `omath::angles`.
-* **Arithmetic honors policy:** `operator+=`/`-=` and the binary `+`/`-` apply **wrap** or **clamp** in `[min,max]`, mirroring construction behavior.
-* **`atan()`**: returns `std::atan(as_radians())` (the arctangent of the *radian value*). This is mathematically unusual for an angle type and is rarely useful; prefer `tan()`/`atan2` in client code when solving geometry problems.
+* **Arithmetic honors policy:** `operator+=`/`-=` and the binary `+`/`-` apply **wrap** or **clamp**, mirroring construction behavior.
 * **`cot()` / `tan()` singularities:** Near multiples where `sin() ≈ 0` or `cos() ≈ 0`, results blow up. Guard in your usage if inputs can approach these points.
-* **Comparison:** `operator<=>` is defaulted. With normalization, distinct representatives can compare as expected (e.g., `-180` vs `180` in signed ranges are distinct endpoints).
+* **Comparison:** `operator<=>` is defaulted. Normalization canonicalizes the maximum endpoint to the minimum endpoint.
 * **No implicit numeric conversion:** There’s **no `operator Type()`**. Use `as_degrees()`/`as_radians()` (or `*angle`) explicitly—this intentional friction avoids unit mistakes.
 
 ---

docs/trigonometry/angles.md

@@ -4,7 +4,7 @@
 > Namespace: `omath::angles`
 > All functions are `[[nodiscard]]` and `noexcept` where applicable.
 
-A small set of constexpr-friendly utilities for converting between degrees/radians, converting horizontal/vertical field of view, and wrapping angles into a closed interval.
+A small set of constexpr-friendly utilities for converting between degrees/radians, converting horizontal/vertical field of view, and wrapping angles into a half-open interval.
 
 ---
 
@@ -29,9 +29,9 @@ template<class Type>
 requires std::is_floating_point_v<Type>
 Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect) noexcept;
 
-// Wrap angle into [min, max] (any arithmetic type)
+// Wrap angle into [min, max) (floating-point types)
 template<class Type>
-requires std::is_arithmetic_v<Type>
+requires std::is_floating_point_v<Type>
 Type wrap_angle(const Type& angle, const Type& min, const Type& max) noexcept;
 ```
 
@@ -66,10 +66,10 @@ Formulas (in radians):
 
 ### Wrapping angles (or any periodic value)
 
-Wrap any numeric `angle` into `[min, max]`:
+Wrap any floating-point `angle` into `[min, max)`:
 
 ```cpp
-// Wrap degrees into [0, 360]
+// Wrap degrees into [0, 360)
 float a = omath::angles::wrap_angle(   370.0f, 0.0f, 360.0f); // 10
 float b = omath::angles::wrap_angle(   -15.0f, 0.0f, 360.0f); // 345
 // Signed range [-180,180]
@@ -83,10 +83,10 @@ float c = omath::angles::wrap_angle(  200.0f, -180.0f, 180.0f); // -160
 * **Type requirements**
 
     * Converters & FOV helpers require **floating-point** `Type`.
-    * `wrap_angle` accepts any arithmetic `Type` (floats or integers).
+    * `wrap_angle` accepts floating-point types.
 * **Aspect ratio** must be **positive** and finite. For `aspect == 0` the FOV helpers are undefined.
 * **Units**: FOV functions accept/return **degrees** but compute internally in radians.
-* **Wrapping interval**: Behavior assumes `max > min`. The result lies in the **closed interval** `[min, max]` with modulo arithmetic; if you need half-open behavior (e.g., `[min,max)`), adjust your range or post-process endpoint cases.
+* **Wrapping interval**: Behavior assumes `max > min`. The result lies in the half-open interval `[min, max)`.
 * **constexpr**: Converters are `constexpr`; FOV helpers are runtime constexpr-compatible except for `std::atan/std::tan` constraints on some standard libraries.
 
 ---
@@ -103,5 +103,5 @@ float v = horizontal_fov_to_vertical(90.0f, 16.0f/9.0f);
 float h = vertical_fov_to_horizontal(v, 16.0f/9.0f);
 assert(std::abs(h - 90.0f) < 1e-5f);
 
-assert(wrap_angle(360.0f, 0.0f, 360.0f) == 0.0f || wrap_angle(360.0f, 0.0f, 360.0f) == 360.0f);
+assert(wrap_angle(360.0f, 0.0f, 360.0f) == 0.0f);
 ```

examples/example_dx11_hook/dllmain.cpp

@@ -5,6 +5,8 @@
 #include <imgui.h>
 #include <imgui_impl_dx11.h>
 #include <imgui_impl_win32.h>
+#include <thread>
+#include <tuple>
 
 extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND, UINT, WPARAM, LPARAM);
 
@@ -17,13 +19,35 @@ namespace
     ID3D11DeviceContext* g_context = nullptr;
     ID3D11RenderTargetView* g_render_target_view = nullptr;
 
-    void create_render_target(IDXGISwapChain* swap_chain)
+    [[nodiscard]]
+    bool create_render_target(IDXGISwapChain* swap_chain)
     {
         ID3D11Texture2D* back_buffer = nullptr;
         if (FAILED(swap_chain->GetBuffer(0, IID_PPV_ARGS(&back_buffer))))
-            return;
-        g_device->CreateRenderTargetView(back_buffer, nullptr, &g_render_target_view);
+            return false;
+
+        D3D11_RENDER_TARGET_VIEW_DESC desc{};
+        desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
+        desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+
+        const HRESULT result = g_device->CreateRenderTargetView(back_buffer, &desc, &g_render_target_view);
         back_buffer->Release();
+        return SUCCEEDED(result);
+    }
+
+    void release_render_target()
+    {
+        if (g_context)
+            g_context->OMSetRenderTargets(0, nullptr, nullptr);
+
+        if (g_render_target_view)
+        {
+            g_render_target_view->Release();
+            g_render_target_view = nullptr;
+        }
+
+        if (g_context)
+            g_context->Flush();
     }
 
     void init(IDXGISwapChain* swap_chain)
@@ -36,9 +60,9 @@ namespace
         g_device->GetImmediateContext(&g_context);
 
         DXGI_SWAP_CHAIN_DESC desc{};
-        swap_chain->GetDesc(&desc);
+        std::ignore = swap_chain->GetDesc(&desc);
 
-        create_render_target(swap_chain);
+        std::ignore = create_render_target(swap_chain);
 
         ImGui::CreateContext();
         ImGui::StyleColorsDark();
@@ -51,7 +75,7 @@ namespace
 
         auto& mgr = omath::hooks::HooksManager::get();
         mgr.set_on_wnd_proc(
-                [](HWND h, UINT msg, WPARAM wp, LPARAM lp) -> std::optional<LRESULT>
+                [](const HWND h, const UINT msg, const WPARAM wp, const LPARAM lp) -> std::optional<LRESULT>
                 {
                     if (ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp))
                         return 0;
@@ -71,44 +95,49 @@ namespace
             return;
         }
 
-        if (!g_render_target_view)
-            create_render_target(swap_chain);
+        if (!g_render_target_view && !create_render_target(swap_chain))
+            return;
+
+        ID3D11RenderTargetView* previous_render_target_views[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT]{};
+        ID3D11DepthStencilView* previous_depth_stencil_view = nullptr;
+        g_context->OMGetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, previous_render_target_views,
+                                      &previous_depth_stencil_view);
 
         g_context->OMSetRenderTargets(1, &g_render_target_view, nullptr);
 
         ImGui_ImplDX11_NewFrame();
         ImGui_ImplWin32_NewFrame();
         ImGui::NewFrame();
-
-        ImGui::SetNextWindowSize({300.f, 80.f}, ImGuiCond_Once);
-        ImGui::SetNextWindowPos({10.f, 10.f}, ImGuiCond_Once);
-        ImGui::Begin("omath | DX11 hook");
-        ImGui::Text("Hook active");
-        ImGui::Text("FPS: %.1f", ImGui::GetIO().Framerate);
-        ImGui::End();
+        ImGui::GetIO().MouseDrawCursor = true;
+        ImGui::ShowDemoWindow();
 
         ImGui::Render();
         ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
+
+        g_context->OMSetRenderTargets(D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT, previous_render_target_views,
+                                      previous_depth_stencil_view);
+        for (ID3D11RenderTargetView* render_target_view : previous_render_target_views)
+        {
+            if (render_target_view)
+                render_target_view->Release();
+        }
+        if (previous_depth_stencil_view)
+            previous_depth_stencil_view->Release();
     }
 
     void on_resize_buffers(IDXGISwapChain*, UINT, UINT, UINT, DXGI_FORMAT, UINT)
     {
-        if (g_render_target_view)
-        {
-            g_render_target_view->Release();
-            g_render_target_view = nullptr;
-        }
+        release_render_target();
     }
 } // namespace
 
-BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
+BOOL WINAPI DllMain(const HINSTANCE h_instance, const DWORD reason, LPVOID)
 {
     if (reason == DLL_PROCESS_ATTACH)
     {
         DisableThreadLibraryCalls(h_instance);
-        CreateThread(
-                nullptr, 0,
-                [](LPVOID) -> DWORD
+        std::thread(
+                []()
                 {
                     while (!GetModuleHandle("d3d11.dll"))
                         Sleep(100);
@@ -116,10 +145,10 @@ BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
                     auto& mgr = omath::hooks::HooksManager::get();
                     mgr.set_on_present(on_present);
                     mgr.set_on_resize_buffers(on_resize_buffers);
-                    mgr.hook_dx11();
+                    std::ignore = mgr.hook_dx11();
                     return 0;
-                },
-                nullptr, 0, nullptr);
+                })
+                .detach();
     }
     else if (reason == DLL_PROCESS_DETACH)
     {
@@ -134,11 +163,7 @@ BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
             ImGui::DestroyContext();
         }
 
-        if (g_render_target_view)
-        {
-            g_render_target_view->Release();
-            g_render_target_view = nullptr;
-        }
+        release_render_target();
         if (g_context)
         {
             g_context->Release();

examples/example_dx12_hook/dllmain.cpp

@@ -5,6 +5,7 @@
 #include <imgui.h>
 #include <imgui_impl_dx12.h>
 #include <imgui_impl_win32.h>
+#include <mutex>
 #include <tuple>
 #include <vector>
 
@@ -13,10 +14,15 @@ bool show_menu = true;
 
 namespace
 {
+    constexpr UINT srv_heap_size = 64;
+
     struct frame_context
     {
         ID3D12Resource* render_target = nullptr;
+        // Each back buffer gets its own allocator because allocators cannot be reset while GPU work uses them.
+        ID3D12CommandAllocator* command_allocator = nullptr;
         D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = {};
+        UINT64 fence_value = 0;
     };
 
     bool g_initialized = false;
@@ -24,48 +30,246 @@ namespace
 
     ID3D12Device* g_device = nullptr;
     ID3D12CommandQueue* g_command_queue = nullptr;
+    ID3D12CommandQueue* g_pending_command_queue = nullptr;
     IDXGISwapChain3* g_swap_chain = nullptr;
+    IUnknown* g_swap_chain_identity = nullptr;
     ID3D12DescriptorHeap* g_rtv_heap = nullptr;
     ID3D12DescriptorHeap* g_srv_heap = nullptr;
     ID3D12GraphicsCommandList* g_command_list = nullptr;
-    ID3D12CommandAllocator* g_command_allocator = nullptr;
+    ID3D12Fence* g_fence = nullptr;
+    HANDLE g_fence_event = nullptr;
+    UINT64 g_fence_value = 0;
+    UINT g_srv_descriptor_size = 0;
+    bool g_command_queue_selected = false;
+    std::mutex g_command_queue_mutex;
+    std::vector<UINT> g_free_srv_indices;
     std::vector<frame_context> g_frames;
 
-    void init(IDXGISwapChain* swap_chain)
+    void allocate_srv_descriptor(ImGui_ImplDX12_InitInfo*, D3D12_CPU_DESCRIPTOR_HANDLE* cpu_handle,
+                                 D3D12_GPU_DESCRIPTOR_HANDLE* gpu_handle)
     {
-        g_init_attempted = true;
+        IM_ASSERT(!g_free_srv_indices.empty());
+        const UINT index = g_free_srv_indices.back();
+        g_free_srv_indices.pop_back();
 
-        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&g_swap_chain))))
+        *cpu_handle = g_srv_heap->GetCPUDescriptorHandleForHeapStart();
+        *gpu_handle = g_srv_heap->GetGPUDescriptorHandleForHeapStart();
+        cpu_handle->ptr += static_cast<SIZE_T>(index) * g_srv_descriptor_size;
+        gpu_handle->ptr += static_cast<UINT64>(index) * g_srv_descriptor_size;
+    }
+
+    void free_srv_descriptor(ImGui_ImplDX12_InitInfo*, D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle,
+                             D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle)
+    {
+        const D3D12_CPU_DESCRIPTOR_HANDLE cpu_start = g_srv_heap->GetCPUDescriptorHandleForHeapStart();
+        const D3D12_GPU_DESCRIPTOR_HANDLE gpu_start = g_srv_heap->GetGPUDescriptorHandleForHeapStart();
+        const UINT cpu_index = static_cast<UINT>((cpu_handle.ptr - cpu_start.ptr) / g_srv_descriptor_size);
+        const UINT gpu_index = static_cast<UINT>((gpu_handle.ptr - gpu_start.ptr) / g_srv_descriptor_size);
+        IM_ASSERT(cpu_index == gpu_index && cpu_index < srv_heap_size);
+        g_free_srv_indices.push_back(cpu_index);
+    }
+
+    void remember_direct_command_queue(ID3D12CommandQueue* queue)
+    {
+        if (queue->GetDesc().Type != D3D12_COMMAND_LIST_TYPE_DIRECT)
             return;
 
-        if (FAILED(swap_chain->GetDevice(IID_PPV_ARGS(&g_device))))
+        std::scoped_lock lock(g_command_queue_mutex);
+        if (g_command_queue_selected || g_pending_command_queue == queue)
             return;
 
+        queue->AddRef();
+        if (g_pending_command_queue)
+            g_pending_command_queue->Release();
+        g_pending_command_queue = queue;
+    }
+
+    ID3D12CommandQueue* take_command_queue_for_device(ID3D12Device* device)
+    {
+        std::scoped_lock lock(g_command_queue_mutex);
+        if (!g_pending_command_queue)
+            return nullptr;
+
+        ID3D12Device* queue_device = nullptr;
+        if (FAILED(g_pending_command_queue->GetDevice(IID_PPV_ARGS(&queue_device))))
+            return nullptr;
+
+        const bool matches = queue_device == device;
+        queue_device->Release();
+        if (!matches)
+            return nullptr;
+
+        ID3D12CommandQueue* queue = g_pending_command_queue;
+        g_pending_command_queue = nullptr;
+        g_command_queue_selected = true;
+        return queue;
+    }
+
+    bool is_target_swap_chain(IDXGISwapChain* swap_chain)
+    {
+        if (!g_swap_chain_identity)
+            return false;
+
+        IUnknown* identity = nullptr;
+        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&identity))))
+            return false;
+
+        const bool matches = identity == g_swap_chain_identity;
+        identity->Release();
+        return matches;
+    }
+
+    // This fence tracks only the overlay work submitted by this DLL, not the game's whole frame.
+    bool create_sync_objects()
+    {
+        if (g_fence)
+            return true;
+
+        if (FAILED(g_device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&g_fence))))
+            return false;
+
+        g_fence_event = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+        if (!g_fence_event)
+        {
+            g_fence->Release();
+            g_fence = nullptr;
+            return false;
+        }
+
+        g_fence_value = 0;
+        return true;
+    }
+
+    bool wait_for_fence_value(UINT64 fence_value)
+    {
+        if (!g_fence || !g_fence_event || fence_value == 0 || g_fence->GetCompletedValue() >= fence_value)
+            return true;
+
+        if (FAILED(g_fence->SetEventOnCompletion(fence_value, g_fence_event)))
+            return false;
+
+        WaitForSingleObject(g_fence_event, INFINITE);
+        return true;
+    }
+
+    void wait_for_frame(frame_context& fc)
+    {
+        // The current back buffer's allocator is safe to reset only after its previous overlay pass completes.
+        if (wait_for_fence_value(fc.fence_value))
+            fc.fence_value = 0;
+    }
+
+    void wait_for_gpu()
+    {
+        // ResizeBuffers and shutdown must not release back buffers still referenced by queued overlay commands.
+        if (!g_command_queue || !g_fence || !g_fence_event)
+            return;
+
+        const UINT64 fence_value = ++g_fence_value;
+        if (FAILED(g_command_queue->Signal(g_fence, fence_value)))
+            return;
+
+        if (wait_for_fence_value(fence_value))
+        {
+            for (auto& fc : g_frames)
+                fc.fence_value = 0;
+        }
+    }
+
+    bool signal_frame(frame_context& fc)
+    {
+        if (!g_command_queue || !g_fence)
+            return false;
+
+        const UINT64 fence_value = ++g_fence_value;
+        if (FAILED(g_command_queue->Signal(g_fence, fence_value)))
+            return false;
+
+        fc.fence_value = fence_value;
+        return true;
+    }
+
+    void release_sync_objects()
+    {
+        if (g_fence_event)
+        {
+            CloseHandle(g_fence_event);
+            g_fence_event = nullptr;
+        }
+        if (g_fence)
+        {
+            g_fence->Release();
+            g_fence = nullptr;
+        }
+        g_fence_value = 0;
+    }
+
+    void release_frame_contexts()
+    {
+        for (auto& fc : g_frames)
+        {
+            if (fc.render_target)
+            {
+                fc.render_target->Release();
+                fc.render_target = nullptr;
+            }
+            if (fc.command_allocator)
+            {
+                fc.command_allocator->Release();
+                fc.command_allocator = nullptr;
+            }
+            fc.fence_value = 0;
+        }
+        g_frames.clear();
+
+        if (g_rtv_heap)
+        {
+            g_rtv_heap->Release();
+            g_rtv_heap = nullptr;
+        }
+    }
+
+    void release_command_objects()
+    {
+        if (g_command_list)
+        {
+            g_command_list->Release();
+            g_command_list = nullptr;
+        }
+    }
+
+    bool create_command_objects()
+    {
+        if (g_frames.empty() || !g_frames[0].command_allocator)
+            return false;
+
+        if (FAILED(g_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, g_frames[0].command_allocator,
+                                               nullptr, IID_PPV_ARGS(&g_command_list))))
+        {
+            release_command_objects();
+            return false;
+        }
+
+        g_command_list->Close();
+        return true;
+    }
+
+    bool create_render_targets(IDXGISwapChain* swap_chain)
+    {
+        // These references must be released before IDXGISwapChain::ResizeBuffers reaches the original function.
         DXGI_SWAP_CHAIN_DESC desc{};
-        swap_chain->GetDesc(&desc);
+        if (FAILED(swap_chain->GetDesc(&desc)))
+            return false;
+
         const UINT buffer_count = desc.BufferCount;
 
-        {
-            D3D12_DESCRIPTOR_HEAP_DESC heap_desc{};
-            heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
-            heap_desc.NumDescriptors = buffer_count;
-            heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
-            if (FAILED(g_device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&g_srv_heap))))
-                return;
-        }
-        {
         D3D12_DESCRIPTOR_HEAP_DESC heap_desc{};
         heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
         heap_desc.NumDescriptors = buffer_count;
         heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
         heap_desc.NodeMask = 1;
         if (FAILED(g_device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&g_rtv_heap))))
-                return;
-        }
-
-        if (FAILED(g_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
-                                                    IID_PPV_ARGS(&g_command_allocator))))
-            return;
+            return false;
 
         g_frames.resize(buffer_count);
         const UINT rtv_size = g_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
@@ -74,16 +278,92 @@ namespace
         for (UINT i = 0; i < buffer_count; ++i)
         {
             g_frames[i].rtv_handle = rtv_handle;
+            if (FAILED(g_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
+                                                        IID_PPV_ARGS(&g_frames[i].command_allocator))))
+            {
+                release_frame_contexts();
+                return false;
+            }
             if (FAILED(swap_chain->GetBuffer(i, IID_PPV_ARGS(&g_frames[i].render_target))))
-                return;
+            {
+                release_frame_contexts();
+                return false;
+            }
             g_device->CreateRenderTargetView(g_frames[i].render_target, nullptr, rtv_handle);
             rtv_handle.ptr += rtv_size;
         }
 
-        if (FAILED(g_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, g_command_allocator, nullptr,
-                                               IID_PPV_ARGS(&g_command_list))))
+        return true;
+    }
+
+    void init(IDXGISwapChain* swap_chain)
+    {
+        IDXGISwapChain3* swap_chain3 = nullptr;
+        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&swap_chain3))))
+            return;
+
+        ID3D12Device* device = nullptr;
+        if (FAILED(swap_chain->GetDevice(IID_PPV_ARGS(&device))))
+        {
+            swap_chain3->Release();
+            return;
+        }
+
+        IUnknown* swap_chain_identity = nullptr;
+        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&swap_chain_identity))))
+        {
+            device->Release();
+            swap_chain3->Release();
+            return;
+        }
+
+        DXGI_SWAP_CHAIN_DESC desc{};
+        if (FAILED(swap_chain->GetDesc(&desc)))
+        {
+            swap_chain_identity->Release();
+            device->Release();
+            swap_chain3->Release();
+            return;
+        }
+
+        ID3D12CommandQueue* command_queue = take_command_queue_for_device(device);
+        if (!command_queue)
+        {
+            swap_chain_identity->Release();
+            device->Release();
+            swap_chain3->Release();
+            return;
+        }
+
+        g_init_attempted = true;
+        g_swap_chain = swap_chain3;
+        g_swap_chain_identity = swap_chain_identity;
+        g_device = device;
+        g_command_queue = command_queue;
+        const UINT buffer_count = desc.BufferCount;
+
+        {
+            D3D12_DESCRIPTOR_HEAP_DESC heap_desc{};
+            heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
+            heap_desc.NumDescriptors = srv_heap_size;
+            heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
+            if (FAILED(g_device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&g_srv_heap))))
+                return;
+
+            g_srv_descriptor_size = g_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
+            g_free_srv_indices.reserve(srv_heap_size);
+            for (UINT i = srv_heap_size; i > 0; --i)
+                g_free_srv_indices.push_back(i - 1);
+        }
+
+        if (!create_render_targets(swap_chain))
+            return;
+
+        if (!create_command_objects())
+            return;
+
+        if (!create_sync_objects())
             return;
-        g_command_list->Close();
 
         ImGui::CreateContext();
         ImGui::StyleColorsDark();
@@ -92,9 +372,17 @@ namespace
         ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
 
         ImGui_ImplWin32_Init(desc.OutputWindow);
-        ImGui_ImplDX12_Init(g_device, static_cast<int>(buffer_count), desc.BufferDesc.Format, g_srv_heap,
-                            g_srv_heap->GetCPUDescriptorHandleForHeapStart(),
-                            g_srv_heap->GetGPUDescriptorHandleForHeapStart());
+
+        ImGui_ImplDX12_InitInfo init_info{};
+        init_info.Device = g_device;
+        init_info.CommandQueue = g_command_queue;
+        init_info.NumFramesInFlight = static_cast<int>(buffer_count);
+        init_info.RTVFormat = desc.BufferDesc.Format;
+        init_info.DSVFormat = DXGI_FORMAT_UNKNOWN;
+        init_info.SrvDescriptorHeap = g_srv_heap;
+        init_info.SrvDescriptorAllocFn = allocate_srv_descriptor;
+        init_info.SrvDescriptorFreeFn = free_srv_descriptor;
+        ImGui_ImplDX12_Init(&init_info);
         ImGui_ImplDX12_CreateDeviceObjects();
 
         auto& mgr = omath::hooks::HooksManager::get();
@@ -104,8 +392,10 @@ namespace
                     if (!show_menu)
                         return std::nullopt;
 
-                    ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp);
+                    if (ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp))
                         return true;
+
+                    return std::nullopt;
                 });
         std::ignore = mgr.hook_wnd_proc(desc.OutputWindow);
 
@@ -114,27 +404,60 @@ namespace
 
     void on_execute_command_lists(ID3D12CommandQueue* queue, UINT, ID3D12CommandList* const*)
     {
-        if (!g_command_queue)
-            g_command_queue = queue;
+        // The most recently used DIRECT queue is the best available proxy for the swap chain's presentation queue.
+        remember_direct_command_queue(queue);
     }
 
-    void on_present(IDXGISwapChain* swap_chain, UINT, UINT)
+    bool ensure_initialized(IDXGISwapChain* swap_chain)
     {
-        if (!g_initialized)
-        {
-            if (!g_init_attempted && g_command_queue)
+        if (g_initialized)
+            return true;
+
+        if (!g_init_attempted)
             init(swap_chain);
-            return;
+
+        return false;
     }
 
-        if (!g_command_queue)
-            return;
+    bool ensure_render_targets(IDXGISwapChain* swap_chain)
+    {
+        if (!g_frames.empty() && g_rtv_heap)
+            return true;
 
+        return create_render_targets(swap_chain);
+    }
+
+    bool ensure_command_list()
+    {
+        if (g_command_list)
+            return true;
+
+        return create_command_objects();
+    }
+
+    bool ensure_sync_ready()
+    {
+        if (g_fence)
+            return true;
+
+        return create_sync_objects();
+    }
+
+    bool ensure_present_resources(IDXGISwapChain* swap_chain)
+    {
+        if (!ensure_initialized(swap_chain) || !g_command_queue)
+            return false;
+
+        return ensure_render_targets(swap_chain) && ensure_command_list() && ensure_sync_ready();
+    }
+
+    bool begin_imgui_frame()
+    {
         if (GetAsyncKeyState(VK_INSERT) & 1)
             show_menu = !show_menu;
 
         if (!show_menu)
-            return;
+            return false;
 
         ImGui_ImplDX12_NewFrame();
         ImGui_ImplWin32_NewFrame();
@@ -142,77 +465,133 @@ namespace
         ImGui::GetIO().MouseDrawCursor = true;
         ImGui::ShowDemoWindow();
         ImGui::EndFrame();
+        return true;
+    }
 
+    frame_context* current_frame_context()
+    {
         const UINT buf_idx = g_swap_chain->GetCurrentBackBufferIndex();
-        auto& fc = g_frames[buf_idx];
+        if (buf_idx >= g_frames.size())
+            return nullptr;
 
-        g_command_allocator->Reset();
-        g_command_list->Reset(g_command_allocator, nullptr);
+        return &g_frames[buf_idx];
+    }
 
+    bool reset_overlay_command_list(frame_context& fc)
+    {
+        wait_for_frame(fc);
+
+        // Both resets depend on wait_for_frame(); otherwise DLSSG/Streamline can observe invalid GPU work.
+        if (FAILED(fc.command_allocator->Reset()))
+            return false;
+
+        if (FAILED(g_command_list->Reset(fc.command_allocator, nullptr)))
+            return false;
+
+        return true;
+    }
+
+    void transition_render_target(frame_context& fc, D3D12_RESOURCE_STATES before, D3D12_RESOURCE_STATES after)
+    {
         D3D12_RESOURCE_BARRIER barrier{};
         barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
         barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
         barrier.Transition.pResource = fc.render_target;
         barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
-        barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
-        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
+        barrier.Transition.StateBefore = before;
+        barrier.Transition.StateAfter = after;
         g_command_list->ResourceBarrier(1, &barrier);
+    }
+
+    void record_overlay_commands(frame_context& fc)
+    {
+        transition_render_target(fc, D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET);
         g_command_list->OMSetRenderTargets(1, &fc.rtv_handle, FALSE, nullptr);
         g_command_list->SetDescriptorHeaps(1, &g_srv_heap);
 
         ImGui::Render();
         ImGui_ImplDX12_RenderDrawData(ImGui::GetDrawData(), g_command_list);
 
-        barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
-        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT;
-        g_command_list->ResourceBarrier(1, &barrier);
-        g_command_list->Close();
+        transition_render_target(fc, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT);
+    }
+
+    bool submit_overlay_commands(frame_context& fc)
+    {
+        if (FAILED(g_command_list->Close()))
+            return false;
 
         ID3D12CommandList* cmd_lists[] = {g_command_list};
         g_command_queue->ExecuteCommandLists(1, cmd_lists);
+        return signal_frame(fc);
+    }
+
+    void on_present(IDXGISwapChain* swap_chain, UINT, UINT)
+    {
+        if (g_initialized && !is_target_swap_chain(swap_chain))
+            return;
+
+        if (!ensure_present_resources(swap_chain) || !begin_imgui_frame())
+            return;
+
+        frame_context* fc = current_frame_context();
+        if (!fc || !reset_overlay_command_list(*fc))
+            return;
+
+        record_overlay_commands(*fc);
+        std::ignore = submit_overlay_commands(*fc);
+    }
+
+    void on_resize_buffers(IDXGISwapChain* swap_chain, UINT, UINT, UINT, DXGI_FORMAT, UINT)
+    {
+        if (!is_target_swap_chain(swap_chain))
+            return;
+
+        wait_for_gpu();
+        release_command_objects();
+        release_frame_contexts();
     }
 
     void release_dx12_resources()
     {
-        for (auto& fc : g_frames)
-        {
-            if (fc.render_target)
-            {
-                fc.render_target->Release();
-                fc.render_target = nullptr;
-            }
-        }
-        g_frames.clear();
-        if (g_command_allocator)
-        {
-            g_command_allocator->Release();
-            g_command_allocator = nullptr;
-        }
-        if (g_command_list)
-        {
-            g_command_list->Release();
-            g_command_list = nullptr;
-        }
+        wait_for_gpu();
+        release_command_objects();
+        release_frame_contexts();
+        release_sync_objects();
         if (g_srv_heap)
         {
             g_srv_heap->Release();
             g_srv_heap = nullptr;
         }
-        if (g_rtv_heap)
-        {
-            g_rtv_heap->Release();
-            g_rtv_heap = nullptr;
-        }
+        g_srv_descriptor_size = 0;
+        g_free_srv_indices.clear();
         if (g_swap_chain)
         {
             g_swap_chain->Release();
             g_swap_chain = nullptr;
         }
+        if (g_swap_chain_identity)
+        {
+            g_swap_chain_identity->Release();
+            g_swap_chain_identity = nullptr;
+        }
         if (g_device)
         {
             g_device->Release();
             g_device = nullptr;
         }
+        if (g_command_queue)
+        {
+            g_command_queue->Release();
+            g_command_queue = nullptr;
+        }
+
+        std::scoped_lock lock(g_command_queue_mutex);
+        if (g_pending_command_queue)
+        {
+            g_pending_command_queue->Release();
+            g_pending_command_queue = nullptr;
+        }
+        g_command_queue_selected = false;
     }
 } // namespace
 
@@ -221,20 +600,20 @@ BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
     if (reason == DLL_PROCESS_ATTACH)
     {
         DisableThreadLibraryCalls(h_instance);
-        CreateThread(
-                nullptr, 0,
-                [](LPVOID) -> DWORD
+        std::thread(
+                []()
                 {
                     while (!GetModuleHandle("d3d12.dll"))
                         Sleep(100);
 
                     auto& mgr = omath::hooks::HooksManager::get();
                     mgr.set_on_present(on_present);
+                    mgr.set_on_resize_buffers(on_resize_buffers);
                     mgr.set_on_execute_command_lists(on_execute_command_lists);
                     std::ignore = mgr.hook_dx12();
                     return 0;
-                },
-                nullptr, 0, nullptr);
+                })
+                .detach();
     }
     else if (reason == DLL_PROCESS_DETACH)
     {

examples/example_dx9_hook/dllmain.cpp

@@ -1,11 +1,10 @@
+#include "omath/hooks/hooks_manager.hpp"
 #include <Windows.h>
 #include <d3d9.h>
 #include <imgui.h>
 #include <imgui_impl_dx9.h>
 #include <imgui_impl_win32.h>
 
-#include "omath/hooks/hooks_manager.hpp"
-
 extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND, UINT, WPARAM, LPARAM);
 
 namespace
@@ -31,12 +30,14 @@ namespace
         ImGui_ImplDX9_Init(device);
 
         auto& mgr = omath::hooks::HooksManager::get();
-        mgr.set_on_wnd_proc([](HWND h, UINT msg, WPARAM wp, LPARAM lp) -> std::optional<LRESULT> {
+        mgr.set_on_wnd_proc(
+                [](HWND h, UINT msg, WPARAM wp, LPARAM lp) -> std::optional<LRESULT>
+                {
                     if (ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp))
                         return 0;
                     return std::nullopt;
                 });
-        mgr.hook_wnd_proc(params.hFocusWindow);
+        std::ignore = mgr.hook_wnd_proc(params.hFocusWindow);
 
         g_initialized = true;
     }
@@ -54,11 +55,8 @@ namespace
         ImGui_ImplWin32_NewFrame();
         ImGui::NewFrame();
 
-        ImGui::SetNextWindowSize({300.f, 80.f}, ImGuiCond_Once);
-        ImGui::SetNextWindowPos({10.f, 10.f}, ImGuiCond_Once);
-        ImGui::Begin("omath | DX9 hook");
-        ImGui::Text("Hook active");
-        ImGui::Text("FPS: %.1f", ImGui::GetIO().Framerate);
+        ImGui::GetIO().MouseDrawCursor = true;
+        ImGui::ShowDemoWindow();
         ImGui::End();
 
         ImGui::EndFrame();
@@ -78,7 +76,8 @@ BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
     if (reason == DLL_PROCESS_ATTACH)
     {
         DisableThreadLibraryCalls(h_instance);
-        CreateThread(nullptr, 0, [](LPVOID) -> DWORD
+        std::thread(
+                []()
                 {
                     while (!GetModuleHandle("d3d9.dll"))
                         Sleep(100);
@@ -86,9 +85,10 @@ BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
                     auto& mgr = omath::hooks::HooksManager::get();
                     mgr.set_on_dx9_present(on_present);
                     mgr.set_on_dx9_reset(on_reset);
-            mgr.hook_dx9();
+                    std::ignore = mgr.hook_dx9();
                     return 0;
-        }, nullptr, 0, nullptr);
+                })
+                .detach();
     }
     else if (reason == DLL_PROCESS_DETACH)
     {

examples/example_hud/gui/main_window.cpp

@@ -4,6 +4,7 @@
 #include "main_window.hpp"
 #include "omath/hud/renderer_realizations/imgui_renderer.hpp"
 #include <GLFW/glfw3.h>
+#include <cmath>
 #include <imgui.h>
 #include <imgui_impl_glfw.h>
 #include <imgui_impl_opengl3.h>
@@ -65,6 +66,19 @@ namespace imgui_desktop::gui
         ImGui::Begin("Controls", &m_opened,
                      ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
         ImGui::PushItemWidth(160.f);
+        const auto draw_glow_controls = [](const char* label, GlowSettings& settings)
+        {
+            ImGui::PushID(label);
+            ImGui::TextUnformatted(label);
+            ImGui::Checkbox("Glow", &settings.enabled);
+            if (settings.enabled)
+            {
+                ImGui::ColorEdit4("Color", reinterpret_cast<float*>(&settings.color), ImGuiColorEditFlags_NoInputs);
+                ImGui::InputFloat("Radius", &settings.radius);
+                ImGui::InputFloat("Intensity", &settings.intensity);
+            }
+            ImGui::PopID();
+        };
 
         if (ImGui::CollapsingHeader("Entity", ImGuiTreeNodeFlags_DefaultOpen))
         {
@@ -72,6 +86,12 @@ namespace imgui_desktop::gui
             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);
             ImGui::SliderFloat("Aspect", &m_entity_aspect, 1.f, 10.f);
+            draw_glow_controls("Canvas light", m_canvas_glow);
+            if (m_canvas_glow.enabled)
+            {
+                ImGui::InputInt("Blur layers##canvas", &m_canvas_glow_layers);
+                ImGui::InputFloat("Rounding##canvas", &m_canvas_glow_rounding);
+            }
         }
 
         if (ImGui::CollapsingHeader("Box", ImGuiTreeNodeFlags_DefaultOpen))
@@ -83,9 +103,20 @@ namespace imgui_desktop::gui
             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::Checkbox("Gradient fill", &m_gradient_box_fill);
+            ImGui::Checkbox("Animate gradients", &m_animate_gradients);
+            if (m_gradient_box_fill)
+            {
+                ImGui::ColorEdit4("Gradient top##box", reinterpret_cast<float*>(&m_box_gradient_top),
+                                  ImGuiColorEditFlags_NoInputs);
+                ImGui::ColorEdit4("Gradient bottom##box", reinterpret_cast<float*>(&m_box_gradient_bottom),
+                                  ImGuiColorEditFlags_NoInputs);
+            }
             ImGui::ColorEdit4("Outline##box", reinterpret_cast<float*>(&m_box_outline), ImGuiColorEditFlags_NoInputs);
             ImGui::SliderFloat("Thickness", &m_box_thickness, 0.5f, 5.f);
             ImGui::SliderFloat("Corner ratio", &m_corner_ratio, 0.05f, 0.5f);
+            draw_glow_controls("Box glow", m_box_glow);
+            draw_glow_controls("Cornered box glow", m_cornered_box_glow);
             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);
@@ -99,6 +130,7 @@ namespace imgui_desktop::gui
             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::Checkbox("Gradient bars", &m_gradient_bars);
             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);
@@ -116,11 +148,26 @@ namespace imgui_desktop::gui
             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);
+            draw_glow_controls("Bar glow", m_bar_glow);
         }
 
         if (ImGui::CollapsingHeader("Labels", ImGuiTreeNodeFlags_DefaultOpen))
         {
             ImGui::Checkbox("Outlined", &m_outlined);
+            ImGui::Checkbox("Gradient centered label", &m_gradient_label);
+            if (m_gradient_label)
+            {
+                ImGui::ColorEdit4("Gradient left##lbl", reinterpret_cast<float*>(&m_label_gradient_left),
+                                  ImGuiColorEditFlags_NoInputs);
+                ImGui::ColorEdit4("Gradient right##lbl", reinterpret_cast<float*>(&m_label_gradient_right),
+                                  ImGuiColorEditFlags_NoInputs);
+                if (m_animate_gradients)
+                {
+                    int direction = static_cast<int>(m_label_gradient_direction);
+                    if (ImGui::Combo("Direction##lbl", &direction, "Right to left\0Left to right\0"))
+                        m_label_gradient_direction = static_cast<omath::hud::GradientDirection>(direction);
+                }
+            }
             ImGui::SliderFloat("Offset##lbl", &m_label_offset, 0.f, 15.f);
             ImGui::Checkbox("Right##lbl", &m_show_right_labels);
             ImGui::SameLine();
@@ -131,6 +178,7 @@ namespace imgui_desktop::gui
             ImGui::Checkbox("Ctr top##lbl", &m_show_centered_top);
             ImGui::SameLine();
             ImGui::Checkbox("Ctr bot##lbl", &m_show_centered_bottom);
+            draw_glow_controls("Label glow", m_label_glow);
         }
 
         if (ImGui::CollapsingHeader("Skeleton"))
@@ -193,9 +241,83 @@ namespace imgui_desktop::gui
         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};
+        const float entity_height = m_entity_bottom_y - m_entity_top_y;
+        const float entity_half_width = entity_height / m_entity_aspect;
+        const auto joint = [&](const float x, const float y)
+        {
+            return omath::Vector2<float>{m_entity_x + (x * 2.f - 1.f) * entity_half_width,
+                                         m_entity_top_y + y * entity_height};
+        };
+        const auto head = joint(0.5f, 0.1f);
+        const auto neck = joint(0.5f, 0.22f);
+        const auto torso = joint(0.5f, 0.5f);
+        const auto left_shoulder = joint(0.3f, 0.25f);
+        const auto right_shoulder = joint(0.7f, 0.25f);
+        const auto left_elbow = joint(0.18f, 0.42f);
+        const auto right_elbow = joint(0.82f, 0.42f);
+        const auto left_hand = joint(0.1f, 0.58f);
+        const auto right_hand = joint(0.9f, 0.58f);
+        const auto left_hip = joint(0.4f, 0.55f);
+        const auto right_hip = joint(0.6f, 0.55f);
+        const auto left_knee = joint(0.36f, 0.75f);
+        const auto right_knee = joint(0.64f, 0.75f);
+        const auto left_foot = joint(0.3f, 0.95f);
+        const auto right_foot = joint(0.7f, 0.95f);
+        const std::array skeleton_bones = {
+                Bone{head, neck},
+                Bone{neck, torso},
+                Bone{neck, left_shoulder},
+                Bone{left_shoulder, left_elbow},
+                Bone{left_elbow, left_hand},
+                Bone{neck, right_shoulder},
+                Bone{right_shoulder, right_elbow},
+                Bone{right_elbow, right_hand},
+                Bone{torso, left_hip},
+                Bone{left_hip, left_knee},
+                Bone{left_knee, left_foot},
+                Bone{torso, right_hip},
+                Bone{right_hip, right_knee},
+                Bone{right_knee, right_foot},
+        };
+        const auto animated_color = [&](const omath::Color& color, const float hue_offset)
+        {
+            if (!m_animate_gradients)
+                return color;
+
+            auto hsv = color.to_hsv();
+            hsv.hue = std::fmod(hsv.hue + static_cast<float>(ImGui::GetTime()) * 0.15f + hue_offset, 1.f);
+            const auto animated = omath::Color::from_hsv(hsv).value();
+            return omath::Color{animated.x, animated.y, animated.z, color.value().w};
+        };
+        const auto box_gradient_top = animated_color(m_box_gradient_top, 0.f);
+        const auto box_gradient_bottom = animated_color(m_box_gradient_bottom, 0.5f);
+        const auto red = omath::Color{1.f, 0.f, 0.f, 1.f};
+        const auto green = omath::Color{0.f, 1.f, 0.f, 1.f};
+        const auto make_glow = [](const GlowSettings& settings) -> std::optional<Glow>
+        {
+            if (!settings.enabled)
+                return std::nullopt;
+            return Glow{settings.color, settings.radius, settings.intensity};
+        };
+        const auto box_glow = make_glow(m_box_glow);
+        const auto cornered_box_glow = make_glow(m_cornered_box_glow);
+        const auto bar_glow = make_glow(m_bar_glow);
+        const auto label_glow = make_glow(m_label_glow);
+        const auto canvas_glow = make_glow(m_canvas_glow);
+        const BarPaint bar_color = m_gradient_bars ? BarPaint{BarGradient{red, green}} : BarPaint{m_bar_color};
+        const Bar bar{bar_color, m_bar_outline_color, m_bar_bg_color, m_bar_width, m_bar_value, m_bar_offset, bar_glow};
+        const Paint box_fill = m_gradient_box_fill
+                                       ? Paint{omath::hud::Gradient{box_gradient_top, box_gradient_top,
+                                                                    box_gradient_bottom, box_gradient_bottom}}
+                                       : Paint{m_box_fill};
+        const Paint centered_label_color =
+                m_gradient_label ? Paint{omath::hud::Gradient{m_label_gradient_left, m_label_gradient_right,
+                                                              m_label_gradient_right, m_label_gradient_left,
+                                                              m_animate_gradients, 4.f, 0.7f,
+                                                              m_label_gradient_direction}}
+                                 : Paint{omath::Color::from_rgba(255, 255, 255, 255)};
 
         auto outline_helper = [](const bool is_outline) -> Outlined
         {
@@ -204,10 +326,13 @@ namespace imgui_desktop::gui
         omath::hud::EntityOverlay({m_entity_x, m_entity_top_y}, {m_entity_x, m_entity_bottom_y}, m_entity_aspect,
                                   std::make_shared<omath::hud::ImguiHudRenderer>())
                 .contents(
+                        when(canvas_glow.has_value(), CanvasGlow{canvas_glow.value_or(Glow{m_canvas_glow.color}),
+                                                                 m_canvas_glow_layers, m_canvas_glow_rounding}),
                         // ── Boxes ────────────────────────────────────────────────────
-                        when(m_show_box, Box{m_box_color, m_box_fill, m_box_outline, m_box_thickness}),
-                        when(m_show_cornered_box, CorneredBox{omath::Color::from_rgba(255, 0, 255, 255), m_box_fill,
-                                                              m_box_outline, m_corner_ratio, m_box_thickness}),
+                        when(m_show_box, Box{m_box_color, box_fill, m_box_outline, m_box_thickness, box_glow}),
+                        when(m_show_cornered_box,
+                             CorneredBox{omath::Color::from_rgba(255, 0, 255, 255), m_box_fill, m_box_outline,
+                                         m_corner_ratio, m_box_thickness, cornered_box_glow}),
                         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),
@@ -254,14 +379,14 @@ namespace imgui_desktop::gui
                                 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,
-                                                    outline_helper(m_outlined), "PlayerName"}}),
+                                     Centered{Label{centered_label_color, m_label_offset, outline_helper(m_outlined),
+                                                    "Gradient PlayerName", label_glow}}),
                                 when(m_show_bottom_labels, Label{omath::Color::from_rgba(200, 200, 0, 255),
                                                                  m_label_offset, outline_helper(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_skeleton, Skeleton{skeleton_bones, 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,

examples/example_hud/gui/main_window.hpp

@@ -17,6 +17,14 @@ namespace imgui_desktop::gui
         void Run();
 
     private:
+        struct GlowSettings
+        {
+            omath::Color color{0.f, 0.7f, 1.f, 0.8f};
+            float radius = 4.f;
+            float intensity = 0.8f;
+            bool enabled = false;
+        };
+
         void draw_controls();
         void draw_overlay();
         void present();
@@ -30,8 +38,12 @@ namespace imgui_desktop::gui
         // 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};
+        omath::Color m_box_gradient_top{0.1f, 0.6f, 1.f, 0.55f};
+        omath::Color m_box_gradient_bottom{0.7f, 0.1f, 1.f, 0.15f};
         omath::Color m_box_outline{0.f, 0.f, 0.f, 0.f};
         float m_box_thickness = 1.f, m_corner_ratio = 0.2f;
+        bool m_gradient_box_fill = true;
+        bool m_animate_gradients = false;
         bool m_show_box = true, m_show_cornered_box = true, m_show_dashed_box = false;
 
         // Dashed box
@@ -43,6 +55,7 @@ namespace imgui_desktop::gui
         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_gradient_bars = true;
         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;
@@ -51,11 +64,23 @@ namespace imgui_desktop::gui
 
         // Labels
         float m_label_offset = 3.f;
+        omath::Color m_label_gradient_left{0.f, 0.8f, 1.f, 1.f};
+        omath::Color m_label_gradient_right{1.f, 0.2f, 0.7f, 1.f};
         bool m_outlined = true;
+        bool m_gradient_label = true;
+        omath::hud::GradientDirection m_label_gradient_direction = omath::hud::GradientDirection::RightToLeft;
         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;
 
+        GlowSettings m_box_glow;
+        GlowSettings m_cornered_box_glow{{1.f, 0.f, 1.f, 0.8f}};
+        GlowSettings m_bar_glow{{1.f, 0.f, 0.f, 0.8f}};
+        GlowSettings m_label_glow;
+        GlowSettings m_canvas_glow{{1.f, 0.5f, 0.f, 0.8f}, 100.f};
+        int m_canvas_glow_layers = 64;
+        float m_canvas_glow_rounding = 40.f;
+
         // Skeleton
         omath::Color m_skel_color = omath::Color::from_rgba(255, 255, 255, 200);
         float m_skel_thickness = 1.f;

include/omath/3d_primitives/aabb.hpp

@@ -4,17 +4,28 @@
 
 #pragma once
 #include "omath/linear_algebra/vector3.hpp"
+#include <array>
 
 namespace omath::primitives
 {
-    enum class UpAxis { X, Y, Z };
+    enum class UpAxis
+    {
+        X,
+        Y,
+        Z
+    };
 
-    template<class Type>
+    template<class Type, UpAxis Up = UpAxis::Y>
     struct Aabb final
     {
         Vector3<Type> min;
         Vector3<Type> max;
 
+        [[nodiscard]]
+        static consteval UpAxis get_up_axis()
+        {
+            return Up;
+        }
         [[nodiscard]]
         constexpr Vector3<Type> center() const noexcept
         {
@@ -27,7 +38,6 @@ namespace omath::primitives
             return (max - min) / static_cast<Type>(2);
         }
 
-        template<UpAxis Up = UpAxis::Y>
         [[nodiscard]]
         constexpr Vector3<Type> top() const noexcept
         {
@@ -42,7 +52,6 @@ namespace omath::primitives
                 std::unreachable();
         }
 
-        template<UpAxis Up = UpAxis::Y>
         [[nodiscard]]
         constexpr Vector3<Type> bottom() const noexcept
         {
@@ -57,11 +66,22 @@ namespace omath::primitives
                 std::unreachable();
         }
 
+        [[nodiscard]]
+        constexpr std::array<Vector3<Type>, 8> vertices() const noexcept
+        {
+            return {
+                    Vector3<Type>{min.x, min.y, min.z}, Vector3<Type>{max.x, min.y, min.z},
+                    Vector3<Type>{min.x, max.y, min.z}, Vector3<Type>{max.x, max.y, min.z},
+                    Vector3<Type>{min.x, min.y, max.z}, Vector3<Type>{max.x, min.y, max.z},
+                    Vector3<Type>{min.x, max.y, max.z}, Vector3<Type>{max.x, max.y, max.z},
+            };
+        }
+
         [[nodiscard]]
         constexpr bool is_collide(const Aabb& other) const noexcept
         {
-            return min.x <= other.max.x && max.x >= other.min.x &&
-                min.y <= other.max.y && max.y >= other.min.y &&min.z <= other.max.z && max.z >= other.min.z;
+            return min.x <= other.max.x && max.x >= other.min.x && min.y <= other.max.y && max.y >= other.min.y
+                   && min.z <= other.max.z && max.z >= other.min.z;
         }
     };
 } // namespace omath::primitives

include/omath/algorithm/radar.hpp

@@ -0,0 +1,42 @@
+//
+// Created by orange on 7/1/2026.
+//
+#pragma once
+#include "omath/linear_algebra/vector3.hpp"
+#include <type_traits>
+
+namespace omath::algorithm
+{
+    template<class Camera, class FloatingType>
+    requires std::is_floating_point_v<FloatingType>
+    [[nodiscard]]
+    constexpr Vector2<float> world_to_radar(const Camera& camera, const Vector3<FloatingType>& position, const FloatingType scale)
+    {
+        const auto look_at_angles = camera.calc_look_at_angles(position);
+        const auto current_angles = camera.get_view_angles();
+
+        if consteval
+        {
+            const auto right_yaw = current_angles.yaw
+                             - camera.calc_look_at_angles(camera.get_origin() + camera.get_abs_right()).yaw
+                             - decltype(current_angles.yaw)::from_degrees(90);
+            const auto sign =  right_yaw.cos() < 0 ? -1.f : 1.f;
+
+            const auto yaw = current_angles.yaw - look_at_angles.yaw - decltype(current_angles.yaw)::from_degrees(90);
+            return omath::Vector2<float>(static_cast<float>(yaw.cos()) * sign, static_cast<float>(yaw.sin()))
+               * (camera.get_origin().distance_to(position) * scale);
+        }
+        static const auto sign = [&camera, &current_angles]
+        {
+            const auto right_yaw = current_angles.yaw
+                             - camera.calc_look_at_angles(camera.get_origin() + camera.get_abs_right()).yaw
+                             - decltype(current_angles.yaw)::from_degrees(90);
+            return right_yaw.cos() < 0 ? -1.f : 1.f;
+        }();
+
+        const auto yaw = current_angles.yaw - look_at_angles.yaw - decltype(current_angles.yaw)::from_degrees(90);
+
+        return omath::Vector2<float>(static_cast<float>(yaw.cos()) * sign, static_cast<float>(yaw.sin()))
+               * (camera.get_origin().distance_to(position) * scale);
+    }
+} // namespace omath::algorithm

include/omath/engines/cry_engine/formulas.hpp

@@ -7,36 +7,87 @@
 
 namespace omath::cry_engine
 {
-    [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.roll)
+               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
+    }
 
-    [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("forward vector result should not be discarded")]]
+    constexpr Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept;
+    [[nodiscard("up vector result should not be discarded")]]
+    constexpr Vector3<float> up_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
 
-    [[nodiscard]]
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept;
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), right_vector(angles),
+                                                               up_vector(angles), cam_origin);
+    }
 
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept;
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.x),
+                YawAngle::from_degrees(angles.z),
+                RollAngle::from_degrees(angles.y),
+        };
+    }
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4
+    calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near_plane,
+                                       const float far_plane,
+                                       const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept
+    {
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         return units / static_cast<FloatingType>(100);
@@ -44,7 +95,7 @@ namespace omath::cry_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units;
@@ -52,7 +103,7 @@ namespace omath::cry_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -60,7 +111,7 @@ namespace omath::cry_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         return centimeters * static_cast<FloatingType>(100);
@@ -68,7 +119,7 @@ namespace omath::cry_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return meters;
@@ -76,7 +127,7 @@ namespace omath::cry_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -5,20 +5,34 @@
 #pragma once
 #include "omath/engines/cry_engine/formulas.hpp"
 #include "omath/projection/camera.hpp"
-
 namespace omath::cry_engine
 {
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        [[nodiscard("look-at angle result should not be discarded")]]
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
+            return {PitchAngle::from_asin(direction.z), -YawAngle::from_atan2(direction.x, direction.y),
+                    RollAngle::from_radians(0.f)};
+        }
 
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return cry_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::cry_engine

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

@@ -10,7 +10,7 @@ namespace omath::cry_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return cry_engine::rotation_matrix(rotation);

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

@@ -12,6 +12,7 @@ namespace omath::cry_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
@@ -25,7 +26,7 @@ namespace omath::cry_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -36,19 +37,19 @@ namespace omath::cry_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.y * delta.y);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.z;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -60,13 +61,13 @@ namespace omath::cry_engine
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
             return angles::radians_to_degrees(std::asin(direction.z));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();

include/omath/engines/frostbite_engine/formulas.hpp

@@ -7,36 +7,91 @@
 
 namespace omath::frostbite_engine
 {
-    [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("forward vector result should not be discarded")]]
+    constexpr Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept;
+    [[nodiscard("up vector result should not be discarded")]]
+    constexpr Vector3<float> up_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
 
-    [[nodiscard]]
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept;
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), right_vector(angles),
+                                                               up_vector(angles), cam_origin);
+    }
 
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
+    }
+
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.x),
+                YawAngle::from_degrees(angles.y),
+                RollAngle::from_degrees(angles.z),
+        };
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_perspective_projection_matrix(
+            const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane,
+            const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept
+    {
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         return units / static_cast<FloatingType>(100);
@@ -44,7 +99,7 @@ namespace omath::frostbite_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units;
@@ -52,7 +107,7 @@ namespace omath::frostbite_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -60,7 +115,7 @@ namespace omath::frostbite_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         return centimeters * static_cast<FloatingType>(100);
@@ -68,7 +123,7 @@ namespace omath::frostbite_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return meters;
@@ -76,7 +131,7 @@ namespace omath::frostbite_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -11,14 +11,30 @@ namespace omath::frostbite_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        [[nodiscard("look-at angle result should not be discarded")]]
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+            return {-PitchAngle::from_asin(direction.y), YawAngle::from_atan2(direction.x, direction.z),
+                    RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return frostbite_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
-} // namespace omath::unreal_engine
+} // namespace omath::frostbite_engine

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

@@ -10,7 +10,7 @@ namespace omath::frostbite_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return frostbite_engine::rotation_matrix(rotation);

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

@@ -12,6 +12,7 @@ namespace omath::frostbite_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
@@ -25,7 +26,7 @@ namespace omath::frostbite_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -36,19 +37,19 @@ namespace omath::frostbite_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.z * delta.z);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.y;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -60,13 +61,13 @@ namespace omath::frostbite_engine
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
             return angles::radians_to_degrees(std::asin(direction.y));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();

include/omath/engines/iw_engine/formulas.hpp

@@ -7,36 +7,89 @@
 
 namespace omath::iw_engine
 {
-    [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("forward vector result should not be discarded")]]
+    constexpr Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
-    [[nodiscard]]
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept;
+    [[nodiscard("up vector result should not be discarded")]]
+    constexpr Vector3<float> up_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
 
-    [[nodiscard]]
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
+    }
 
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.y),
+                YawAngle::from_degrees(angles.z),
+                RollAngle::from_degrees(angles.x),
+        };
+    }
+
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_perspective_projection_matrix(
+            const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane,
+            const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept
+    {
+        constexpr float k_source_reference_aspect = 4.f / 3.f;
+        const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect);
+
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    vertical_fov, aspect_ratio, near_plane, far_plane);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    vertical_fov, aspect_ratio, near_plane, far_plane);
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         constexpr auto centimeter_in_unit = static_cast<FloatingType>(2.54);
@@ -45,7 +98,7 @@ namespace omath::iw_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units_to_centimeters(units) / static_cast<FloatingType>(100);
@@ -53,7 +106,7 @@ namespace omath::iw_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -61,7 +114,7 @@ namespace omath::iw_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         constexpr auto centimeter_in_unit = static_cast<FloatingType>(2.54);
@@ -70,7 +123,7 @@ namespace omath::iw_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return centimeters_to_units(meters * static_cast<FloatingType>(100));
@@ -78,7 +131,7 @@ namespace omath::iw_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -3,7 +3,7 @@
 //
 
 #pragma once
-#include "omath/engines/iw_engine/constants.hpp"
+#include "omath/engines/iw_engine/formulas.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::iw_engine
@@ -11,14 +11,30 @@ namespace omath::iw_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        [[nodiscard("look-at angle result should not be discarded")]]
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+            return {-PitchAngle::from_asin(direction.z), YawAngle::from_atan2(direction.y, direction.x),
+                    RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return iw_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::iw_engine

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

@@ -10,7 +10,7 @@ namespace omath::iw_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return iw_engine::rotation_matrix(rotation);

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

@@ -13,6 +13,7 @@ namespace omath::iw_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
@@ -26,7 +27,7 @@ namespace omath::iw_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -37,19 +38,19 @@ namespace omath::iw_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.y * delta.y);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.z;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -61,7 +62,7 @@ namespace omath::iw_engine
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto distance = origin.distance_to(view_to);
@@ -69,7 +70,7 @@ namespace omath::iw_engine
 
             return angles::radians_to_degrees(std::asin(delta.z / distance));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto delta = view_to - origin;

include/omath/engines/opengl_engine/formulas.hpp

@@ -6,36 +6,93 @@
 
 namespace omath::opengl_engine
 {
-    [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("forward vector result should not be discarded")]]
+    constexpr 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);
 
-    [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr 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);
 
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept;
+    [[nodiscard("up vector result should not be discarded")]]
+    constexpr Vector3<float> up_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_up);
 
-    [[nodiscard]]
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept;
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr 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));
+    }
 
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll)
+               * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(angles.yaw)
+               * mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(angles.pitch);
+    }
+
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.x),
+                YawAngle::from_degrees(angles.y),
+                RollAngle::from_degrees(angles.z),
+        };
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_perspective_projection_matrix(
+            const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane,
+            const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept
+    {
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_right_handed_vertical_fov<float, MatStoreType::COLUMN_MAJOR,
+                                                             NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_right_handed_vertical_fov<float, MatStoreType::COLUMN_MAJOR,
+                                                             NDCDepthRange::ZERO_TO_ONE>(field_of_view, aspect_ratio,
+                                                                                         near_plane, far_plane);
+
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         return units / static_cast<FloatingType>(100);
@@ -43,7 +100,7 @@ namespace omath::opengl_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units;
@@ -51,7 +108,7 @@ namespace omath::opengl_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -59,7 +116,7 @@ namespace omath::opengl_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         return centimeters * static_cast<FloatingType>(100);
@@ -67,7 +124,7 @@ namespace omath::opengl_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return meters;
@@ -75,7 +132,7 @@ namespace omath::opengl_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -3,7 +3,7 @@
 //
 
 #pragma once
-#include "omath/engines/opengl_engine/constants.hpp"
+#include "omath/engines/opengl_engine/formulas.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::opengl_engine
@@ -11,14 +11,30 @@ namespace omath::opengl_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        [[nodiscard("look-at angle result should not be discarded")]]
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+            return {PitchAngle::from_asin(direction.y), -YawAngle::from_atan2(direction.x, -direction.z),
+                    RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return opengl_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::opengl_engine

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

@@ -10,7 +10,7 @@ namespace omath::opengl_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return opengl_engine::rotation_matrix(rotation);

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

@@ -12,6 +12,7 @@ namespace omath::opengl_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
@@ -25,7 +26,7 @@ namespace omath::opengl_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -36,19 +37,19 @@ namespace omath::opengl_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.z * delta.z);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.y;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -60,13 +61,13 @@ namespace omath::opengl_engine
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
             return angles::radians_to_degrees(std::asin(direction.y));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();

include/omath/engines/rage_engine/formulas.hpp

@@ -8,36 +8,91 @@
 
 namespace omath::rage_engine
 {
-    [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("forward vector result should not be discarded")]]
+    constexpr Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept;
+    [[nodiscard("up vector result should not be discarded")]]
+    constexpr Vector3<float> up_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
 
-    [[nodiscard]]
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept;
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), right_vector(angles),
+                                                               up_vector(angles), cam_origin);
+    }
 
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
-                                              NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.roll)
+               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
+    }
+
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.x),
+                YawAngle::from_degrees(angles.z),
+                RollAngle::from_degrees(angles.y),
+        };
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4
+    calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near_plane,
+                                       const float far_plane,
+                                       const NDCDepthRange ndc_depth_range = NDCDepthRange::ZERO_TO_ONE) noexcept
+    {
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         return units / static_cast<FloatingType>(100);
@@ -45,7 +100,7 @@ namespace omath::rage_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units;
@@ -53,7 +108,7 @@ namespace omath::rage_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -61,7 +116,7 @@ namespace omath::rage_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         return centimeters * static_cast<FloatingType>(100);
@@ -69,7 +124,7 @@ namespace omath::rage_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return meters;
@@ -77,7 +132,7 @@ namespace omath::rage_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -11,14 +11,30 @@ namespace omath::rage_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        [[nodiscard("look-at angle result should not be discarded")]]
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+            return {PitchAngle::from_asin(direction.z), -YawAngle::from_atan2(direction.x, direction.y),
+                    RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return rage_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::rage_engine

include/omath/engines/rage_engine/traits/mesh_trait.hpp

@@ -11,7 +11,7 @@ namespace omath::rage_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return rage_engine::rotation_matrix(rotation);

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

@@ -13,6 +13,7 @@ namespace omath::rage_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float>
         predict_projectile_position(const projectile_prediction::Projectile<float>& projectile, const float pitch,
                                     const float yaw, const float time, const float gravity) noexcept
@@ -26,7 +27,7 @@ namespace omath::rage_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -37,19 +38,19 @@ namespace omath::rage_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.y * delta.y);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.z;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -59,13 +60,13 @@ namespace omath::rage_engine
 
             return {predicted_target_position.x, predicted_target_position.y, projectile.m_origin.z + height};
         }
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
             return angles::radians_to_degrees(std::asin(direction.z));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();

include/omath/engines/source_engine/formulas.hpp

@@ -6,36 +6,89 @@
 
 namespace omath::source_engine
 {
-    [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+    [[nodiscard("forward vector result should not be discarded")]]
+    constexpr Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
+    }
 
-    [[nodiscard]]
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept;
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
 
-    [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
 
-    [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.y),
+                YawAngle::from_degrees(angles.z),
+                RollAngle::from_degrees(angles.x),
+        };
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+
+    [[nodiscard("up vector result should not be discarded")]]
+    constexpr Vector3<float> up_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
+
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
+
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_perspective_projection_matrix(
+            const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane,
+            const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept
+    {
+        constexpr float k_source_reference_aspect = 4.f / 3.f;
+        const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect);
+
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+                    vertical_fov, aspect_ratio, near_plane, far_plane);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    vertical_fov, aspect_ratio, near_plane, far_plane);
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         constexpr auto centimeter_in_unit = static_cast<FloatingType>(2.54);
@@ -44,7 +97,7 @@ namespace omath::source_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units_to_centimeters(units) / static_cast<FloatingType>(100);
@@ -52,7 +105,7 @@ namespace omath::source_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -60,7 +113,7 @@ namespace omath::source_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         constexpr auto centimeter_in_unit = static_cast<FloatingType>(2.54);
@@ -69,7 +122,7 @@ namespace omath::source_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return centimeters_to_units(meters * static_cast<FloatingType>(100));
@@ -77,7 +130,7 @@ namespace omath::source_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -3,7 +3,7 @@
 //
 
 #pragma once
-#include "omath/engines/source_engine/constants.hpp"
+#include "omath/engines/source_engine/formulas.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::source_engine
@@ -11,14 +11,30 @@ namespace omath::source_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        [[nodiscard("look-at angle result should not be discarded")]]
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+            return {-PitchAngle::from_asin(direction.z),
+                    YawAngle::from_atan2(direction.y, direction.x), RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return source_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::source_engine

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

@@ -10,7 +10,7 @@ namespace omath::source_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return source_engine::rotation_matrix(rotation);

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

@@ -13,6 +13,7 @@ namespace omath::source_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
@@ -26,7 +27,7 @@ namespace omath::source_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -37,19 +38,19 @@ namespace omath::source_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.y * delta.y);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.z;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -61,7 +62,7 @@ namespace omath::source_engine
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto distance = origin.distance_to(view_to);
@@ -69,7 +70,7 @@ namespace omath::source_engine
 
             return angles::radians_to_degrees(std::asin(delta.z / distance));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto delta = view_to - origin;

include/omath/engines/unity_engine/formulas.hpp

@@ -7,36 +7,90 @@
 
 namespace omath::unity_engine
 {
-    [[nodiscard]]
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("forward vector result should not be discarded")]]
+    constexpr Vector3<float> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr Vector3<float> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept;
+    [[nodiscard("up vector result should not be discarded")]]
+    constexpr Vector3<float> up_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
 
-    [[nodiscard]]
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept;
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+    {
+        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(-forward_vector(angles), right_vector(angles),
+                                                               up_vector(angles), cam_origin);
+    }
 
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll)
+               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
+    }
+
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<float> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<float> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(angles.x),
+                YawAngle::from_degrees(angles.y),
+                RollAngle::from_degrees(angles.z),
+        };
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_perspective_projection_matrix(
+            const float field_of_view, const float aspect_ratio, const float near_plane, const float far_plane,
+            const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept
+    {
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return omath::mat_perspective_right_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                                    NDCDepthRange::ZERO_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return omath::mat_perspective_right_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
+                                                                    NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         return units / static_cast<FloatingType>(100);
@@ -44,7 +98,7 @@ namespace omath::unity_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units;
@@ -52,7 +106,7 @@ namespace omath::unity_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -60,7 +114,7 @@ namespace omath::unity_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         return centimeters * static_cast<FloatingType>(100);
@@ -68,7 +122,7 @@ namespace omath::unity_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return meters;
@@ -76,7 +130,7 @@ namespace omath::unity_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -11,14 +11,30 @@ namespace omath::unity_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept;
+        [[nodiscard("look-at angle result should not be discarded")]]
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<float>& cam_origin,
+                                                       const Vector3<float>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             float near, float far, NDCDepthRange ndc_depth_range) noexcept;
+            return {-PitchAngle::from_asin(direction.y), YawAngle::from_atan2(direction.x, direction.z),
+                    RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
+        {
+            return unity_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const float near_plane,
+                                                       const float far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::unity_engine

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

@@ -10,7 +10,7 @@ namespace omath::unity_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return unity_engine::rotation_matrix(rotation);

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

@@ -12,6 +12,7 @@ namespace omath::unity_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
@@ -25,7 +26,7 @@ namespace omath::unity_engine
 
             return current_pos;
         }
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
         {
@@ -36,19 +37,19 @@ namespace omath::unity_engine
 
             return predicted;
         }
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static float calc_vector_2d_distance(const Vector3<float>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.z * delta.z);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         constexpr static float get_vector_height_coordinate(const Vector3<float>& vec) noexcept
         {
             return vec.y;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<float> calc_viewpoint_from_angles(const projectile_prediction::Projectile<float>& projectile,
                                                          Vector3<float> predicted_target_position,
                                                          const std::optional<float> projectile_pitch) noexcept
@@ -60,13 +61,13 @@ namespace omath::unity_engine
         }
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static float calc_direct_pitch_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
             return angles::radians_to_degrees(std::asin(direction.y));
         }
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static float calc_direct_yaw_angle(const Vector3<float>& origin, const Vector3<float>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();

include/omath/engines/unreal_engine/formulas.hpp

@@ -7,36 +7,90 @@
 
 namespace omath::unreal_engine
 {
-    [[nodiscard]]
-    Vector3<double> forward_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
 
-    [[nodiscard]]
-    Vector3<double> right_vector(const ViewAngles& angles) noexcept;
+    [[nodiscard("forward vector result should not be discarded")]]
+    constexpr Vector3<double> forward_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
 
-    [[nodiscard]]
-    Vector3<double> up_vector(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept;
+    [[nodiscard("right vector result should not be discarded")]]
+    constexpr Vector3<double> right_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
 
-    [[nodiscard]]
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    Vector3<double> extract_origin(const Mat4X4& mat) noexcept;
+    [[nodiscard("up vector result should not be discarded")]]
+    constexpr Vector3<double> up_vector(const ViewAngles& angles) noexcept
+    {
+        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
 
-    [[nodiscard]]
-    Vector3<double> extract_scale(const Mat4X4& mat) noexcept;
+        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
+    }
 
-    [[nodiscard]]
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept;
+    [[nodiscard("view matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept
+    {
+        return mat_camera_view<double, MatStoreType::ROW_MAJOR>(forward_vector(angles), right_vector(angles),
+                                                                up_vector(angles), cam_origin);
+    }
 
-    [[nodiscard]]
-    Mat4X4 calc_perspective_projection_matrix(double field_of_view, double aspect_ratio, double near, double far,
-                                             NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept;
+    [[nodiscard("rotation matrix result should not be discarded")]]
+    constexpr Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
+    {
+        return mat_rotation_axis_z<double, MatStoreType::ROW_MAJOR>(angles.yaw)
+               * mat_rotation_axis_y<double, MatStoreType::ROW_MAJOR>(-angles.pitch)
+               * mat_rotation_axis_x<double, MatStoreType::ROW_MAJOR>(-angles.roll);
+    }
+
+    [[nodiscard("origin result should not be discarded")]]
+    constexpr Vector3<double> extract_origin(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_origin(mat);
+    }
+
+    [[nodiscard("scale result should not be discarded")]]
+    constexpr Vector3<double> extract_scale(const Mat4X4& mat) noexcept
+    {
+        return mat_extract_scale(mat);
+    }
+
+    [[nodiscard("rotation angles result should not be discarded")]]
+    constexpr ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
+    {
+        const auto angles = mat_extract_rotation_zyx(mat);
+        return {
+                PitchAngle::from_degrees(-angles.y),
+                YawAngle::from_degrees(angles.z),
+                RollAngle::from_degrees(-angles.x),
+        };
+    }
+
+    [[nodiscard("perspective projection matrix result should not be discarded")]]
+    constexpr Mat4X4 calc_perspective_projection_matrix(
+            const double field_of_view, const double aspect_ratio, const double near_plane, const double far_plane,
+            const NDCDepthRange ndc_depth_range = NDCDepthRange::NEGATIVE_ONE_TO_ONE) noexcept
+    {
+        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
+            return mat_perspective_left_handed_horizontal_fov<double, MatStoreType::ROW_MAJOR,
+                                                              NDCDepthRange::ZERO_TO_ONE>(field_of_view, aspect_ratio,
+                                                                                          near_plane, far_plane);
+        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
+            return mat_perspective_left_handed_horizontal_fov<double, MatStoreType::ROW_MAJOR,
+                                                              NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
+                    field_of_view, aspect_ratio, near_plane, far_plane);
+        std::unreachable();
+    }
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("centimeters value should not be discarded")]]
     constexpr FloatingType units_to_centimeters(const FloatingType& units)
     {
         return units;
@@ -44,7 +98,7 @@ namespace omath::unreal_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("meters value should not be discarded")]]
     constexpr FloatingType units_to_meters(const FloatingType& units)
     {
         return units / static_cast<FloatingType>(100);
@@ -52,7 +106,7 @@ namespace omath::unreal_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("kilometers value should not be discarded")]]
     constexpr FloatingType units_to_kilometers(const FloatingType& units)
     {
         return units_to_meters(units) / static_cast<FloatingType>(1000);
@@ -60,7 +114,7 @@ namespace omath::unreal_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType centimeters_to_units(const FloatingType& centimeters)
     {
         return centimeters;
@@ -68,7 +122,7 @@ namespace omath::unreal_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType meters_to_units(const FloatingType& meters)
     {
         return meters * static_cast<FloatingType>(100);
@@ -76,7 +130,7 @@ namespace omath::unreal_engine
 
     template<class FloatingType>
     requires std::is_floating_point_v<FloatingType>
-    [[nodiscard]]
+    [[nodiscard("units value should not be discarded")]]
     constexpr FloatingType kilometers_to_units(const FloatingType& kilometers)
     {
         return meters_to_units(kilometers * static_cast<FloatingType>(1000));

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

@@ -11,14 +11,30 @@ namespace omath::unreal_engine
     class CameraTrait final
     {
     public:
-        [[nodiscard]]
-        static ViewAngles calc_look_at_angle(const Vector3<double>& cam_origin, const Vector3<double>& look_at) noexcept;
+        [[nodiscard("look-at angle result should not be discarded")]]
+        constexpr static ViewAngles calc_look_at_angle(const Vector3<double>& cam_origin,
+                                                       const Vector3<double>& look_at) noexcept
+        {
+            const auto direction = (look_at - cam_origin).normalized();
 
-        [[nodiscard]]
-        static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept;
-        [[nodiscard]]
-        static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov, const projection::ViewPort& view_port,
-                                             double near, double far, NDCDepthRange ndc_depth_range) noexcept;
+            return {PitchAngle::from_asin(direction.z), YawAngle::from_atan2(direction.y, direction.x),
+                    RollAngle::from_radians(0.f)};
+        }
+
+        [[nodiscard("view matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept
+        {
+            return unreal_engine::calc_view_matrix(angles, cam_origin);
+        }
+        [[nodiscard("projection matrix result should not be discarded")]]
+        constexpr static Mat4X4 calc_projection_matrix(const projection::FieldOfView& fov,
+                                                       const projection::ViewPort& view_port, const double near_plane,
+                                                       const double far_plane,
+                                                       const NDCDepthRange ndc_depth_range) noexcept
+        {
+            return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near_plane, far_plane,
+                                                      ndc_depth_range);
+        }
     };
 
 } // namespace omath::unreal_engine

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

@@ -10,7 +10,7 @@ namespace omath::unreal_engine
     class MeshTrait final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("rotation matrix result should not be discarded")]]
         static Mat4X4 rotation_matrix(const ViewAngles& rotation)
         {
             return unreal_engine::rotation_matrix(rotation);

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

@@ -12,6 +12,7 @@ namespace omath::unreal_engine
     class PredEngineTrait final
     {
     public:
+        [[nodiscard("projectile position result should not be discarded")]]
         static Vector3<double> predict_projectile_position(const projectile_prediction::Projectile<double>& projectile,
                                                            const double pitch, const double yaw,
                                                            const double time, const double gravity) noexcept
@@ -27,7 +28,7 @@ namespace omath::unreal_engine
             return current_pos;
         }
 
-        [[nodiscard]]
+        [[nodiscard("target position result should not be discarded")]]
         static Vector3<double> predict_target_position(const projectile_prediction::Target<double>& target,
                                                        const double time, const double gravity) noexcept
         {
@@ -39,19 +40,19 @@ namespace omath::unreal_engine
             return predicted;
         }
 
-        [[nodiscard]]
+        [[nodiscard("2d distance result should not be discarded")]]
         static double calc_vector_2d_distance(const Vector3<double>& delta) noexcept
         {
             return std::sqrt(delta.x * delta.x + delta.z * delta.z);
         }
 
-        [[nodiscard]]
+        [[nodiscard("height coordinate result should not be discarded")]]
         static double get_vector_height_coordinate(const Vector3<double>& vec) noexcept
         {
             return vec.y;
         }
 
-        [[nodiscard]]
+        [[nodiscard("viewpoint result should not be discarded")]]
         static Vector3<double> calc_viewpoint_from_angles(const projectile_prediction::Projectile<double>& projectile,
                                                           Vector3<double> predicted_target_position,
                                                           const std::optional<double> projectile_pitch) noexcept
@@ -64,7 +65,7 @@ namespace omath::unreal_engine
 
         // Due to specification of maybe_calculate_projectile_launch_pitch_angle, pitch angle must be:
         // 89 look up, -89 look down
-        [[nodiscard]]
+        [[nodiscard("pitch angle result should not be discarded")]]
         static double calc_direct_pitch_angle(const Vector3<double>& origin, const Vector3<double>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();
@@ -72,7 +73,7 @@ namespace omath::unreal_engine
             return angles::radians_to_degrees(std::asin(direction.z));
         }
 
-        [[nodiscard]]
+        [[nodiscard("yaw angle result should not be discarded")]]
         static double calc_direct_yaw_angle(const Vector3<double>& origin, const Vector3<double>& view_to) noexcept
         {
             const auto direction = (view_to - origin).normalized();

include/omath/hashing.hpp

@@ -0,0 +1,130 @@
+#pragma once
+
+#include <cstdint>
+#include <expected>
+#include <string>
+#include <string_view>
+
+namespace omath::hashing
+{
+    enum class Base64Error
+    {
+        INVALID_LENGTH,
+        INVALID_CHARACTER,
+        INVALID_PADDING
+    };
+
+    [[nodiscard("FNV-1a hash result should not be discarded")]]
+    constexpr std::uint64_t fnv1a(const std::string_view value) noexcept
+    {
+        std::uint64_t hash = 14695981039346656037ULL;
+
+        for (const char character : value)
+        {
+            hash ^= static_cast<std::uint8_t>(character);
+            hash *= 1099511628211ULL;
+        }
+
+        return hash;
+    }
+
+    [[nodiscard("CRC-32 checksum result should not be discarded")]]
+    constexpr std::uint32_t crc32(const std::string_view value) noexcept
+    {
+        std::uint32_t crc = 0xFFFFFFFFU;
+
+        for (const char character : value)
+        {
+            crc ^= static_cast<std::uint8_t>(character);
+
+            for (int bit = 0; bit < 8; bit++)
+            {
+                crc = crc & 1U ? (crc >> 1U) ^ 0xEDB88320U : crc >> 1U;
+            }
+        }
+
+        return crc ^ 0xFFFFFFFFU;
+    }
+
+    [[nodiscard("Base64 encoding result should not be discarded")]]
+    constexpr std::string base64_encode(const std::string_view value)
+    {
+        constexpr std::string_view alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+        std::string result;
+        result.reserve((value.size() + 2) / 3 * 4);
+
+        for (std::size_t index = 0; index < value.size(); index += 3)
+        {
+            const std::uint32_t first = static_cast<std::uint8_t>(value[index]);
+            const std::uint32_t second = index + 1 < value.size() ? static_cast<std::uint8_t>(value[index + 1]) : 0;
+            const std::uint32_t third = index + 2 < value.size() ? static_cast<std::uint8_t>(value[index + 2]) : 0;
+            const std::uint32_t chunk = first << 16U | second << 8U | third;
+
+            result += alphabet[(chunk >> 18U) & 0x3FU];
+            result += alphabet[(chunk >> 12U) & 0x3FU];
+            result += index + 1 < value.size() ? alphabet[(chunk >> 6U) & 0x3FU] : '=';
+            result += index + 2 < value.size() ? alphabet[chunk & 0x3FU] : '=';
+        }
+
+        return result;
+    }
+
+    [[nodiscard("Base64 decoding result should not be discarded")]]
+    constexpr std::expected<std::string, Base64Error> base64_decode(const std::string_view value)
+    {
+        if (value.size() % 4 != 0)
+            return std::unexpected(Base64Error::INVALID_LENGTH);
+
+        std::string result;
+        result.reserve(value.size() / 4 * 3);
+
+        for (std::size_t index = 0; index < value.size(); index += 4)
+        {
+            const auto decode_character = [](const char character) constexpr -> int
+            {
+                if (character >= 'A' && character <= 'Z')
+                    return character - 'A';
+                if (character >= 'a' && character <= 'z')
+                    return character - 'a' + 26;
+                if (character >= '0' && character <= '9')
+                    return character - '0' + 52;
+                if (character == '+')
+                    return 62;
+                if (character == '/')
+                    return 63;
+
+                return -1;
+            };
+
+            const bool is_last_chunk = index + 4 == value.size();
+            const int first = decode_character(value[index]);
+            const int second = decode_character(value[index + 1]);
+            const int third = value[index + 2] == '=' ? -2 : decode_character(value[index + 2]);
+            const int fourth = value[index + 3] == '=' ? -2 : decode_character(value[index + 3]);
+
+            if (first < 0 || second < 0 || third == -1 || fourth == -1)
+                return std::unexpected(Base64Error::INVALID_CHARACTER);
+            if (third == -2)
+            {
+                if (fourth != -2 || !is_last_chunk || (second & 0x0F) != 0)
+                    return std::unexpected(Base64Error::INVALID_PADDING);
+            }
+            else if (fourth == -2 && (!is_last_chunk || (third & 0x03) != 0))
+                return std::unexpected(Base64Error::INVALID_PADDING);
+
+            const std::uint32_t chunk = static_cast<std::uint32_t>(first) << 18U
+                                        | static_cast<std::uint32_t>(second) << 12U
+                                        | static_cast<std::uint32_t>(third < 0 ? 0 : third) << 6U
+                                        | static_cast<std::uint32_t>(fourth < 0 ? 0 : fourth);
+
+            result += static_cast<char>(chunk >> 16U);
+            if (third >= 0)
+                result += static_cast<char>(chunk >> 8U);
+            if (fourth >= 0)
+                result += static_cast<char>(chunk);
+        }
+
+        return result;
+    }
+} // namespace omath::hashing

include/omath/hud/canvas_box.hpp

@@ -9,9 +9,10 @@ namespace omath::hud
     class CanvasBox final
     {
     public:
+        CanvasBox() = default;
         CanvasBox(Vector2<float> top, Vector2<float> bottom, float ratio = 4.f);
 
-        [[nodiscard]]
+        [[nodiscard("You have to use array")]]
         std::array<Vector2<float>, 4> as_array() const;
 
         Vector2<float> top_left_corner;

include/omath/hud/entity_overlay.hpp

@@ -5,13 +5,21 @@
 #include "canvas_box.hpp"
 #include "entity_overlay_widgets.hpp"
 #include "hud_renderer_interface.hpp"
+#include "omath/3d_primitives/aabb.hpp"
 #include "omath/linear_algebra/vector2.hpp"
 #include "omath/utility/color.hpp"
+#include <expected>
 #include <memory>
 #include <string_view>
-
+#include <type_traits>
 namespace omath::hud
 {
+    enum class EntityOverlayError
+    {
+        NO_PROJECTED_VERTEX,
+        CENTER_PROJECTION_FAILED,
+    };
+
     class EntityOverlay final
     {
     public:
@@ -22,6 +30,9 @@ namespace omath::hud
         EntityOverlay& add_2d_box(const Color& box_color, const Color& fill_color = Color{0.f, 0.f, 0.f, 0.f},
                                   const Color& outline_color = Color{0.f, 0.f, 0.f, 0.f}, float thickness = 1.f);
 
+        EntityOverlay& add_2d_box(const Color& box_color, const Gradient& fill_gradient,
+                                  const Color& outline_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},
                                            const Color& outline_color = Color{0.f, 0.f, 0.f, 0.f},
                                            float corner_ratio_len = 0.2f, float thickness = 1.f);
@@ -30,17 +41,21 @@ namespace omath::hud
                                       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_right_bar(const widget::BarPaint& color, const Color& outline_color, const Color& bg_color,
+                                     float width, float ratio, float offset = 5.f,
+                                     const std::optional<widget::Glow>& glow = std::nullopt);
 
-        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_left_bar(const widget::BarPaint& color, const Color& outline_color, const Color& bg_color,
+                                    float width, float ratio, float offset = 5.f,
+                                    const std::optional<widget::Glow>& glow = std::nullopt);
 
-        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_top_bar(const widget::BarPaint& color, const Color& outline_color, const Color& bg_color,
+                                   float height, float ratio, float offset = 5.f,
+                                   const std::optional<widget::Glow>& glow = std::nullopt);
 
-        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_bottom_bar(const widget::BarPaint& color, const Color& outline_color, const Color& bg_color,
+                                      float height, float ratio, float offset = 5.f,
+                                      const std::optional<widget::Glow>& glow = std::nullopt);
 
         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,
@@ -57,46 +72,58 @@ namespace omath::hud
                                              float offset = 5.f);
 
         // ── Labels ───────────────────────────────────────────────────────
-        EntityOverlay& add_right_label(const Color& color, float offset, widget::Outlined outlined, const std::string_view& text);
+        EntityOverlay& add_right_label(const widget::Paint& color, float offset, widget::Outlined outlined,
+                                       const std::string_view& text,
+                                       const std::optional<widget::Glow>& glow = std::nullopt);
 
-        EntityOverlay& add_left_label(const Color& color, float offset, widget::Outlined outlined, const std::string_view& text);
+        EntityOverlay& add_left_label(const widget::Paint& color, float offset, widget::Outlined outlined,
+                                      const std::string_view& text,
+                                      const std::optional<widget::Glow>& glow = std::nullopt);
 
-        EntityOverlay& add_top_label(const Color& color, float offset, widget::Outlined outlined, std::string_view text);
+        EntityOverlay& add_top_label(const widget::Paint& color, float offset, widget::Outlined outlined,
+                                     std::string_view text, const std::optional<widget::Glow>& glow = std::nullopt);
 
-        EntityOverlay& add_bottom_label(const Color& color, float offset, widget::Outlined outlined, std::string_view text);
+        EntityOverlay& add_bottom_label(const widget::Paint& color, float offset, widget::Outlined outlined,
+                                        std::string_view text, const std::optional<widget::Glow>& glow = std::nullopt);
 
-        EntityOverlay& add_centered_top_label(const Color& color, float offset, widget::Outlined outlined,
-                                              const std::string_view& text);
+        EntityOverlay& add_centered_top_label(const widget::Paint& color, float offset, widget::Outlined outlined,
+                                              const std::string_view& text,
+                                              const std::optional<widget::Glow>& glow = std::nullopt);
 
-        EntityOverlay& add_centered_bottom_label(const Color& color, float offset, widget::Outlined outlined,
-                                                 const std::string_view& text);
+        EntityOverlay& add_centered_bottom_label(const widget::Paint& color, float offset, widget::Outlined outlined,
+                                                 const std::string_view& text,
+                                                 const std::optional<widget::Glow>& glow = std::nullopt);
 
         template<typename... Args>
-        EntityOverlay& add_right_label(const Color& color, const float offset, const widget::Outlined outlined, std::format_string<Args...> fmt,
-                                       Args&&... args)
+        requires(sizeof...(Args) > 0)
+        EntityOverlay& add_right_label(const widget::Paint& color, const float offset, const widget::Outlined 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 widget::Outlined outlined, std::format_string<Args...> fmt,
-                                      Args&&... args)
+        requires(sizeof...(Args) > 0)
+        EntityOverlay& add_left_label(const widget::Paint& color, const float offset, const widget::Outlined 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 widget::Outlined outlined, std::format_string<Args...> fmt,
-                                     Args&&... args)
+        requires(sizeof...(Args) > 0)
+        EntityOverlay& add_top_label(const widget::Paint& color, const float offset, const widget::Outlined 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 widget::Outlined outlined,
+        requires(sizeof...(Args) > 0)
+        EntityOverlay& add_bottom_label(const widget::Paint& color, const float offset, const widget::Outlined outlined,
                                         std::format_string<Args...> fmt, Args&&... args)
         {
             return add_bottom_label(color, offset, outlined,
@@ -104,16 +131,20 @@ namespace omath::hud
         }
 
         template<typename... Args>
-        EntityOverlay& add_centered_top_label(const Color& color, const float offset, const widget::Outlined outlined,
-                                              std::format_string<Args...> fmt, Args&&... args)
+        requires(sizeof...(Args) > 0)
+        EntityOverlay& add_centered_top_label(const widget::Paint& color, const float offset,
+                                              const widget::Outlined 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 widget::Outlined outlined,
-                                                 std::format_string<Args...> fmt, Args&&... args)
+        requires(sizeof...(Args) > 0)
+        EntityOverlay& add_centered_bottom_label(const widget::Paint& color, const float offset,
+                                                 const widget::Outlined 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...))});
@@ -153,6 +184,7 @@ namespace omath::hud
         EntityOverlay& add_snap_line(const Vector2<float>& start_pos, const Color& color, float width);
 
         EntityOverlay& add_skeleton(const Color& color, float thickness = 1.f);
+        EntityOverlay& add_skeleton(std::span<const widget::Bone> bones, const Color& color, float thickness = 1.f);
 
         // ── Declarative interface ─────────────────────────────────────────
         /// Pass any combination of widget:: descriptor structs (and std::optional<W>
@@ -164,6 +196,49 @@ namespace omath::hud
             return *this;
         }
 
+        template<class Camera, class Aabb>
+        [[nodiscard]]
+        static std::expected<EntityOverlay, EntityOverlayError>
+        from_aabb(const Camera& camera, const Aabb& aabb, const float aspect,
+                  const std::shared_ptr<HudRendererInterface>& renderer)
+        {
+            using ProjectedVector = std::invoke_result_t<decltype(&Aabb::center), const Aabb&>;
+
+            ProjectedVector top;
+            ProjectedVector bottom;
+            bool has_projected_vertex = false;
+
+            for (const auto& vertex : aabb.vertices())
+            {
+                if (auto projected = camera.world_to_screen_unclipped(vertex))
+                {
+                    if (!has_projected_vertex)
+                    {
+                        top = *projected;
+                        bottom = *projected;
+                        has_projected_vertex = true;
+                        continue;
+                    }
+
+                    if (projected->y < top.y)
+                        top = *projected;
+                    if (projected->y > bottom.y)
+                        bottom = *projected;
+                }
+            }
+
+            if (!has_projected_vertex)
+                return std::unexpected(EntityOverlayError::NO_PROJECTED_VERTEX);
+
+            auto center = camera.world_to_screen_unclipped(aabb.center());
+            if (!center)
+                return std::unexpected(EntityOverlayError::CENTER_PROJECTION_FAILED);
+
+            const auto center_x = static_cast<float>(center->x);
+            return EntityOverlay{
+                    {center_x, static_cast<float>(top.y)}, {center_x, static_cast<float>(bottom.y)}, aspect, renderer};
+        }
+
     private:
         // optional<W> dispatch — enables when() conditional widgets
         template<typename W>
@@ -174,6 +249,7 @@ namespace omath::hud
         }
 
         void dispatch(const widget::Box& box);
+        void dispatch(const widget::CanvasGlow& canvas_glow);
         void dispatch(const widget::CorneredBox& cornered_box);
         void dispatch(const widget::DashedBox& dashed_box);
         void dispatch(const widget::RightSide& right_side);
@@ -186,7 +262,19 @@ namespace omath::hud
         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_label(const Vector2<float>& position, const widget::Paint& paint, widget::Outlined outlined,
+                        const std::string_view& text, const std::optional<widget::Glow>& glow);
+        void draw_glow_polyline(const std::span<const Vector2<float>>& points, const widget::Glow& glow,
+                                float thickness) const;
+        void draw_glow_line(const Vector2<float>& from, const Vector2<float>& to, const widget::Glow& glow,
+                            float thickness) const;
+        void draw_glow_rectangle(const Vector2<float>& min, const Vector2<float>& max,
+                                 const std::optional<widget::Glow>& glow) const;
+        void draw_canvas_glow(const widget::CanvasGlow& canvas_glow) const;
+        void draw_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max,
+                                   const widget::Paint& paint) const;
+        [[nodiscard]]
+        static widget::Paint resolve_bar_paint(const widget::BarPaint& paint, float ratio, bool vertical);
         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,

include/omath/hud/entity_overlay_widgets.hpp

@@ -2,16 +2,57 @@
 // Created by orange on 15.03.2026.
 //
 #pragma once
+#include "gradient.hpp"
 #include "omath/linear_algebra/vector2.hpp"
 #include "omath/utility/color.hpp"
 #include <any>
+#include <array>
 #include <initializer_list>
 #include <optional>
+#include <span>
 #include <string_view>
+#include <type_traits>
 #include <variant>
+#include <vector>
 
 namespace omath::hud::widget
 {
+    struct Paint : std::variant<Color, Gradient>
+    {
+        using std::variant<Color, Gradient>::variant;
+
+        constexpr Paint(const float red, const float green, const float blue, const float alpha)
+            : std::variant<Color, Gradient>(Color{red, green, blue, alpha})
+        {
+        }
+    };
+
+    struct BarGradient
+    {
+        Color empty_color;
+        Color full_color;
+    };
+
+    struct BarPaint : std::variant<Color, Gradient, BarGradient>
+    {
+        using std::variant<Color, Gradient, BarGradient>::variant;
+
+        constexpr BarPaint(const float red, const float green, const float blue, const float alpha)
+            : std::variant<Color, Gradient, BarGradient>(Color{red, green, blue, alpha})
+        {
+        }
+
+        BarPaint(const Paint& paint)
+        {
+            std::visit(
+                    [this](const auto& value)
+                    {
+                        this->template emplace<std::decay_t<decltype(value)>>(value);
+                    },
+                    paint);
+        }
+    };
+
     // ── Overloaded helper for std::visit ──────────────────────────────────────
     template<typename... Ts>
     struct Overloaded : Ts...
@@ -21,13 +62,28 @@ namespace omath::hud::widget
     template<typename... Ts>
     Overloaded(Ts...) -> Overloaded<Ts...>;
 
+    struct Glow
+    {
+        Color color;
+        float radius = 4.f;
+        float intensity = 1.f;
+    };
+
+    struct CanvasGlow
+    {
+        Glow glow;
+        int layers = 64;
+        float rounding = 20.f;
+    };
+
     // ── Standalone widgets ────────────────────────────────────────────────────
     struct Box
     {
         Color color;
-        Color fill{0.f, 0.f, 0.f, 0.f};
+        Paint fill{Color{0.f, 0.f, 0.f, 0.f}};
         Color outline{0.f, 0.f, 0.f, 0.f};
         float thickness = 1.f;
+        std::optional<Glow> glow = std::nullopt;
     };
 
     enum class Outlined
@@ -42,6 +98,7 @@ namespace omath::hud::widget
         Color outline{0.f, 0.f, 0.f, 0.f};
         float corner_ratio = 0.2f;
         float thickness = 1.f;
+        std::optional<Glow> glow = std::nullopt;
     };
 
     struct DashedBox
@@ -52,10 +109,37 @@ namespace omath::hud::widget
         float thickness = 1.f;
     };
 
+    struct Bone
+    {
+        Vector2<float> start;
+        Vector2<float> end;
+    };
+
     struct Skeleton
     {
+        std::vector<Bone> bones;
         Color color;
         float thickness = 1.f;
+
+        Skeleton(const Color& color, const float thickness = 1.f): color(color), thickness(thickness)
+        {
+        }
+
+        Skeleton(const std::span<const Bone> bones, const Color& color, const float thickness = 1.f)
+            : bones(bones.begin(), bones.end()), color(color), thickness(thickness)
+        {
+        }
+
+        Skeleton(const std::initializer_list<Bone> bones, const Color& color, const float thickness = 1.f)
+            : bones(bones), color(color), thickness(thickness)
+        {
+        }
+
+        template<std::size_t Size>
+        Skeleton(const std::array<Bone, Size>& bones, const Color& color, const float thickness = 1.f)
+            : Skeleton(std::span<const Bone>{bones}, color, thickness)
+        {
+        }
     };
     struct SnapLine
     {
@@ -92,18 +176,18 @@ namespace omath::hud::widget
         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;
+        BarPaint color;
         Color outline;
         Color bg;
         float size;
         float ratio;
         float offset = 5.f;
+        std::optional<Glow> glow = std::nullopt;
     };
 
     /// A dashed bar. Same field semantics as Bar plus dash parameters.
@@ -121,10 +205,11 @@ namespace omath::hud::widget
 
     struct Label
     {
-        Color color;
+        Paint color;
         float offset;
         Outlined outlined;
         std::string_view text;
+        std::optional<Glow> glow = std::nullopt;
     };
 
     /// Wraps a Label to request horizontal centering (only applied in TopSide / BottomSide).
@@ -172,8 +257,8 @@ namespace omath::hud::widget
     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>;
+    using SideWidget = std::variant<None, Bar, DashedBar, Label, Centered<Label>, SpaceVertical, SpaceHorizontal,
+                                    ProgressRing, Icon>;
 
     // ── Side containers ───────────────────────────────────────────────────────
     // Storing std::initializer_list<SideWidget> is safe here: the backing array

include/omath/hud/gradient.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include "omath/utility/color.hpp"
+
+namespace omath::hud
+{
+    enum class GradientDirection
+    {
+        RightToLeft,
+        LeftToRight,
+    };
+
+    struct Gradient final
+    {
+        Color top_left;
+        Color top_right;
+        Color bottom_right;
+        Color bottom_left;
+        bool animated = false;
+        float animation_speed = 4.f;
+        float animation_spread = 0.7f;
+        GradientDirection direction = GradientDirection::RightToLeft;
+    };
+} // namespace omath::hud

include/omath/hud/hud_renderer_interface.hpp

@@ -2,6 +2,7 @@
 // Created by orange on 13.03.2026.
 //
 #pragma once
+#include "gradient.hpp"
 #include "omath/linear_algebra/vector2.hpp"
 #include "omath/utility/color.hpp"
 #include <any>
@@ -19,12 +20,24 @@ namespace omath::hud
         virtual void add_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color,
                                   float thickness) = 0;
 
+        virtual void add_polyline_clipped(const std::span<const Vector2<float>>& vertexes, const Vector2<float>&,
+                                          const Vector2<float>&, const Color& color, float thickness)
+        {
+            add_polyline(vertexes, color, thickness);
+        }
+
         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_gradient_rectangle(const Vector2<float>& min, const Vector2<float>& max,
+                                            const Gradient& gradient)
+        {
+            add_filled_rectangle(min, max, gradient.top_left);
+        }
+
         virtual void add_circle(const Vector2<float>& center, float radius, const Color& color, float thickness,
                                 int segments = 0) = 0;
 
@@ -41,6 +54,12 @@ namespace omath::hud
 
         virtual void add_text(const Vector2<float>& position, const Color& color, const std::string_view& text) = 0;
 
+        virtual void add_gradient_text(const Vector2<float>& position, const Gradient& gradient,
+                                       const std::string_view& text)
+        {
+            add_text(position, gradient.top_left, text);
+        }
+
         [[nodiscard]]
         virtual Vector2<float> calc_text_size(const std::string_view& text) = 0;
     };

include/omath/hud/renderer_realizations/imgui_renderer.hpp

@@ -13,10 +13,15 @@ namespace omath::hud
         ~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_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color,
+                          float thickness) override;
+        void add_polyline_clipped(const std::span<const Vector2<float>>& vertexes, const Vector2<float>& clip_min,
+                                  const Vector2<float>& clip_max, 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_gradient_rectangle(const Vector2<float>& min, const Vector2<float>& max,
+                                    const Gradient& gradient) 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,
@@ -26,6 +31,8 @@ namespace omath::hud
         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;
+        void add_gradient_text(const Vector2<float>& position, const Gradient& gradient,
+                               const std::string_view& text) override;
         [[nodiscard]]
         Vector2<float> calc_text_size(const std::string_view& text) override;
     };

include/omath/internal/constexpr_math.hpp

@@ -0,0 +1,707 @@
+//
+// Created by orange on 6/11/2026.
+//
+#pragma once
+
+#include <bit>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <numbers>
+#include <type_traits>
+
+namespace omath::internal
+{
+    // Embedded subset of GCE-Math 1.18.0.
+    //
+    // Original project:
+    //   GCE-Math: A C++ generalized constant expression-based math library
+    //   Copyright 2016-2024 Keith O'Hara
+    //   Licensed under the Apache License, Version 2.0.
+    namespace math_detail
+    {
+        using uint_t = unsigned int;
+        using llint_t = long long int;
+        using ullint_t = unsigned long long int;
+
+        template<class Type>
+        using limits = std::numeric_limits<Type>;
+
+        template<class Type>
+        constexpr Type pi = std::numbers::pi_v<Type>;
+
+        template<class Type>
+        constexpr Type half_pi = std::numbers::pi_v<Type> / static_cast<Type>(2);
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type abs(const Type value) noexcept
+        {
+            return value == Type{0} ? Type{0} : value < Type{0} ? -value : value;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr int sgn(const Type value) noexcept
+        {
+            return value > Type{0} ? 1 : value < Type{0} ? -1 : 0;
+        }
+
+        [[nodiscard]]
+        constexpr bool is_odd(const llint_t value) noexcept
+        {
+            return (value & 1U) != 0;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool is_nan(const Type value) noexcept
+        {
+            return value != value;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool is_neginf(const Type value) noexcept
+        {
+            return value == -limits<Type>::infinity();
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool is_posinf(const Type value) noexcept
+        {
+            return value == limits<Type>::infinity();
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool is_inf(const Type value) noexcept
+        {
+            return is_neginf(value) || is_posinf(value);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool is_finite(const Type value) noexcept
+        {
+            return !is_nan(value) && !is_inf(value);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool any_nan(const Type x, const Type y) noexcept
+        {
+            return is_nan(x) || is_nan(y);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool any_inf(const Type x, const Type y) noexcept
+        {
+            return is_inf(x) || is_inf(y);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool all_finite(const Type x, const Type y) noexcept
+        {
+            return is_finite(x) && is_finite(y);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool signbit(const Type value) noexcept
+        {
+            if constexpr (std::is_same_v<Type, float>)
+                return (std::bit_cast<std::uint32_t>(value) & 0x80000000U) != 0;
+            else if constexpr (std::is_same_v<Type, double>)
+                return (std::bit_cast<std::uint64_t>(value) & 0x8000000000000000ULL) != 0;
+            else
+                return value < Type{0};
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr bool neg_zero(const Type value) noexcept
+        {
+            return value == Type{0} && signbit(value);
+        }
+
+        template<class Type, class ExpType>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type pow_integral_compute(const Type base, const ExpType exp_term) noexcept;
+
+        template<class Type, class ExpType>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type pow_integral_compute_recur(const Type base, const Type value, const ExpType exp_term) noexcept
+        {
+            return exp_term > ExpType{1}
+                           ? is_odd(static_cast<llint_t>(exp_term))
+                                     ? pow_integral_compute_recur(base * base, value * base, exp_term / ExpType{2})
+                                     : pow_integral_compute_recur(base * base, value, exp_term / ExpType{2})
+                   : exp_term == ExpType{1} ? value * base
+                                            : value;
+        }
+
+        template<class Type, class ExpType>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type pow_integral_sgn_check(const Type base, const ExpType exp_term) noexcept
+        {
+            if constexpr (std::is_signed_v<ExpType>)
+                return exp_term < ExpType{0} ? Type{1} / pow_integral_compute(base, -exp_term)
+                                             : pow_integral_compute_recur(base, Type{1}, exp_term);
+            else
+                return pow_integral_compute_recur(base, Type{1}, exp_term);
+        }
+
+        template<class Type, class ExpType>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type pow_integral_compute(const Type base, const ExpType exp_term) noexcept
+        {
+            return exp_term == ExpType{3}               ? base * base * base
+                   : exp_term == ExpType{2}             ? base * base
+                   : exp_term == ExpType{1}             ? base
+                   : exp_term == ExpType{0}             ? Type{1}
+                   : exp_term == limits<ExpType>::min() ? Type{0}
+                   : exp_term == limits<ExpType>::max() ? limits<Type>::infinity()
+                                                        : pow_integral_sgn_check(base, exp_term);
+        }
+
+        template<class Type, class ExpType>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type pow_integral(const Type base, const ExpType exp_term) noexcept
+        {
+            return pow_integral_compute(base, exp_term);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type sqrt_recur(const Type x, const Type xn, const int count) noexcept
+        {
+            return abs(xn - x / xn) / (Type{1} + xn) < limits<Type>::min() ? xn
+                   : count < 100 ? sqrt_recur(x, Type{0.5} * (xn + x / xn), count + 1)
+                                 : xn;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type sqrt_simplify(const Type x, const Type m_val) noexcept
+        {
+            return x > Type{1e+08}   ? sqrt_simplify(x / Type{1e+08}, Type{1e+04} * m_val)
+                   : x > Type{1e+06} ? sqrt_simplify(x / Type{1e+06}, Type{1e+03} * m_val)
+                   : x > Type{1e+04} ? sqrt_simplify(x / Type{1e+04}, Type{1e+02} * m_val)
+                   : x > Type{100}   ? sqrt_simplify(x / Type{100}, Type{10} * m_val)
+                   : x > Type{4}     ? sqrt_simplify(x / Type{4}, Type{2} * m_val)
+                                     : m_val * sqrt_recur(x, x / Type{2}, 0);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type sqrt(const Type x) noexcept
+        {
+            return is_nan(x)                                ? limits<Type>::quiet_NaN()
+                   : x < Type{0}                            ? limits<Type>::quiet_NaN()
+                   : is_posinf(x)                           ? x
+                   : limits<Type>::min() > abs(x)           ? Type{0}
+                   : limits<Type>::min() > abs(Type{1} - x) ? x
+                                                            : sqrt_simplify(x, Type{1});
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type floor_int(const Type x, const Type x_whole) noexcept
+        {
+            return x_whole - static_cast<Type>((x < Type{0}) && (x < x_whole));
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type floor_check_internal(const Type x) noexcept
+        {
+            if constexpr (std::is_same_v<Type, float>)
+                return abs(x) >= 8388608.f ? x : floor_int(x, static_cast<float>(static_cast<int>(x)));
+            else if constexpr (std::is_same_v<Type, double>)
+                return abs(x) >= 4503599627370496. ? x : floor_int(x, static_cast<double>(static_cast<llint_t>(x)));
+            else
+                return abs(x) >= 9223372036854775808.l
+                               ? x
+                               : static_cast<long double>(static_cast<ullint_t>(abs(x))) * sgn(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type floor(const Type x) noexcept
+        {
+            return is_nan(x)                      ? limits<Type>::quiet_NaN()
+                   : !is_finite(x)                ? x
+                   : limits<Type>::min() > abs(x) ? x
+                                                  : floor_check_internal(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type trunc_int(const Type x) noexcept
+        {
+            return static_cast<Type>(static_cast<llint_t>(x));
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type trunc_check_internal(const Type x) noexcept
+        {
+            if constexpr (std::is_same_v<Type, float>)
+                return abs(x) >= 8388608.f ? x : trunc_int(x);
+            else if constexpr (std::is_same_v<Type, double>)
+                return abs(x) >= 4503599627370496. ? x : trunc_int(x);
+            else
+                return abs(x) >= 9223372036854775808.l
+                               ? x
+                               : static_cast<long double>(static_cast<ullint_t>(abs(x))) * sgn(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type trunc(const Type x) noexcept
+        {
+            return is_nan(x)                      ? limits<Type>::quiet_NaN()
+                   : !is_finite(x)                ? x
+                   : limits<Type>::min() > abs(x) ? x
+                                                  : trunc_check_internal(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type fmod(const Type x, const Type y) noexcept
+        {
+            return any_nan(x, y) || !all_finite(x, y) || limits<Type>::min() > abs(y) ? limits<Type>::quiet_NaN()
+                                                                                      : x - trunc(x / y) * y;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type tan_series_exp_long(const Type z) noexcept
+        {
+            return -Type{1} / z
+                   + (z / Type{3}
+                      + (pow_integral(z, 3) / Type{45}
+                         + (Type{2} * pow_integral(z, 5) / Type{945} + pow_integral(z, 7) / Type{4725})));
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type tan_series_exp(const Type x) noexcept
+        {
+            return limits<Type>::min() > abs(x - half_pi<Type>) ? Type{1.633124e+16}
+                                                                : tan_series_exp_long(x - half_pi<Type>);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type tan_cf_recur(const Type xx, const int max_depth) noexcept
+        {
+            Type result = static_cast<Type>(2 * max_depth - 1);
+            for (int depth = max_depth - 1; depth >= 1; --depth)
+                result = static_cast<Type>(2 * depth - 1) - xx / result;
+
+            return result;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type tan_cf_main(const Type x) noexcept
+        {
+            return x > Type{1.55} && x < Type{1.60} ? tan_series_exp(x)
+                   : x > Type{1.4}                  ? x / tan_cf_recur(x * x, 45)
+                   : x > Type{1}                    ? x / tan_cf_recur(x * x, 35)
+                                                    : x / tan_cf_recur(x * x, 25);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type tan_begin(const Type x, const int count = 0) noexcept
+        {
+            return x > pi<Type> ? count > 1 ? limits<Type>::quiet_NaN()
+                                            : tan_begin(x - pi<Type> * floor(x / pi<Type>), count + 1)
+                                : tan_cf_main(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type tan(const Type x) noexcept
+        {
+            return is_nan(x)                      ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x) ? Type{0}
+                   : x < Type{0}                  ? -tan_begin(-x)
+                                                  : tan_begin(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type sin(const Type x) noexcept
+        {
+            return is_nan(x)                                      ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x)                 ? Type{0}
+                   : limits<Type>::min() > abs(x - half_pi<Type>) ? Type{1}
+                   : limits<Type>::min() > abs(x + half_pi<Type>) ? -Type{1}
+                   : limits<Type>::min() > abs(x - pi<Type>)      ? Type{0}
+                   : limits<Type>::min() > abs(x + pi<Type>)
+                           ? -Type{0}
+                           : (Type{2} * tan(x / Type{2})) / (Type{1} + tan(x / Type{2}) * tan(x / Type{2}));
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type cos(const Type x) noexcept
+        {
+            return is_nan(x)                                      ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x)                 ? Type{1}
+                   : limits<Type>::min() > abs(x - half_pi<Type>) ? Type{0}
+                   : limits<Type>::min() > abs(x + half_pi<Type>) ? Type{0}
+                   : limits<Type>::min() > abs(x - pi<Type>)      ? -Type{1}
+                   : limits<Type>::min() > abs(x + pi<Type>)
+                           ? -Type{1}
+                           : (Type{1} - tan(x / Type{2}) * tan(x / Type{2}))
+                                     / (Type{1} + tan(x / Type{2}) * tan(x / Type{2}));
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan_series_order_calc(const Type xx, const Type x_pow, const uint_t order) noexcept
+        {
+            return Type{1} / (static_cast<Type>((order - 1) * 4 - 1) * x_pow)
+                   - Type{1} / (static_cast<Type>((order - 1) * 4 + 1) * x_pow * xx);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan_series_order(const Type x, const uint_t order_begin, const uint_t max_order) noexcept
+        {
+            if (max_order == 1)
+                return half_pi<Type> - Type{1} / x;
+
+            const Type xx = x * x;
+            Type result = atan_series_order_calc(xx, pow_integral(x, 4 * max_order - 5), max_order);
+            auto depth = max_order - 1;
+
+            while (depth > order_begin)
+            {
+                result += atan_series_order_calc(xx, pow_integral(x, 4 * depth - 5), depth);
+                --depth;
+            }
+
+            return result + half_pi<Type> - Type{1} / x;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan_series_main(const Type x) noexcept
+        {
+            return x < Type{3}      ? atan_series_order(x, 1U, 10U)
+                   : x < Type{4}    ? atan_series_order(x, 1U, 9U)
+                   : x < Type{5}    ? atan_series_order(x, 1U, 8U)
+                   : x < Type{7}    ? atan_series_order(x, 1U, 7U)
+                   : x < Type{11}   ? atan_series_order(x, 1U, 6U)
+                   : x < Type{25}   ? atan_series_order(x, 1U, 5U)
+                   : x < Type{100}  ? atan_series_order(x, 1U, 4U)
+                   : x < Type{1000} ? atan_series_order(x, 1U, 3U)
+                                    : atan_series_order(x, 1U, 2U);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan_cf_recur(const Type xx, const uint_t depth_begin, const uint_t max_depth) noexcept
+        {
+            auto depth = max_depth - 1;
+            Type result = static_cast<Type>(2 * (depth + 1) - 1);
+
+            while (depth > depth_begin - 1)
+            {
+                result = static_cast<Type>(2 * depth - 1) + static_cast<Type>(depth * depth) * xx / result;
+                --depth;
+            }
+
+            return result;
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan_cf_main(const Type x) noexcept
+        {
+            return x < Type{0.5}   ? x / atan_cf_recur(x * x, 1U, 15U)
+                   : x < Type{1}   ? x / atan_cf_recur(x * x, 1U, 25U)
+                   : x < Type{1.5} ? x / atan_cf_recur(x * x, 1U, 35U)
+                   : x < Type{2}   ? x / atan_cf_recur(x * x, 1U, 45U)
+                                   : x / atan_cf_recur(x * x, 1U, 52U);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan_begin(const Type x) noexcept
+        {
+            return x > Type{2.5} ? atan_series_main(x) : atan_cf_main(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan(const Type x) noexcept
+        {
+            return is_nan(x)                      ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x) ? Type{0}
+                   : x < Type{0}                  ? -atan_begin(-x)
+                                                  : atan_begin(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type atan2(const Type y, const Type x) noexcept
+        {
+            return any_nan(y, x)                  ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x) ? limits<Type>::min() > abs(y)
+                                                            ? neg_zero(y)   ? neg_zero(x) ? -pi<Type> : -Type{0}
+                                                                : neg_zero(x) ? pi<Type>
+                                                                            : Type{0}
+                                                    : y > Type{0} ? half_pi<Type>
+                                                                  : -half_pi<Type>
+                   : x < Type{0} ? y < Type{0} ? atan(y / x) - pi<Type> : atan(y / x) + pi<Type>
+                                 : atan(y / x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type asin_compute(const Type x) noexcept
+        {
+            return x > Type{1}                              ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x - Type{1}) ? half_pi<Type>
+                   : limits<Type>::min() > abs(x)           ? Type{0}
+                                                            : atan(x / sqrt(Type{1} - x * x));
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type asin(const Type x) noexcept
+        {
+            return is_nan(x) ? limits<Type>::quiet_NaN() : x < Type{0} ? -asin_compute(-x) : asin_compute(x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type acos_compute(const Type x) noexcept
+        {
+            return abs(x) > Type{1}                         ? limits<Type>::quiet_NaN()
+                   : limits<Type>::min() > abs(x - Type{1}) ? Type{0}
+                   : limits<Type>::min() > abs(x)           ? half_pi<Type>
+                                                            : atan(sqrt(Type{1} - x * x) / x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type acos(const Type x) noexcept
+        {
+            return is_nan(x) ? limits<Type>::quiet_NaN() : x > Type{0} ? acos_compute(x) : pi<Type> - acos_compute(-x);
+        }
+
+        template<class Type>
+        requires std::is_floating_point_v<Type>
+        [[nodiscard]]
+        constexpr Type hypot(const Type x, const Type y) noexcept
+        {
+            return any_nan(x, y)                  ? limits<Type>::quiet_NaN()
+                   : any_inf(x, y)                ? limits<Type>::infinity()
+                   : limits<Type>::min() > abs(x) ? abs(y)
+                   : limits<Type>::min() > abs(y) ? abs(x)
+                                                  : abs(x) * sqrt(Type{1} + (y / x) * (y / x));
+        }
+    } // namespace math_detail
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type sin(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::sin(value);
+        }
+        return std::sin(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type cos(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::cos(value);
+        }
+        return std::cos(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type tan(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::tan(value);
+        }
+        return std::tan(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type atan(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::atan(value);
+        }
+        return std::atan(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type atan2(const Type& y, const Type& x) noexcept
+    {
+        if consteval
+        {
+            return math_detail::atan2(y, x);
+        }
+        return std::atan2(y, x);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type asin(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::asin(value);
+        }
+        return std::asin(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type acos(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::acos(value);
+        }
+        return std::acos(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type sqrt(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::sqrt(value);
+        }
+        return std::sqrt(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type hypot(const Type& x, const Type& y) noexcept
+    {
+        if consteval
+        {
+            return math_detail::hypot(x, y);
+        }
+        return std::hypot(x, y);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type hypot(const Type& x, const Type& y, const Type& z) noexcept
+    {
+        if consteval
+        {
+            return math_detail::sqrt(x * x + y * y + z * z);
+        }
+        return std::hypot(x, y, z);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type abs(const Type& value) noexcept
+    {
+        if consteval
+        {
+            return math_detail::abs(value);
+        }
+        return std::abs(value);
+    }
+
+    template<class Type>
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]]
+    constexpr Type fmod(const Type& dividend, const Type& divisor) noexcept
+    {
+        if consteval
+        {
+            return math_detail::fmod(dividend, divisor);
+        }
+        return std::fmod(dividend, divisor);
+    }
+} // namespace omath::internal

include/omath/linear_algebra/mat.hpp

@@ -2,6 +2,7 @@
 // Created by vlad on 9/29/2024.
 //
 #pragma once
+#include "omath/internal/constexpr_math.hpp"
 #include "vector3.hpp"
 #include <algorithm>
 #include <array>
@@ -10,6 +11,7 @@
 #include <numeric>
 #include <sstream>
 #include <stdexcept>
+#include <type_traits>
 #include <utility>
 
 #ifdef OMATH_USE_AVX2
@@ -44,8 +46,8 @@ namespace omath
         ZERO_TO_ONE // DirectX / Vulkan: [0.0, 1.0]
     };
 
-    template<typename M1, typename M2> concept MatTemplateEqual
-            = (M1::rows == M2::rows) && (M1::columns == M2::columns)
+    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);
 
     template<size_t Rows = 0, size_t Columns = 0, class Type = float, MatStoreType StoreType = MatStoreType::ROW_MAJOR>
@@ -149,7 +151,8 @@ namespace omath
             }
         }
 
-        [[nodiscard("You must use element reference")]] constexpr Type& at(const size_t row_index, const size_t column_index)
+        [[nodiscard("You must use element reference")]] constexpr Type& at(const size_t row_index,
+                                                                           const size_t column_index)
         {
             return const_cast<Type&>(std::as_const(*this).at(row_index, column_index));
         }
@@ -176,7 +179,21 @@ namespace omath
         operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
         {
 #ifdef OMATH_USE_AVX2
+            if (std::is_constant_evaluated())
+            {
                 if constexpr (StoreType == MatStoreType::ROW_MAJOR)
+                    return cache_friendly_multiply_row_major(other);
+                else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
+                    return cache_friendly_multiply_col_major(other);
+            }
+            if constexpr (!std::is_same_v<Type, float> && !std::is_same_v<Type, double>)
+            {
+                if constexpr (StoreType == MatStoreType::ROW_MAJOR)
+                    return cache_friendly_multiply_row_major(other);
+                else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
+                    return cache_friendly_multiply_col_major(other);
+            }
+            else if constexpr (StoreType == MatStoreType::ROW_MAJOR)
                 return avx_multiply_row_major(other);
             else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
                 return avx_multiply_col_major(other);
@@ -192,7 +209,11 @@ namespace omath
 
         constexpr Mat& operator*=(const Type& f) noexcept
         {
-            std::ranges::for_each(m_data, [&f](auto& val) { val *= f; });
+            std::ranges::for_each(m_data,
+                                  [&f](auto& val)
+                                  {
+                                      val *= f;
+                                  });
             return *this;
         }
 
@@ -212,7 +233,11 @@ namespace omath
 
         constexpr Mat& operator/=(const Type& value) noexcept
         {
-            std::ranges::for_each(m_data, [&value](auto& val) { val /= value; });
+            std::ranges::for_each(m_data,
+                                  [&value](auto& val)
+                                  {
+                                      val /= value;
+                                  });
             return *this;
         }
 
@@ -388,7 +413,7 @@ namespace omath
         {
             const auto det = determinant();
 
-            if (std::abs(det) < std::numeric_limits<Type>::epsilon())
+            if (internal::abs(det) < std::numeric_limits<Type>::epsilon())
                 return std::nullopt;
 
             const auto transposed_mat = transposed();
@@ -411,12 +436,21 @@ namespace omath
         cache_friendly_multiply_row_major(const Mat<Columns, OtherColumns, Type, MatStoreType::ROW_MAJOR>& other) const
         {
             Mat<Rows, OtherColumns, Type, MatStoreType::ROW_MAJOR> result;
+            const Type* left_data = m_data.data();
+            const Type* right_data = other.raw_array().data();
+            Type* result_data = result.raw_array().data();
+
             for (std::size_t row_index = 0; row_index < Rows; ++row_index)
+            {
+                const Type* left_row = left_data + row_index * Columns;
+                Type* result_row = result_data + row_index * OtherColumns;
                 for (std::size_t column_index = 0; column_index < Columns; ++column_index)
                 {
-                    const Type& current_number = at(row_index, column_index);
+                    const Type current_number = left_row[column_index];
+                    const Type* right_row = right_data + column_index * OtherColumns;
                     for (std::size_t other_column = 0; other_column < OtherColumns; ++other_column)
-                        result.at(row_index, other_column) += current_number * other.at(column_index, other_column);
+                        result_row[other_column] += current_number * right_row[other_column];
+                }
             }
             return result;
         }
@@ -426,12 +460,21 @@ namespace omath
                 const Mat<Columns, OtherColumns, Type, MatStoreType::COLUMN_MAJOR>& other) const
         {
             Mat<Rows, OtherColumns, Type, MatStoreType::COLUMN_MAJOR> result;
+            const Type* left_data = m_data.data();
+            const Type* right_data = other.raw_array().data();
+            Type* result_data = result.raw_array().data();
+
             for (std::size_t other_column = 0; other_column < OtherColumns; ++other_column)
+            {
+                const Type* right_column = right_data + other_column * Columns;
+                Type* result_column = result_data + other_column * Rows;
                 for (std::size_t column_index = 0; column_index < Columns; ++column_index)
                 {
-                    const Type& current_number = other.at(column_index, other_column);
+                    const Type current_number = right_column[column_index];
+                    const Type* left_column = left_data + column_index * Rows;
                     for (std::size_t row_index = 0; row_index < Rows; ++row_index)
-                        result.at(row_index, other_column) += at(row_index, column_index) * current_number;
+                        result_column[row_index] += left_column[row_index] * current_number;
+                }
             }
             return result;
         }
@@ -448,56 +491,92 @@ namespace omath
 
             if constexpr (std::is_same_v<Type, float>)
             {
-                // ReSharper disable once CppTooWideScopeInitStatement
                 constexpr std::size_t vector_size = 8;
+                constexpr std::size_t block_size = vector_size * 4;
                 for (std::size_t j = 0; j < OtherColumns; ++j)
                 {
                     auto* c_col = reinterpret_cast<float*>(result_mat_data + j * Rows);
+                    std::size_t i = 0;
+                    for (; i + block_size <= Rows; i += block_size)
+                    {
+                        __m256 cvec0 = _mm256_setzero_ps();
+                        __m256 cvec1 = _mm256_setzero_ps();
+                        __m256 cvec2 = _mm256_setzero_ps();
+                        __m256 cvec3 = _mm256_setzero_ps();
                         for (std::size_t k = 0; k < Columns; ++k)
                         {
-                        const float bkj = reinterpret_cast<const float*>(other_mat_data)[k + j * Columns];
-                        const __m256 bkj_vec = _mm256_set1_ps(bkj);
-
-                        const auto* a_col_k = reinterpret_cast<const float*>(this_mat_data + k * Rows);
-
-                        std::size_t i = 0;
+                            const __m256 bkj_vec = _mm256_set1_ps(other_mat_data[k + j * Columns]);
+                            const auto* a_col_k = this_mat_data + k * Rows + i;
+                            cvec0 = _mm256_fmadd_ps(_mm256_loadu_ps(a_col_k), bkj_vec, cvec0);
+                            cvec1 = _mm256_fmadd_ps(_mm256_loadu_ps(a_col_k + vector_size), bkj_vec, cvec1);
+                            cvec2 = _mm256_fmadd_ps(_mm256_loadu_ps(a_col_k + vector_size * 2), bkj_vec, cvec2);
+                            cvec3 = _mm256_fmadd_ps(_mm256_loadu_ps(a_col_k + vector_size * 3), bkj_vec, cvec3);
+                        }
+                        _mm256_storeu_ps(c_col + i, cvec0);
+                        _mm256_storeu_ps(c_col + i + vector_size, cvec1);
+                        _mm256_storeu_ps(c_col + i + vector_size * 2, cvec2);
+                        _mm256_storeu_ps(c_col + i + vector_size * 3, cvec3);
+                    }
                     for (; i + vector_size <= Rows; i += vector_size)
                     {
-                            __m256 cvec = _mm256_loadu_ps(c_col + i);
+                        __m256 cvec = _mm256_setzero_ps();
+                        for (std::size_t k = 0; k < Columns; ++k)
+                        {
+                            const __m256 bkj_vec = _mm256_set1_ps(other_mat_data[k + j * Columns]);
+                            const auto* a_col_k = this_mat_data + k * Rows;
                             const __m256 a_vec = _mm256_loadu_ps(a_col_k + i);
                             cvec = _mm256_fmadd_ps(a_vec, bkj_vec, cvec);
+                        }
                         _mm256_storeu_ps(c_col + i, cvec);
                     }
                     for (; i < Rows; ++i)
-                            c_col[i] += a_col_k[i] * bkj;
-                    }
+                        for (std::size_t k = 0; k < Columns; ++k)
+                            c_col[i] += this_mat_data[i + k * Rows] * other_mat_data[k + j * Columns];
                 }
             }
             else if (std::is_same_v<Type, double>)
-            { // double
-                // ReSharper disable once CppTooWideScopeInitStatement
+            {
                 constexpr std::size_t vector_size = 4;
+                constexpr std::size_t block_size = vector_size * 4;
                 for (std::size_t j = 0; j < OtherColumns; ++j)
                 {
                     auto* c_col = reinterpret_cast<double*>(result_mat_data + j * Rows);
+                    std::size_t i = 0;
+                    for (; i + block_size <= Rows; i += block_size)
+                    {
+                        __m256d cvec0 = _mm256_setzero_pd();
+                        __m256d cvec1 = _mm256_setzero_pd();
+                        __m256d cvec2 = _mm256_setzero_pd();
+                        __m256d cvec3 = _mm256_setzero_pd();
                         for (std::size_t k = 0; k < Columns; ++k)
                         {
-                        const double bkj = reinterpret_cast<const double*>(other_mat_data)[k + j * Columns];
-                        const __m256d bkj_vec = _mm256_set1_pd(bkj);
-
-                        const auto* a_col_k = reinterpret_cast<const double*>(this_mat_data + k * Rows);
-
-                        std::size_t i = 0;
+                            const __m256d bkj_vec = _mm256_set1_pd(other_mat_data[k + j * Columns]);
+                            const auto* a_col_k = this_mat_data + k * Rows + i;
+                            cvec0 = _mm256_fmadd_pd(_mm256_loadu_pd(a_col_k), bkj_vec, cvec0);
+                            cvec1 = _mm256_fmadd_pd(_mm256_loadu_pd(a_col_k + vector_size), bkj_vec, cvec1);
+                            cvec2 = _mm256_fmadd_pd(_mm256_loadu_pd(a_col_k + vector_size * 2), bkj_vec, cvec2);
+                            cvec3 = _mm256_fmadd_pd(_mm256_loadu_pd(a_col_k + vector_size * 3), bkj_vec, cvec3);
+                        }
+                        _mm256_storeu_pd(c_col + i, cvec0);
+                        _mm256_storeu_pd(c_col + i + vector_size, cvec1);
+                        _mm256_storeu_pd(c_col + i + vector_size * 2, cvec2);
+                        _mm256_storeu_pd(c_col + i + vector_size * 3, cvec3);
+                    }
                     for (; i + vector_size <= Rows; i += vector_size)
                     {
-                            __m256d cvec = _mm256_loadu_pd(c_col + i);
+                        __m256d cvec = _mm256_setzero_pd();
+                        for (std::size_t k = 0; k < Columns; ++k)
+                        {
+                            const __m256d bkj_vec = _mm256_set1_pd(other_mat_data[k + j * Columns]);
+                            const auto* a_col_k = this_mat_data + k * Rows;
                             const __m256d a_vec = _mm256_loadu_pd(a_col_k + i);
                             cvec = _mm256_fmadd_pd(a_vec, bkj_vec, cvec);
+                        }
                         _mm256_storeu_pd(c_col + i, cvec);
                     }
                     for (; i < Rows; ++i)
-                            c_col[i] += a_col_k[i] * bkj;
-                    }
+                        for (std::size_t k = 0; k < Columns; ++k)
+                            c_col[i] += this_mat_data[i + k * Rows] * other_mat_data[k + j * Columns];
                 }
             }
             else
@@ -518,56 +597,92 @@ namespace omath
 
             if constexpr (std::is_same_v<Type, float>)
             {
-                // ReSharper disable once CppTooWideScopeInitStatement
                 constexpr std::size_t vector_size = 8;
+                constexpr std::size_t block_size = vector_size * 4;
                 for (std::size_t i = 0; i < Rows; ++i)
                 {
-                    Type* c_row = result_mat_data + i * OtherColumns;
+                    auto* c_row = reinterpret_cast<float*>(result_mat_data + i * OtherColumns);
+                    std::size_t j = 0;
+                    for (; j + block_size <= OtherColumns; j += block_size)
+                    {
+                        __m256 cvec0 = _mm256_setzero_ps();
+                        __m256 cvec1 = _mm256_setzero_ps();
+                        __m256 cvec2 = _mm256_setzero_ps();
+                        __m256 cvec3 = _mm256_setzero_ps();
                         for (std::size_t k = 0; k < Columns; ++k)
                         {
-                        const auto aik = static_cast<float>(this_mat_data[i * Columns + k]);
-                        const __m256 aik_vec = _mm256_set1_ps(aik);
-                        const auto* b_row = reinterpret_cast<const float*>(other_mat_data + k * OtherColumns);
-
-                        std::size_t j = 0;
+                            const __m256 aik_vec = _mm256_set1_ps(this_mat_data[i * Columns + k]);
+                            const auto* b_row = other_mat_data + k * OtherColumns + j;
+                            cvec0 = _mm256_fmadd_ps(_mm256_loadu_ps(b_row), aik_vec, cvec0);
+                            cvec1 = _mm256_fmadd_ps(_mm256_loadu_ps(b_row + vector_size), aik_vec, cvec1);
+                            cvec2 = _mm256_fmadd_ps(_mm256_loadu_ps(b_row + vector_size * 2), aik_vec, cvec2);
+                            cvec3 = _mm256_fmadd_ps(_mm256_loadu_ps(b_row + vector_size * 3), aik_vec, cvec3);
+                        }
+                        _mm256_storeu_ps(c_row + j, cvec0);
+                        _mm256_storeu_ps(c_row + j + vector_size, cvec1);
+                        _mm256_storeu_ps(c_row + j + vector_size * 2, cvec2);
+                        _mm256_storeu_ps(c_row + j + vector_size * 3, cvec3);
+                    }
                     for (; j + vector_size <= OtherColumns; j += vector_size)
                     {
-                            __m256 cvec = _mm256_loadu_ps(c_row + j);
+                        __m256 cvec = _mm256_setzero_ps();
+                        for (std::size_t k = 0; k < Columns; ++k)
+                        {
+                            const __m256 aik_vec = _mm256_set1_ps(this_mat_data[i * Columns + k]);
+                            const auto* b_row = other_mat_data + k * OtherColumns;
                             const __m256 b_vec = _mm256_loadu_ps(b_row + j);
                             cvec = _mm256_fmadd_ps(b_vec, aik_vec, cvec);
-
+                        }
                         _mm256_storeu_ps(c_row + j, cvec);
                     }
                     for (; j < OtherColumns; ++j)
-                            c_row[j] += aik * b_row[j];
-                    }
+                        for (std::size_t k = 0; k < Columns; ++k)
+                            c_row[j] += this_mat_data[i * Columns + k] * other_mat_data[k * OtherColumns + j];
                 }
             }
             else if (std::is_same_v<Type, double>)
-            { // double
-                // ReSharper disable once CppTooWideScopeInitStatement
+            {
                 constexpr std::size_t vector_size = 4;
+                constexpr std::size_t block_size = vector_size * 4;
                 for (std::size_t i = 0; i < Rows; ++i)
                 {
-                    Type* c_row = result_mat_data + i * OtherColumns;
+                    auto* c_row = reinterpret_cast<double*>(result_mat_data + i * OtherColumns);
+                    std::size_t j = 0;
+                    for (; j + block_size <= OtherColumns; j += block_size)
+                    {
+                        __m256d cvec0 = _mm256_setzero_pd();
+                        __m256d cvec1 = _mm256_setzero_pd();
+                        __m256d cvec2 = _mm256_setzero_pd();
+                        __m256d cvec3 = _mm256_setzero_pd();
                         for (std::size_t k = 0; k < Columns; ++k)
                         {
-                        const auto aik = static_cast<double>(this_mat_data[i * Columns + k]);
-                        const __m256d aik_vec = _mm256_set1_pd(aik);
-                        const auto* b_row = reinterpret_cast<const double*>(other_mat_data + k * OtherColumns);
-
-                        std::size_t j = 0;
+                            const __m256d aik_vec = _mm256_set1_pd(this_mat_data[i * Columns + k]);
+                            const auto* b_row = other_mat_data + k * OtherColumns + j;
+                            cvec0 = _mm256_fmadd_pd(_mm256_loadu_pd(b_row), aik_vec, cvec0);
+                            cvec1 = _mm256_fmadd_pd(_mm256_loadu_pd(b_row + vector_size), aik_vec, cvec1);
+                            cvec2 = _mm256_fmadd_pd(_mm256_loadu_pd(b_row + vector_size * 2), aik_vec, cvec2);
+                            cvec3 = _mm256_fmadd_pd(_mm256_loadu_pd(b_row + vector_size * 3), aik_vec, cvec3);
+                        }
+                        _mm256_storeu_pd(c_row + j, cvec0);
+                        _mm256_storeu_pd(c_row + j + vector_size, cvec1);
+                        _mm256_storeu_pd(c_row + j + vector_size * 2, cvec2);
+                        _mm256_storeu_pd(c_row + j + vector_size * 3, cvec3);
+                    }
                     for (; j + vector_size <= OtherColumns; j += vector_size)
                     {
-                            __m256d cvec = _mm256_loadu_pd(c_row + j);
+                        __m256d cvec = _mm256_setzero_pd();
+                        for (std::size_t k = 0; k < Columns; ++k)
+                        {
+                            const __m256d aik_vec = _mm256_set1_pd(this_mat_data[i * Columns + k]);
+                            const auto* b_row = other_mat_data + k * OtherColumns;
                             const __m256d b_vec = _mm256_loadu_pd(b_row + j);
                             cvec = _mm256_fmadd_pd(b_vec, aik_vec, cvec);
-
+                        }
                         _mm256_storeu_pd(c_row + j, cvec);
                     }
                     for (; j < OtherColumns; ++j)
-                            c_row[j] += aik * b_row[j];
-                    }
+                        for (std::size_t k = 0; k < Columns; ++k)
+                            c_row[j] += this_mat_data[i * Columns + k] * other_mat_data[k * OtherColumns + j];
                 }
             }
             else
@@ -578,13 +693,13 @@ namespace omath
     };
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard("You must use row matrix")]]
-    constexpr static Mat<1, 4, Type, St> mat_row_from_vector(const Vector3<Type>& vector) noexcept
+    constexpr Mat<1, 4, Type, St> mat_row_from_vector(const Vector3<Type>& vector) noexcept
     {
         return {{vector.x, vector.y, vector.z, 1}};
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard("You must use column matrix")]]
-    constexpr static Mat<4, 1, Type, St> mat_column_from_vector(const Vector3<Type>& vector) noexcept
+    constexpr Mat<4, 1, Type, St> mat_column_from_vector(const Vector3<Type>& vector) noexcept
     {
         return {{vector.x}, {vector.y}, {vector.z}, {1}};
     }
@@ -593,8 +708,7 @@ namespace omath
     [[nodiscard("You must use translation matrix")]]
     constexpr Mat<4, 4, Type, St> mat_translation(const Vector3<Type>& diff) noexcept
     {
-        return
-        {
+        return {
                 {1, 0, 0, diff.x},
                 {0, 1, 0, diff.y},
                 {0, 0, 1, diff.z},
@@ -622,10 +736,11 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard("You must use extracted scale")]]
-    Vector3<Type> mat_extract_scale(const Mat<4, 4, Type, St>& mat) noexcept
+    constexpr Vector3<Type> mat_extract_scale(const Mat<4, 4, Type, St>& mat) noexcept
     {
-        auto column_length = [](const Type x, const Type y, const Type z) {
-            return static_cast<Type>(std::sqrt(x * x + y * y + z * z));
+        auto column_length = [](const Type x, const Type y, const Type z)
+        {
+            return static_cast<Type>(internal::sqrt(x * x + y * y + z * z));
         };
 
         const auto scale_x = column_length(mat.at(0, 0), mat.at(1, 0), mat.at(2, 0));
@@ -635,16 +750,16 @@ namespace omath
         constexpr auto epsilon = std::numeric_limits<Type>::epsilon();
 
         return {
-                std::abs(scale_x) < epsilon ? Type{1} : scale_x,
-                std::abs(scale_y) < epsilon ? Type{1} : scale_y,
-                std::abs(scale_z) < epsilon ? Type{1} : scale_z,
+                internal::abs(scale_x) < epsilon ? Type{1} : scale_x,
+                internal::abs(scale_y) < epsilon ? Type{1} : scale_y,
+                internal::abs(scale_z) < epsilon ? Type{1} : scale_z,
         };
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     requires std::is_floating_point_v<Type>
     [[nodiscard("You must use extracted rotation")]]
-    Vector3<Type> mat_extract_rotation_zyx(const Mat<4, 4, Type, St>& mat) noexcept
+    constexpr Vector3<Type> mat_extract_rotation_zyx(const Mat<4, 4, Type, St>& mat) noexcept
     {
         const auto scale = mat_extract_scale(mat);
         const auto m00 = mat.at(0, 0) / scale.x;
@@ -654,73 +769,59 @@ namespace omath
         const auto m22 = mat.at(2, 2) / scale.z;
 
         return {
-                angles::radians_to_degrees(std::atan2(m21, m22)),
-                angles::radians_to_degrees(std::asin(std::clamp(-m20, Type{-1}, Type{1}))),
-                angles::radians_to_degrees(std::atan2(m10, m00)),
+                angles::radians_to_degrees(internal::atan2(m21, m22)),
+                angles::radians_to_degrees(internal::asin(std::clamp(-m20, Type{-1}, Type{1}))),
+                angles::radians_to_degrees(internal::atan2(m10, m00)),
         };
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
     [[nodiscard("You must use rotation matrix")]]
-    Mat<4, 4, Type, St> mat_rotation_axis_x(const Angle& angle) noexcept
+    constexpr Mat<4, 4, Type, St> mat_rotation_axis_x(const Angle& angle) noexcept
     {
-        return
-        {
-            {1, 0,           0,            0},
-            {0, angle.cos(), -angle.sin(), 0},
-            {0, angle.sin(), angle.cos(),  0},
-            {0, 0,           0,            1}
-        };
+        return {{1, 0, 0, 0}, {0, angle.cos(), -angle.sin(), 0}, {0, angle.sin(), angle.cos(), 0}, {0, 0, 0, 1}};
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
     [[nodiscard("You must use rotation matrix")]]
-    Mat<4, 4, Type, St> mat_rotation_axis_y(const Angle& angle) noexcept
+    constexpr Mat<4, 4, Type, St> mat_rotation_axis_y(const Angle& angle) noexcept
     {
-        return
-        {
-            {angle.cos(),  0, angle.sin(), 0},
-            {0           , 1,           0, 0},
-            {-angle.sin(), 0, angle.cos(), 0},
-            {0           , 0,           0, 1}
-        };
+        return {{angle.cos(), 0, angle.sin(), 0}, {0, 1, 0, 0}, {-angle.sin(), 0, angle.cos(), 0}, {0, 0, 0, 1}};
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
     [[nodiscard("You must use rotation matrix")]]
-    Mat<4, 4, Type, St> mat_rotation_axis_z(const Angle& angle) noexcept
-    {
-        return
+    constexpr Mat<4, 4, Type, St> mat_rotation_axis_z(const Angle& angle) noexcept
     {
+        return {
                 {angle.cos(), -angle.sin(), 0, 0},
                 {angle.sin(), angle.cos(), 0, 0},
-            {          0,        0,     1, 0},
-            {          0,        0,     0, 1},
+                {0, 0, 1, 0},
+                {0, 0, 0, 1},
         };
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard("You must use camera view matrix")]]
-    static Mat<4, 4, Type, St> mat_camera_view(const Vector3<Type>& forward, const Vector3<Type>& right,
+    constexpr Mat<4, 4, Type, St> mat_camera_view(const Vector3<Type>& forward, const Vector3<Type>& right,
                                                   const Vector3<Type>& up, const Vector3<Type>& camera_origin) noexcept
     {
-        return  Mat<4, 4, Type, St>
-        {
+        return Mat<4, 4, Type, St>{
                        {right.x, right.y, right.z, 0},
                        {up.x, up.y, up.z, 0},
                        {forward.x, forward.y, forward.z, 0},
                        {0, 0, 0, 1},
-        } * mat_translation<Type, St>(-camera_origin);
+               }
+               * mat_translation<Type, St>(-camera_origin);
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard("You must use perspective matrix")]]
-    Mat<4, 4, Type, St> mat_perspective_left_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio,
-                                                    const Type near, const Type far) noexcept
+    [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St>
+    mat_perspective_left_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, const Type near,
+                                             const Type far) noexcept
     {
-        const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2});
-
+        const auto fov_half_tan = internal::tan(angles::degrees_to_radians(field_of_view) / Type{2});
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
             return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}},
                     {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}},
@@ -737,11 +838,11 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard("You must use perspective matrix")]]
-    Mat<4, 4, Type, St> mat_perspective_right_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio,
-                                                     const Type near, const Type far) noexcept
+    [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St>
+    mat_perspective_right_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, const Type near,
+                                              const Type far) noexcept
     {
-        const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2});
+        const auto fov_half_tan = internal::tan(angles::degrees_to_radians(field_of_view) / Type{2});
 
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
             return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}},
@@ -762,12 +863,11 @@ namespace omath
     // X and Y scales derived as: X = 1 / tan(hfov/2), Y = aspect / tan(hfov/2).
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard("You must use perspective matrix")]]
-    Mat<4, 4, Type, St> mat_perspective_left_handed_horizontal_fov(const Type horizontal_fov,
-                                                                   const Type aspect_ratio, const Type near,
+    [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St>
+    mat_perspective_left_handed_horizontal_fov(const Type horizontal_fov, const Type aspect_ratio, const Type near,
                                                const Type far) noexcept
     {
-        const auto inv_tan_half_hfov = Type{1} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
+        const auto inv_tan_half_hfov = Type{1} / internal::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
         const auto x_axis = inv_tan_half_hfov;
         const auto y_axis = inv_tan_half_hfov * aspect_ratio;
 
@@ -787,12 +887,12 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard("You must use perspective matrix")]]
-    Mat<4, 4, Type, St> mat_perspective_right_handed_horizontal_fov(const Type horizontal_fov,
-                                                                    const Type aspect_ratio, const Type near,
+    [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St>
+    mat_perspective_right_handed_horizontal_fov(const Type horizontal_fov, const Type aspect_ratio, const Type near,
                                                 const Type far) noexcept
     {
-        const auto inv_tan_half_hfov = Type{1} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
+        const auto inv_tan_half_hfov = Type{1} / internal::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
+
         const auto x_axis = inv_tan_half_hfov;
         const auto y_axis = inv_tan_half_hfov * aspect_ratio;
 
@@ -811,56 +911,45 @@ namespace omath
     }
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard("You must use ortho matrix")]]
-    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
+    [[nodiscard("You must use ortho matrix")]] constexpr Mat<4, 4, Type, St>
+    mat_ortho_left_handed(const Type left, const Type right, const Type bottom, const Type top, const Type near,
+                          const Type far) noexcept
     {
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return
-            {
-                { static_cast<Type>(2) / (right - left), 0.f,       0.f,    -(right + left) / (right - left)},
-                { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,    -(top + bottom) / (top - bottom)},
-                { 0.f,      0.f,       static_cast<Type>(1) / (far - near), -near / (far - near)            },
-                { 0.f,      0.f,       0.f,                                 1.f                             }
-            };
+            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                             }
-            };
+            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,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard("You must use ortho matrix")]]
-    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
+    [[nodiscard("You must use ortho matrix")]] constexpr Mat<4, 4, Type, St>
+    mat_ortho_right_handed(const Type left, const Type right, const Type bottom, const Type top, const Type near,
+                           const Type far) noexcept
     {
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return
-            {
-                    { static_cast<Type>(2) / (right - left), 0.f,       0.f,     -(right + left) / (right - left)},
-                    { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,     -(top + bottom) / (top - bottom)},
-                    { 0.f,      0.f,       -static_cast<Type>(1) / (far - near), -near / (far - near)            },
-                    { 0.f,      0.f,       0.f,                                  1.f                             }
-            };
+            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                             }
-            };
+            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)
+    constexpr Mat<4, 4, T, St> mat_look_at_left_handed(const Vector3<T>& eye, const Vector3<T>& center,
+                                                       const Vector3<T>& up)
     {
         const Vector3<T> f = (center - eye).normalized();
         const Vector3<T> s = f.cross(up).normalized();
@@ -869,7 +958,8 @@ namespace omath
     }
 
     template<class T = float, MatStoreType St = MatStoreType::COLUMN_MAJOR>
-    Mat<4, 4, T, St>mat_look_at_right_handed(const Vector3<T>& eye, const Vector3<T>& center, const Vector3<T>& up)
+    constexpr Mat<4, 4, T, St> mat_look_at_right_handed(const Vector3<T>& eye, const Vector3<T>& center,
+                                                        const Vector3<T>& up)
     {
         const Vector3<T> f = (center - eye).normalized();
         const Vector3<T> s = f.cross(up).normalized();
@@ -880,7 +970,7 @@ namespace omath
 } // namespace omath
 
 template<size_t Rows, size_t Columns, class Type, omath::MatStoreType StoreType>
-struct std::formatter<omath::Mat<Rows, Columns, Type, StoreType>> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Mat<Rows, Columns, Type, StoreType>> final // NOLINT(*-dcl58-cpp)
 {
     using MatType = omath::Mat<Rows, Columns, Type, StoreType>;
     [[nodiscard("You must use parse iterator")]]

include/omath/linear_algebra/triangle.hpp

@@ -2,8 +2,8 @@
 // Created by Orange on 11/13/2024.
 //
 #pragma once
+#include "omath/internal/constexpr_math.hpp"
 #include "vector3.hpp"
-
 namespace omath
 {
     /*
@@ -40,13 +40,13 @@ namespace omath
         }
 
         [[nodiscard]]
-        Vector::ContainedType side_a_length() const
+        constexpr Vector::ContainedType side_a_length() const
         {
             return m_vertex1.distance_to(m_vertex2);
         }
 
         [[nodiscard]]
-        Vector::ContainedType side_b_length() const
+        constexpr Vector::ContainedType side_b_length() const
         {
             return m_vertex3.distance_to(m_vertex2);
         }
@@ -69,7 +69,7 @@ namespace omath
             const auto side_b = side_b_length();
             const auto hypot_value = hypot();
 
-            return std::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f;
+            return internal::abs(side_a * side_a + side_b * side_b - hypot_value * hypot_value) <= 0.0001f;
         }
         [[nodiscard]]
         constexpr Vector side_b_vector() const

include/omath/linear_algebra/vector2.hpp

@@ -3,6 +3,7 @@
 //
 
 #pragma once
+#include "omath/internal/constexpr_math.hpp"
 #include <cmath>
 #include <format>
 #include <tuple>
@@ -116,9 +117,9 @@ namespace omath
 
         // Basic vector operations
         [[nodiscard("You must use distance")]]
-        Type distance_to(const Vector2& other) const noexcept
+        constexpr Type distance_to(const Vector2& other) const noexcept
         {
-            return std::sqrt(distance_to_sqr(other));
+            return internal::sqrt(distance_to_sqr(other));
         }
 
         [[nodiscard("You must use squared distance")]]
@@ -136,7 +137,7 @@ namespace omath
 #ifndef _MSC_VER
         [[nodiscard("You must use length")]] constexpr Type length() const noexcept
         {
-            return std::hypot(this->x, this->y);
+            return internal::hypot(this->x, this->y);
         }
 
         [[nodiscard("You must use normalized vector")]] constexpr Vector2 normalized() const noexcept
@@ -146,13 +147,13 @@ namespace omath
         }
 #else
         [[nodiscard("You must use length")]]
-        Type length() const noexcept
+        constexpr Type length() const noexcept
         {
-            return std::hypot(x, y);
+            return internal::hypot(x, y);
         }
 
         [[nodiscard("You must use normalized vector")]]
-        Vector2 normalized() const noexcept
+        constexpr Vector2 normalized() const noexcept
         {
             const Type len = length();
             return len > static_cast<Type>(0) ? *this / len : *this;
@@ -216,24 +217,24 @@ namespace omath
         }
 
         [[nodiscard("You must use comparison result")]]
-        bool operator<(const Vector2& other) const noexcept
+        constexpr bool operator<(const Vector2& other) const noexcept
         {
             return length() < other.length();
         }
         [[nodiscard("You must use comparison result")]]
-        bool operator>(const Vector2& other) const noexcept
+        constexpr bool operator>(const Vector2& other) const noexcept
         {
             return length() > other.length();
         }
 
         [[nodiscard("You must use comparison result")]]
-        bool operator<=(const Vector2& other) const noexcept
+        constexpr bool operator<=(const Vector2& other) const noexcept
         {
             return length() <= other.length();
         }
 
         [[nodiscard("You must use comparison result")]]
-        bool operator>=(const Vector2& other) const noexcept
+        constexpr bool operator>=(const Vector2& other) const noexcept
         {
             return length() >= other.length();
         }
@@ -264,13 +265,14 @@ namespace omath
     };
 } // namespace omath
 
-template<> struct std::hash<omath::Vector2<float>>
+template<class Type>
+struct std::hash<omath::Vector2<Type>> final // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard("You must use hash value")]]
-    std::size_t operator()(const omath::Vector2<float>& vec) const noexcept
+    std::size_t operator()(const omath::Vector2<Type>& vec) const noexcept
     {
         std::size_t hash = 0;
-        constexpr std::hash<float> hasher;
+        constexpr std::hash<Type> hasher;
 
         hash ^= hasher(vec.x) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
         hash ^= hasher(vec.y) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
@@ -280,10 +282,10 @@ template<> struct std::hash<omath::Vector2<float>>
 };
 
 template<class Type>
-struct std::formatter<omath::Vector2<Type>> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Vector2<Type>> final // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard("You must use parse iterator")]]
-    static constexpr auto parse(std::format_parse_context& ctx)
+    static constexpr auto parse(std::format_parse_context& ctx) noexcept
     {
         return ctx.begin();
     }

include/omath/linear_algebra/vector3.hpp

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/linear_algebra/vector2.hpp"
 #include "omath/trigonometry/angle.hpp"
 #include <cstdint>
@@ -140,20 +141,20 @@ namespace omath
         }
 
 #ifndef _MSC_VER
-        [[nodiscard("You must use length")]] constexpr Type length() const
+        [[nodiscard("You must use length")]] constexpr Type length() const noexcept
         {
-            return std::hypot(this->x, this->y, z);
+            return internal::hypot(this->x, this->y, z);
         }
 
-        [[nodiscard("You must use 2D length")]] constexpr Type length_2d() const
+        [[nodiscard("You must use 2D length")]] constexpr Type length_2d() const noexcept
         {
             return Vector2<Type>::length();
         }
-        [[nodiscard("You must use distance")]] Type distance_to(const Vector3& other) const
+        [[nodiscard("You must use distance")]] constexpr Type distance_to(const Vector3& other) const noexcept
         {
             return (*this - other).length();
         }
-        [[nodiscard("You must use normalized vector")]] constexpr Vector3 normalized() const
+        [[nodiscard("You must use normalized vector")]] constexpr Vector3 normalized() const noexcept
         {
             const Type length_value = this->length();
 
@@ -161,13 +162,13 @@ namespace omath
         }
 #else
         [[nodiscard("You must use length")]]
-        Type length() const noexcept
+        constexpr Type length() const noexcept
         {
-            return std::hypot(this->x, this->y, z);
+            return internal::hypot(this->x, this->y, this->z);
         }
 
         [[nodiscard("You must use normalized vector")]]
-        Vector3 normalized() const noexcept
+        constexpr Vector3 normalized() const noexcept
         {
             const Type len = this->length();
 
@@ -175,13 +176,13 @@ namespace omath
         }
 
         [[nodiscard("You must use 2D length")]]
-        Type length_2d() const noexcept
+        constexpr Type length_2d() const noexcept
         {
             return Vector2<Type>::length();
         }
 
         [[nodiscard("You must use distance")]]
-        Type distance_to(const Vector3& v_other) const noexcept
+        constexpr Type distance_to(const Vector3& v_other) const noexcept
         {
             return (*this - v_other).length();
         }
@@ -249,24 +250,23 @@ namespace omath
         }
 
         [[nodiscard("You must use direction check result")]]
-        bool point_to_same_direction(const Vector3& other) const
+        constexpr bool point_to_same_direction(const Vector3& other) const
         {
             return dot(other) > static_cast<Type>(0);
         }
         [[nodiscard("You must use angle between vectors")]]
-        std::expected<Angle<float, 0.f, 180.f, AngleFlags::Clamped>, Vector3Error>
+        constexpr std::expected<Angle<float, 0.f, 180.f, AngleFlags::Clamped>, Vector3Error>
         angle_between(const Vector3& other) const noexcept
         {
             const auto bottom = length() * other.length();
 
             if (bottom == static_cast<Type>(0))
                 return std::unexpected(Vector3Error::IMPOSSIBLE_BETWEEN_ANGLE);
-
-            return Angle<float, 0.f, 180.f, AngleFlags::Clamped>::from_radians(std::acos(dot(other) / bottom));
+            return Angle<float, 0.f, 180.f, AngleFlags::Clamped>::from_radians(internal::acos(dot(other) / bottom));
         }
 
         [[nodiscard("You must use perpendicularity check result")]]
-        bool is_perpendicular(const Vector3& other, Type epsilon = static_cast<Type>(0.0001)) const noexcept
+        constexpr bool is_perpendicular(const Vector3& other, Type epsilon = static_cast<Type>(0.0001)) const noexcept
         {
             if (const auto angle = angle_between(other))
                 return std::abs(angle->as_degrees() - static_cast<Type>(90)) <= epsilon;
@@ -287,25 +287,25 @@ namespace omath
         }
 
         [[nodiscard("You must use comparison result")]]
-        bool operator<(const Vector3& other) const noexcept
+        constexpr bool operator<(const Vector3& other) const noexcept
         {
             return length() < other.length();
         }
 
         [[nodiscard("You must use comparison result")]]
-        bool operator>(const Vector3& other) const noexcept
+        constexpr bool operator>(const Vector3& other) const noexcept
         {
             return length() > other.length();
         }
 
         [[nodiscard("You must use comparison result")]]
-        bool operator<=(const Vector3& other) const noexcept
+        constexpr bool operator<=(const Vector3& other) const noexcept
         {
             return length() <= other.length();
         }
 
         [[nodiscard("You must use comparison result")]]
-        bool operator>=(const Vector3& other) const noexcept
+        constexpr bool operator>=(const Vector3& other) const noexcept
         {
             return length() >= other.length();
         }
@@ -318,13 +318,15 @@ namespace omath
     };
 } // namespace omath
 
-template<> struct std::hash<omath::Vector3<float>>
+template<class Type>
+struct std::hash<omath::Vector3<Type>> final // NOLINT(*-dcl58-cpp)
 {
+    // NOTE: Cannot be constexpr because of MSVC
     [[nodiscard("You must use hash value")]]
-    std::size_t operator()(const omath::Vector3<float>& vec) const noexcept
+    std::size_t operator()(const omath::Vector3<Type>& vec) const noexcept
     {
         std::size_t hash = 0;
-        constexpr std::hash<float> hasher;
+        constexpr std::hash<Type> hasher;
 
         hash ^= hasher(vec.x) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
         hash ^= hasher(vec.y) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
@@ -335,10 +337,10 @@ template<> struct std::hash<omath::Vector3<float>>
 };
 
 template<class Type>
-struct std::formatter<omath::Vector3<Type>> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Vector3<Type>> final // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard("You must use parse iterator")]]
-    static constexpr auto parse(std::format_parse_context& ctx)
+    static constexpr auto parse(std::format_parse_context& ctx) noexcept
     {
         return ctx.begin();
     }

include/omath/linear_algebra/vector4.hpp

@@ -225,13 +225,14 @@ namespace omath
     };
 } // namespace omath
 
-template<> struct std::hash<omath::Vector4<float>>
+template<class Type>
+struct std::hash<omath::Vector4<Type>> final // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard("You must use hash value")]]
-    std::size_t operator()(const omath::Vector4<float>& vec) const noexcept
+    std::size_t operator()(const omath::Vector4<Type>& vec) const noexcept
     {
         std::size_t hash = 0;
-        constexpr std::hash<float> hasher;
+        constexpr std::hash<Type> hasher;
 
         hash ^= hasher(vec.x) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
         hash ^= hasher(vec.y) + 0x9e3779b9 + (hash << 6) + (hash >> 2);
@@ -240,12 +241,11 @@ template<> struct std::hash<omath::Vector4<float>>
         return hash;
     }
 };
-
 template<class Type>
-struct std::formatter<omath::Vector4<Type>> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Vector4<Type>> final // NOLINT(*-dcl58-cpp)
 {
     [[nodiscard("You must use parse iterator")]]
-    static constexpr auto parse(std::format_parse_context& ctx)
+    static constexpr auto parse(std::format_parse_context& ctx) noexcept
     {
         return ctx.begin();
     }

include/omath/omath.hpp

@@ -6,6 +6,7 @@
 #pragma once
 
 // Basic math utilities
+#include "omath/hashing.hpp"
 #include "omath/trigonometry/angles.hpp"
 #include "omath/trigonometry/angle.hpp"
 

include/omath/pathfinding/a_star.hpp

@@ -13,12 +13,12 @@ namespace omath::pathfinding
     class Astar final
     {
     public:
-        [[nodiscard]]
+        [[nodiscard("You forgot to use returned path")]]
         static std::vector<Vector3<float>> find_path(const Vector3<float>& start, const Vector3<float>& end,
                                                      const NavigationMesh& nav_mesh) noexcept;
 
     private:
-        [[nodiscard]]
+        [[nodiscard("You forgot to use reconstructed path")]]
         static std::vector<Vector3<float>>
         reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
                                const Vector3<float>& current) noexcept;

include/omath/projection/camera.hpp

@@ -6,6 +6,7 @@
 
 #include "omath/3d_primitives/aabb.hpp"
 #include "omath/3d_primitives/obb.hpp"
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/triangle.hpp"
 #include "omath/linear_algebra/vector3.hpp"
@@ -84,8 +85,9 @@ namespace omath::projection
         };
 
         ~Camera() = default;
-        Camera(const Vector3<NumericType>& position, const ViewAnglesType& view_angles, const ViewPort& view_port,
-               const FieldOfView& fov, const NumericType near, const NumericType far) noexcept
+        constexpr Camera(const Vector3<NumericType>& position, const ViewAnglesType& view_angles,
+                         const ViewPort& view_port, const FieldOfView& fov, const NumericType near,
+                         const NumericType far) noexcept
             : m_view_port(view_port), m_field_of_view(fov), m_far_plane_distance(far), m_near_plane_distance(near),
               m_view_angles(view_angles), m_origin(position)
         {
@@ -102,18 +104,18 @@ namespace omath::projection
         // NEGATIVE_ONE_TO_ONE) share the same m[0,0]/m[1,1] layout, so this works
         // regardless of the NDC depth range.
         [[nodiscard("You must use extracted projection params")]]
-        static ProjectionParams extract_projection_params(const Mat4X4Type& proj_matrix) noexcept
+        constexpr static ProjectionParams extract_projection_params(const Mat4X4Type& proj_matrix) noexcept
         {
             // m[1,1] == 1 / tan(fov/2)  =>  fov = 2 * atan(1 / m[1,1])
             const auto f = proj_matrix.at(1, 1);
             // m[0,0] == m[1,1] / aspect_ratio  =>  aspect = m[1,1] / m[0,0]
-            const auto fov_radians = NumericType{2} * std::atan(NumericType{1} / f);
+            const auto fov_radians = NumericType{2} * internal::atan(NumericType{1} / f);
             return {FieldOfView::from_radians(static_cast<typename FieldOfView::ArithmeticType>(fov_radians)),
                     f / proj_matrix.at(0, 0)};
         }
 
         [[nodiscard("You must use calculated view angles")]]
-        static ViewAnglesType calc_view_angles_from_view_matrix(const Mat4X4Type& view_matrix) noexcept
+        constexpr static ViewAnglesType calc_view_angles_from_view_matrix(const Mat4X4Type& view_matrix) noexcept
         {
             Vector3<NumericType> forward_vector = {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]};
             if constexpr (axes.inverted_forward)
@@ -122,7 +124,7 @@ namespace omath::projection
         }
 
         [[nodiscard("You must use calculated origin")]]
-        static Vector3<NumericType> calc_origin_from_view_matrix(const Mat4X4Type& view_matrix) noexcept
+        constexpr static Vector3<NumericType> calc_origin_from_view_matrix(const Mat4X4Type& view_matrix) noexcept
         {
             // The view matrix is R * T(-origin), so the last column stores t = -R * origin.
             // Recovering origin: origin = -R^T * t
@@ -136,40 +138,58 @@ namespace omath::projection
             };
         }
 
-        void look_at(const Vector3<NumericType>& target)
+        constexpr void look_at(const Vector3<NumericType>& target)
         {
             m_view_angles = TraitClass::calc_look_at_angle(m_origin, target);
             m_view_projection_matrix = std::nullopt;
             m_view_matrix = std::nullopt;
         }
         [[nodiscard("You must use calculated look-at angles")]]
-        ViewAnglesType calc_look_at_angles(const Vector3<NumericType>& look_to) const
+        constexpr ViewAnglesType calc_look_at_angles(const Vector3<NumericType>& look_to) const
         {
             return TraitClass::calc_look_at_angle(m_origin, look_to);
         }
 
         [[nodiscard("You must use forward vector")]]
-        Vector3<NumericType> get_forward() const noexcept
+        constexpr Vector3<NumericType> get_forward() const noexcept
         {
+            if consteval
+            {
+                const auto view_matrix = calc_view_matrix();
+                return {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]};
+            }
+
             const auto& view_matrix = get_view_matrix();
             return {view_matrix[2, 0], view_matrix[2, 1], view_matrix[2, 2]};
         }
 
         [[nodiscard("You must use right vector")]]
-        Vector3<NumericType> get_right() const noexcept
+        constexpr Vector3<NumericType> get_right() const noexcept
         {
+            if consteval
+            {
+                const auto view_matrix = calc_view_matrix();
+                return {view_matrix[0, 0], view_matrix[0, 1], view_matrix[0, 2]};
+            }
+
             const auto& view_matrix = get_view_matrix();
             return {view_matrix[0, 0], view_matrix[0, 1], view_matrix[0, 2]};
         }
 
         [[nodiscard("You must use up vector")]]
-        Vector3<NumericType> get_up() const noexcept
+        constexpr Vector3<NumericType> get_up() const noexcept
         {
+            if consteval
+            {
+                const auto view_matrix = calc_view_matrix();
+                return {view_matrix[1, 0], view_matrix[1, 1], view_matrix[1, 2]};
+            }
+
             const auto& view_matrix = get_view_matrix();
             return {view_matrix[1, 0], view_matrix[1, 1], view_matrix[1, 2]};
         }
         [[nodiscard("You must use absolute forward vector")]]
-        Vector3<NumericType> get_abs_forward() const noexcept
+        constexpr Vector3<NumericType> get_abs_forward() const noexcept
         {
             if constexpr (axes.inverted_forward)
                 return -get_forward();
@@ -177,7 +197,7 @@ namespace omath::projection
         }
 
         [[nodiscard("You must use absolute right vector")]]
-        Vector3<NumericType> get_abs_right() const noexcept
+        constexpr Vector3<NumericType> get_abs_right() const noexcept
         {
             if constexpr (axes.inverted_right)
                 return -get_right();
@@ -185,13 +205,32 @@ namespace omath::projection
         }
 
         [[nodiscard("You must use absolute up vector")]]
-        Vector3<NumericType> get_abs_up() const noexcept
+        constexpr Vector3<NumericType> get_abs_up() const noexcept
         {
             return get_up();
         }
 
+        [[nodiscard("You must use calculated view-projection matrix")]]
+        constexpr Mat4X4Type calc_view_projection_matrix() const noexcept
+        {
+            return calc_projection_matrix() * calc_view_matrix();
+        }
+
+        [[nodiscard("You must use calculated view matrix")]]
+        constexpr Mat4X4Type calc_view_matrix() const noexcept
+        {
+            return TraitClass::calc_view_matrix(m_view_angles, m_origin);
+        }
+
+        [[nodiscard("You must use calculated projection matrix")]]
+        constexpr Mat4X4Type calc_projection_matrix() const noexcept
+        {
+            return TraitClass::calc_projection_matrix(m_field_of_view, m_view_port, m_near_plane_distance,
+                                                      m_far_plane_distance, depth_range);
+        }
+
         [[nodiscard("You must use view-projection matrix")]]
-        const Mat4X4Type& get_view_projection_matrix() const noexcept
+        constexpr const Mat4X4Type& get_view_projection_matrix() const noexcept
         {
             if (!m_view_projection_matrix.has_value())
                 m_view_projection_matrix = get_projection_matrix() * get_view_matrix();
@@ -199,90 +238,96 @@ namespace omath::projection
             return m_view_projection_matrix.value();
         }
 
-        [[nodiscard("You must use view matrix")]] const Mat4X4Type& get_view_matrix() const noexcept
+        [[nodiscard("You must use view matrix")]]
+        constexpr const Mat4X4Type& get_view_matrix() const noexcept
         {
             if (!m_view_matrix.has_value())
-                m_view_matrix = TraitClass::calc_view_matrix(m_view_angles, m_origin);
+                m_view_matrix = calc_view_matrix();
 
             return m_view_matrix.value();
         }
-        [[nodiscard("You must use projection matrix")]] const Mat4X4Type& get_projection_matrix() const noexcept
+        [[nodiscard("You must use projection matrix")]] constexpr const Mat4X4Type&
+        get_projection_matrix() const noexcept
         {
             if (!m_projection_matrix.has_value())
-                m_projection_matrix = TraitClass::calc_projection_matrix(
-                        m_field_of_view, m_view_port, m_near_plane_distance, m_far_plane_distance, depth_range);
+                m_projection_matrix = calc_projection_matrix();
 
             return m_projection_matrix.value();
         }
 
-        void set_field_of_view(const FieldOfView& fov) noexcept
+        constexpr void set_field_of_view(const FieldOfView& fov) noexcept
         {
             m_field_of_view = fov;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
 
-        void set_near_plane(const NumericType near_plane) noexcept
+        constexpr void set_near_plane(const NumericType near_plane) noexcept
         {
             m_near_plane_distance = near_plane;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
 
-        void set_far_plane(const NumericType far_plane) noexcept
+        constexpr void set_far_plane(const NumericType far_plane) noexcept
         {
             m_far_plane_distance = far_plane;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
 
-        void set_view_angles(const ViewAnglesType& view_angles) noexcept
+        constexpr void set_view_angles(const ViewAnglesType& view_angles) noexcept
         {
             m_view_angles = view_angles;
             m_view_projection_matrix = std::nullopt;
             m_view_matrix = std::nullopt;
         }
 
-        void set_origin(const Vector3<NumericType>& origin) noexcept
+        constexpr void set_origin(const Vector3<NumericType>& origin) noexcept
         {
             m_origin = origin;
             m_view_projection_matrix = std::nullopt;
             m_view_matrix = std::nullopt;
         }
-        void set_view_port(const ViewPort& view_port) noexcept
+        constexpr void set_view_port(const ViewPort& view_port) noexcept
         {
             m_view_port = view_port;
             m_view_projection_matrix = std::nullopt;
             m_projection_matrix = std::nullopt;
         }
 
-        [[nodiscard("You must use field of view")]] const FieldOfView& get_field_of_view() const noexcept
+        [[nodiscard("You must use field of view")]]
+        constexpr const FieldOfView& get_field_of_view() const noexcept
         {
             return m_field_of_view;
         }
 
-        [[nodiscard("You must use near plane")]] const NumericType& get_near_plane() const noexcept
+        [[nodiscard("You must use near plane")]]
+        constexpr const NumericType& get_near_plane() const noexcept
         {
             return m_near_plane_distance;
         }
 
-        [[nodiscard("You must use far plane")]] const NumericType& get_far_plane() const noexcept
+        [[nodiscard("You must use far plane")]]
+        constexpr const NumericType& get_far_plane() const noexcept
         {
             return m_far_plane_distance;
         }
 
-        [[nodiscard("You must use view angles")]] const ViewAnglesType& get_view_angles() const noexcept
+        [[nodiscard("You must use view angles")]]
+        constexpr const ViewAnglesType& get_view_angles() const noexcept
         {
             return m_view_angles;
         }
 
-        [[nodiscard("You must use origin")]] const Vector3<NumericType>& get_origin() const noexcept
+        [[nodiscard("You must use origin")]]
+        constexpr const Vector3<NumericType>& get_origin() const noexcept
         {
             return m_origin;
         }
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
-        [[nodiscard("You must use screen position")]] std::expected<Vector3<NumericType>, Error>
+        [[nodiscard("You must use screen position")]] constexpr std::expected<Vector3<NumericType>, Error>
         world_to_screen(const Vector3<NumericType>& world_position) const noexcept
         {
             const auto normalized_cords = world_to_view_port(world_position);
@@ -298,7 +343,7 @@ namespace omath::projection
                 std::unreachable();
         }
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
-        [[nodiscard("You must use unclipped screen position")]] std::expected<Vector3<NumericType>, Error>
+        [[nodiscard("You must use unclipped screen position")]] constexpr std::expected<Vector3<NumericType>, Error>
         world_to_screen_unclipped(const Vector3<NumericType>& world_position) const noexcept
         {
             const auto normalized_cords = world_to_view_port(world_position, ViewPortClipping::MANUAL);
@@ -314,7 +359,7 @@ namespace omath::projection
                 std::unreachable();
         }
 
-        [[nodiscard("You must use frustum culling result")]] bool
+        [[nodiscard("You must use frustum culling result")]] constexpr bool
         is_culled_by_frustum(const Triangle<Vector3<NumericType>>& triangle) const noexcept
         {
             // Transform to clip space (before perspective divide)
@@ -382,7 +427,7 @@ namespace omath::projection
             return false;
         }
 
-        [[nodiscard("You must use AABB frustum culling result")]] bool
+        [[nodiscard("You must use AABB frustum culling result")]] constexpr bool
         is_aabb_culled_by_frustum(const primitives::Aabb<NumericType>& aabb) const noexcept
         {
             // For each plane, find the AABB corner most in the direction of the plane normal
@@ -400,7 +445,7 @@ namespace omath::projection
             return false;
         }
 
-        [[nodiscard("You must use OBB frustum culling result")]] bool
+        [[nodiscard("You must use OBB frustum culling result")]] constexpr bool
         is_obb_culled_by_frustum(const primitives::Obb<NumericType>& obb) const noexcept
         {
             // For each plane, project the OBB extents onto the plane normal to get the
@@ -410,9 +455,9 @@ namespace omath::projection
                 const Vector3<NumericType> normal{a, b, c};
 
                 const auto center_distance = normal.dot(obb.center) + d;
-                const auto radius = obb.half_extents.x * std::abs(normal.dot(obb.axis_x))
-                                    + obb.half_extents.y * std::abs(normal.dot(obb.axis_y))
-                                    + obb.half_extents.z * std::abs(normal.dot(obb.axis_z));
+                const auto radius = obb.half_extents.x * internal::abs(normal.dot(obb.axis_x))
+                                    + obb.half_extents.y * internal::abs(normal.dot(obb.axis_y))
+                                    + obb.half_extents.z * internal::abs(normal.dot(obb.axis_z));
 
                 if (center_distance + radius < NumericType{0})
                     return true;
@@ -421,13 +466,29 @@ namespace omath::projection
             return false;
         }
 
-        [[nodiscard("You must use view port position")]] std::expected<Vector3<NumericType>, Error>
+        [[nodiscard("You must view camera space coordinates")]]
+        constexpr Vector3<NumericType> world_to_view_coordinates(const Vector3<NumericType>& world_coordinates) const noexcept
+        {
+            if consteval
+            {
+                const auto view_coordinates =
+                    calc_view_matrix()
+                    * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(world_coordinates);
+
+                return {view_coordinates.at(0, 0), view_coordinates.at(1, 0), view_coordinates.at(2, 0)};
+            }
+            const auto view_coordinates =
+                    get_view_matrix()
+                    * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(world_coordinates);
+
+            return {view_coordinates.at(0, 0), view_coordinates.at(1, 0), view_coordinates.at(2, 0)};
+        }
+        [[nodiscard("You must use view port position")]] constexpr std::expected<Vector3<NumericType>, Error>
         world_to_view_port(const Vector3<NumericType>& world_position,
                            const ViewPortClipping& clipping = ViewPortClipping::AUTO) const noexcept
         {
-            auto projected = get_view_projection_matrix()
-                             * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(world_position);
-
+            auto project_to_view_port = [&clipping](auto projected) -> std::expected<Vector3<NumericType>, Error>
+            {
                 const auto& w = projected.at(3, 0);
                 constexpr auto eps = std::numeric_limits<NumericType>::epsilon();
                 if (w <= eps)
@@ -436,7 +497,8 @@ namespace omath::projection
                 projected /= w;
 
                 // ReSharper disable once CppTooWideScope
-            const auto clipped_automatically = clipping == ViewPortClipping::AUTO && is_ndc_out_of_bounds(projected);
+                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);
 
@@ -449,32 +511,57 @@ namespace omath::projection
                     return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
                 return Vector3<NumericType>{projected.at(0, 0), projected.at(1, 0), projected.at(2, 0)};
+            };
+
+            if consteval
+            {
+                auto projected =
+                        calc_view_projection_matrix()
+                        * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(world_position);
+                return project_to_view_port(projected);
+            }
+
+            auto projected = get_view_projection_matrix()
+                             * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(world_position);
+            return project_to_view_port(projected);
         }
         [[nodiscard("You must use world position")]]
-        std::expected<Vector3<NumericType>, Error> view_port_to_world(const Vector3<NumericType>& ndc) const noexcept
+        constexpr std::expected<Vector3<NumericType>, Error>
+        view_port_to_world(const Vector3<NumericType>& ndc) const noexcept
         {
-            const auto inv_view_proj = get_view_projection_matrix().inverted();
+            auto view_port_to_world =
+                    [&ndc](const Mat4X4Type& view_projection) -> std::expected<Vector3<NumericType>, Error>
+            {
+                const auto inv_view_proj = view_projection.inverted();
 
                 if (!inv_view_proj)
                     return std::unexpected(Error::INV_VIEW_PROJ_MAT_DET_EQ_ZERO);
 
-            auto inverted_projection =
-                    inv_view_proj.value() * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(ndc);
+                auto inverted_projection = inv_view_proj.value()
+                                           * mat_column_from_vector<NumericType, Mat4X4Type::get_store_ordering()>(ndc);
 
                 const auto& w = inverted_projection.at(3, 0);
 
-            if (std::abs(w) < std::numeric_limits<NumericType>::epsilon())
+                if (internal::abs(w) < std::numeric_limits<NumericType>::epsilon())
                     return std::unexpected(Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS);
 
                 inverted_projection /= w;
 
                 return Vector3<NumericType>{inverted_projection.at(0, 0), inverted_projection.at(1, 0),
                                             inverted_projection.at(2, 0)};
+            };
+
+            if consteval
+            {
+                return view_port_to_world(calc_view_projection_matrix());
+            }
+
+            return view_port_to_world(get_view_projection_matrix());
         }
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
         [[nodiscard("You must use world position")]]
-        std::expected<Vector3<NumericType>, Error>
+        constexpr std::expected<Vector3<NumericType>, Error>
         screen_to_world(const Vector3<NumericType>& screen_pos) const noexcept
         {
             return view_port_to_world(screen_to_ndc<screen_start>(screen_pos));
@@ -482,7 +569,7 @@ namespace omath::projection
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
         [[nodiscard("You must use world position")]]
-        std::expected<Vector3<NumericType>, Error>
+        constexpr std::expected<Vector3<NumericType>, Error>
         screen_to_world(const Vector2<NumericType>& screen_pos) const noexcept
         {
             const auto& [x, y] = screen_pos;
@@ -517,7 +604,8 @@ namespace omath::projection
         //   Top    = r3 - r1
         //   Near   = r3 + r2  ([-1,1]) or r2 ([0,1])
         //   Far    = r3 - r2
-        [[nodiscard("You must use frustum planes")]] std::array<FrustumPlane, 6> extract_frustum_planes() const noexcept
+        [[nodiscard("You must use frustum planes")]] constexpr std::array<FrustumPlane, 6>
+        extract_frustum_planes() const noexcept
         {
             const auto& m = get_view_projection_matrix();
 
@@ -589,7 +677,7 @@ namespace omath::projection
                                 v
             */
 
-        [[nodiscard("You must use screen position")]] Vector3<NumericType>
+        [[nodiscard("You must use screen position")]] constexpr Vector3<NumericType>
         ndc_to_screen_position_from_top_left_corner(const Vector3<NumericType>& ndc) const noexcept
         {
             /*
@@ -607,7 +695,7 @@ namespace omath::projection
                     (ndc.y / -NumericType{2} + NumericType{0.5}) * m_view_port.m_height, ndc.z};
         }
 
-        [[nodiscard("You must use screen position")]] Vector3<NumericType>
+        [[nodiscard("You must use screen position")]] constexpr Vector3<NumericType>
         ndc_to_screen_position_from_bottom_left_corner(const Vector3<NumericType>& ndc) const noexcept
         {
             /*
@@ -626,7 +714,7 @@ namespace omath::projection
         }
 
         template<ScreenStart screen_start = ScreenStart::TOP_LEFT_CORNER>
-        [[nodiscard("You must use NDC position")]] Vector3<NumericType>
+        [[nodiscard("You must use NDC position")]] constexpr Vector3<NumericType>
         screen_to_ndc(const Vector3<NumericType>& screen_pos) const noexcept
         {
             if constexpr (screen_start == ScreenStart::TOP_LEFT_CORNER)

include/omath/rev_eng/internal_rev_object.hpp

@@ -21,36 +21,20 @@
 
 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:
         template<class Type>
-        [[nodiscard]] Type& get_by_offset(const std::ptrdiff_t offset)
+        [[nodiscard("You must use value")]]
+        Type& get_by_offset(const std::ptrdiff_t offset) noexcept
         {
             return *reinterpret_cast<Type*>(reinterpret_cast<std::uintptr_t>(this) + offset);
         }
 
         template<class Type>
-        [[nodiscard]] const Type& get_by_offset(const std::ptrdiff_t offset) const
+        [[nodiscard("You must use value")]]
+        const Type& get_by_offset(const std::ptrdiff_t offset) const noexcept
         {
             return *reinterpret_cast<Type*>(reinterpret_cast<std::uintptr_t>(this) + offset);
         }
@@ -76,14 +60,16 @@ namespace omath::rev_eng
             return reinterpret_cast<MethodType>(const_cast<void*>(ptr))(this, arg_list...);
         }
 
-        template<FixedString ModuleName, FixedString Pattern, class ReturnType>
+        template<PatternScanner::ConstevalPattern ModuleName, PatternScanner::ConstevalPattern 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>
+        template<PatternScanner::ConstevalPattern ModuleName, PatternScanner::ConstevalPattern Pattern,
+                 class ReturnType>
         ReturnType call_method(auto... arg_list) const
         {
             static const auto* address = resolve_pattern(ModuleName, Pattern);
@@ -91,14 +77,15 @@ namespace omath::rev_eng
         }
 
         template<class ReturnType>
-        ReturnType call_method(const std::string_view& module_name,const std::string_view& pattern, auto... arg_list)
+        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
+        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...);
@@ -119,26 +106,24 @@ namespace omath::rev_eng
         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);
+            auto sub_this = reinterpret_cast<void*>(reinterpret_cast<std::uintptr_t>(this) + TableOffset);
             const auto vtable = *reinterpret_cast<void***>(sub_this);
 #ifdef _MSC_VER
             using Fn = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
 #else
-            using Fn = 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);
+            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)...);
+            using Fn = ReturnType (*)(const void*, decltype(arg_list)...);
 #endif
             return reinterpret_cast<Fn>(vtable[Id])(sub_this, arg_list...);
         }
@@ -161,8 +146,8 @@ namespace omath::rev_eng
             return reinterpret_cast<const void*>(*result);
         }
 
-        [[nodiscard]]
-        static const void* get_module_base(const std::string_view module_name)
+        [[nodiscard("You forgot to use module base address")]]
+        static const void* get_module_base(const std::string_view module_name) noexcept
         {
 #ifdef _WIN32
             return GetModuleHandleA(module_name.data());

include/omath/trigonometry/angle.hpp

@@ -3,9 +3,12 @@
 //
 
 #pragma once
+#include "omath/internal/constexpr_math.hpp"
 #include "omath/trigonometry/angles.hpp"
 #include <algorithm>
+#include <compare>
 #include <format>
+#include <type_traits>
 #include <utility>
 
 namespace omath
@@ -17,7 +20,7 @@ namespace omath
     };
 
     template<class Type = float, Type min = Type(0), Type max = Type(360), AngleFlags flags = AngleFlags::Normalized>
-    requires std::is_arithmetic_v<Type>
+    requires std::is_floating_point_v<Type>
     class Angle
     {
         Type m_angle;
@@ -42,7 +45,7 @@ namespace omath
         {
             return Angle{degrees};
         }
-        constexpr Angle() noexcept: m_angle(0)
+        constexpr Angle() noexcept: Angle(Type{0})
         {
         }
         [[nodiscard]]
@@ -51,6 +54,30 @@ namespace omath
             return Angle{angles::radians_to_degrees<Type>(degrees)};
         }
 
+        [[nodiscard]]
+        constexpr static Angle from_asin(const Type& value) noexcept
+        {
+            return from_radians(internal::asin(value));
+        }
+
+        [[nodiscard]]
+        constexpr static Angle from_acos(const Type& value) noexcept
+        {
+            return from_radians(internal::acos(value));
+        }
+
+        [[nodiscard]]
+        constexpr static Angle from_atan(const Type& value) noexcept
+        {
+            return from_radians(internal::atan(value));
+        }
+
+        [[nodiscard]]
+        constexpr static Angle from_atan2(const Type& y, const Type& x) noexcept
+        {
+            return from_radians(internal::atan2(y, x));
+        }
+
         [[nodiscard]]
         constexpr const Type& operator*() const noexcept
         {
@@ -70,31 +97,25 @@ namespace omath
         }
 
         [[nodiscard]]
-        Type sin() const noexcept
+        constexpr Type sin() const noexcept
         {
-            return std::sin(as_radians());
+            return internal::sin(as_radians());
         }
 
         [[nodiscard]]
-        Type cos() const noexcept
+        constexpr Type cos() const noexcept
         {
-            return std::cos(as_radians());
+            return internal::cos(as_radians());
         }
 
         [[nodiscard]]
-        Type tan() const noexcept
+        constexpr Type tan() const noexcept
         {
-            return std::tan(as_radians());
+            return internal::tan(as_radians());
         }
 
         [[nodiscard]]
-        Type atan() const noexcept
-        {
-            return std::atan(as_radians());
-        }
-
-        [[nodiscard]]
-        Type cot() const noexcept
+        constexpr Type cot() const noexcept
         {
             return cos() / sin();
         }
@@ -120,11 +141,12 @@ namespace omath
 
         constexpr Angle& operator-=(const Angle& other) noexcept
         {
-            return operator+=(-other);
+            *this = Angle{m_angle - other.m_angle};
+            return *this;
         }
 
         [[nodiscard]]
-        constexpr Angle operator+(const Angle& other) noexcept
+        constexpr Angle operator+(const Angle& other) const noexcept
         {
             if constexpr (flags == AngleFlags::Normalized)
                 return Angle{angles::wrap_angle(m_angle + other.m_angle, min, max)};
@@ -139,9 +161,9 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Angle operator-(const Angle& other) noexcept
+        constexpr Angle operator-(const Angle& other) const noexcept
         {
-            return operator+(-other);
+            return Angle{m_angle - other.m_angle};
         }
 
         [[nodiscard]]
@@ -153,10 +175,11 @@ namespace omath
 } // namespace omath
 
 template<class T, T MinV, T MaxV, omath::AngleFlags F>
-struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char> final // NOLINT(*-dcl58-cpp)
 {
     using AngleT = omath::Angle<T, MinV, MaxV, F>;
 
+    [[nodiscard]]
     static constexpr auto parse(std::format_parse_context& ctx)
     {
         return ctx.begin();
@@ -170,13 +193,13 @@ struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char> // NOLINT(*-dcl58-cp
         return std::format_to(ctx.out(), "{}deg", a.as_degrees());
     }
 };
-
 // wchar_t formatter
 template<class T, T MinV, T MaxV, omath::AngleFlags F>
-struct std::formatter<omath::Angle<T, MinV, MaxV, F>, wchar_t> // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Angle<T, MinV, MaxV, F>, wchar_t> final // NOLINT(*-dcl58-cpp)
 {
     using AngleT = omath::Angle<T, MinV, MaxV, F>;
 
+    [[nodiscard]]
     static constexpr auto parse(std::wformat_parse_context& ctx)
     {
         return ctx.begin();
@@ -190,23 +213,3 @@ struct std::formatter<omath::Angle<T, MinV, MaxV, F>, wchar_t> // NOLINT(*-dcl58
         return std::format_to(ctx.out(), L"{}deg", a.as_degrees());
     }
 };
-
-// wchar_t formatter
-template<class T, T MinV, T MaxV, omath::AngleFlags F>
-struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char8_t> // NOLINT(*-dcl58-cpp)
-{
-    using AngleT = omath::Angle<T, MinV, MaxV, F>;
-
-    static constexpr auto parse(std::wformat_parse_context& ctx)
-    {
-        return ctx.begin();
-    }
-
-    template<class FormatContext>
-    [[nodiscard]]
-    auto format(const AngleT& a, FormatContext& ctx) const
-    {
-        static_assert(std::is_same_v<typename FormatContext::char_type, char8_t>);
-        return std::format_to(ctx.out(), u8"{}deg", a.as_degrees());
-    }
-};

include/omath/trigonometry/angles.hpp

@@ -3,6 +3,7 @@
 //
 
 #pragma once
+#include "omath/internal/constexpr_math.hpp"
 #include <cmath>
 #include <numbers>
 
@@ -24,37 +25,38 @@ namespace omath::angles
 
     template<class Type>
     requires std::is_floating_point_v<Type>
-    [[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect) noexcept
+    [[nodiscard]] constexpr Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect) noexcept
     {
         const auto fov_rad = degrees_to_radians(horizontal_fov);
 
-        const auto vert_fov = static_cast<Type>(2) * std::atan(std::tan(fov_rad / static_cast<Type>(2)) / aspect);
+        const auto vert_fov =
+                static_cast<Type>(2) * internal::atan(internal::tan(fov_rad / static_cast<Type>(2)) / aspect);
 
         return radians_to_degrees(vert_fov);
     }
 
     template<class Type>
     requires std::is_floating_point_v<Type>
-    [[nodiscard]] Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect) noexcept
+    [[nodiscard]] constexpr Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect) noexcept
     {
         const auto fov_as_radians = degrees_to_radians(vertical_fov);
 
         const auto horizontal_fov =
-                static_cast<Type>(2) * std::atan(std::tan(fov_as_radians / static_cast<Type>(2)) * aspect);
+                static_cast<Type>(2) * internal::atan(internal::tan(fov_as_radians / static_cast<Type>(2)) * aspect);
 
         return radians_to_degrees(horizontal_fov);
     }
 
     template<class Type>
-    requires std::is_arithmetic_v<Type>
-    [[nodiscard]] Type wrap_angle(const Type& angle, const Type& min, const Type& max) noexcept
+    requires std::is_floating_point_v<Type>
+    [[nodiscard]] constexpr Type wrap_angle(const Type& angle, const Type& min, const Type& max) noexcept
     {
-        if (angle <= max && angle >= min)
+        if (angle < max && angle >= min)
             return angle;
 
         const Type range = max - min;
 
-        Type wrapped_angle = std::fmod(angle - min, range);
+        Type wrapped_angle = internal::fmod(angle - min, range);
 
         if (wrapped_angle < 0)
             wrapped_angle += range;

include/omath/trigonometry/view_angles.hpp

@@ -18,7 +18,7 @@ namespace omath
         RollType roll;
 
         [[nodiscard]]
-        Vector3<ArithmeticType> as_vector3() const
+        constexpr Vector3<ArithmeticType> as_vector3() const
         {
             return {pitch.as_degrees(), yaw.as_degrees(), roll.as_degrees()};
         }

include/omath/utility/color.hpp

@@ -34,13 +34,13 @@ namespace omath
             m_value.clamp(0.f, 1.f);
         }
         constexpr explicit Color() noexcept = default;
-        [[nodiscard]]
+        [[nodiscard("color result should not be discarded")]]
         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<float>(r, g, b, a) / 255.f);
         }
 
-        [[nodiscard]]
+        [[nodiscard("color result should not be discarded")]]
         constexpr static Color from_hsv(float hue, const float saturation, const float value) noexcept
         {
             float r{}, g{}, b{};
@@ -80,13 +80,13 @@ namespace omath
             return {r, g, b, 1.f};
         }
 
-        [[nodiscard]]
+        [[nodiscard("color result should not be discarded")]]
         constexpr static Color from_hsv(const Hsv& hsv) noexcept
         {
             return from_hsv(hsv.hue, hsv.saturation, hsv.value);
         }
 
-        [[nodiscard]]
+        [[nodiscard("hsv result should not be discarded")]]
         constexpr Hsv to_hsv() const noexcept
         {
             Hsv hsv_data;
@@ -141,33 +141,33 @@ namespace omath
 
             *this = from_hsv(hsv);
         }
-        [[nodiscard]]
+        [[nodiscard("blended color result should not be discarded")]]
         constexpr Color blend(const Color& other, float ratio) const noexcept
         {
             ratio = std::clamp(ratio, 0.f, 1.f);
             return Color(this->m_value * (1.f - ratio) + other.m_value * ratio);
         }
 
-        [[nodiscard]] static constexpr Color red()
+        [[nodiscard("color result should not be discarded")]] static constexpr Color red()
         {
             return {1.f, 0.f, 0.f, 1.f};
         }
-        [[nodiscard]] static constexpr Color green()
+        [[nodiscard("color result should not be discarded")]] static constexpr Color green()
         {
             return {0.f, 1.f, 0.f, 1.f};
         }
-        [[nodiscard]] static constexpr Color blue()
+        [[nodiscard("color result should not be discarded")]] static constexpr Color blue()
         {
             return {0.f, 0.f, 1.f, 1.f};
         }
 #ifdef OMATH_IMGUI_INTEGRATION
-        [[nodiscard]]
+        [[nodiscard("ImColor result should not be discarded")]]
         ImColor to_im_color() const noexcept
         {
             return {m_value.to_im_vec4()};
         }
 #endif
-        [[nodiscard]] std::string to_string() const noexcept
+        [[nodiscard("string result should not be discarded")]] std::string to_string() const noexcept
         {
             return std::format("[r:{}, g:{}, b:{}, a:{}]",
                             static_cast<int>(m_value.x * 255.f),
@@ -175,24 +175,24 @@ namespace omath
                             static_cast<int>(m_value.z * 255.f),
                             static_cast<int>(m_value.w * 255.f));
         }
-        [[nodiscard]] std::string to_rgbf_string() const noexcept
+        [[nodiscard("string result should not be discarded")]] 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
+        [[nodiscard("string result should not be discarded")]] 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
+        [[nodiscard("wide string result should not be discarded")]] std::wstring to_wstring() const noexcept
         {
             const auto ascii_string = to_string();
             return {ascii_string.cbegin(), ascii_string.cend()};
         }
 
         // ReSharper disable once CppInconsistentNaming
-        [[nodiscard]] std::u8string to_u8string() const noexcept
+        [[nodiscard("UTF-8 string result should not be discarded")]] std::u8string to_u8string() const noexcept
         {
             const auto ascii_string = to_string();
             return {ascii_string.cbegin(), ascii_string.cend()};

include/omath/utility/elf_pattern_scan.hpp

@@ -2,12 +2,13 @@
 // Created by Vladislav on 30.12.2025.
 //
 #pragma once
+#include "pattern_scan.hpp"
+#include "section_scan_result.hpp"
 #include <cstdint>
 #include <filesystem>
 #include <optional>
 #include <span>
 #include <string_view>
-#include "section_scan_result.hpp"
 namespace omath
 {
     class ElfPatternScanner final
@@ -18,14 +19,74 @@ namespace omath
         scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& pattern,
                                           const std::string_view& target_section_name = ".text");
 
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address,
+                                          const std::string_view& target_section_name = ".text")
+        {
+            return scan_for_pattern_in_loaded_module(module_base_address, target_section_name,
+                                                     &ElfPatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
         [[nodiscard]]
         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");
 
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                 const std::string_view& target_section_name = ".text")
+        {
+            return scan_for_pattern_in_file(path_to_file, target_section_name,
+                                            &ElfPatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
         [[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");
+
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data,
+                                        const std::string_view& target_section_name = ".text")
+        {
+            return scan_for_pattern_in_memory_file(file_data, target_section_name,
+                                                   &ElfPatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
+    private:
+        using SectionScanFunction = std::optional<std::ptrdiff_t> (*)(std::span<const std::byte>);
+
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<std::ptrdiff_t> scan_section_for_pattern(const std::span<const std::byte> section_data)
+        {
+            const auto result = PatternScanner::scan_for_pattern<Pattern>(section_data.begin(), section_data.end());
+
+            if (result == section_data.end())
+                return std::nullopt;
+
+            return result - section_data.begin();
+        }
+
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& target_section_name,
+                                          SectionScanFunction scan_pattern);
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult> scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                                                         const std::string_view& target_section_name,
+                                                                         SectionScanFunction scan_pattern);
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data,
+                                        const std::string_view& target_section_name, SectionScanFunction scan_pattern);
     };
 } // namespace omath

include/omath/utility/macho_pattern_scan.hpp

@@ -2,12 +2,13 @@
 // Created by Copilot on 04.02.2026.
 //
 #pragma once
+#include "pattern_scan.hpp"
+#include "section_scan_result.hpp"
 #include <cstdint>
 #include <filesystem>
 #include <optional>
 #include <span>
 #include <string_view>
-#include "section_scan_result.hpp"
 namespace omath
 {
     class MachOPatternScanner final
@@ -18,14 +19,74 @@ namespace omath
         scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& pattern,
                                           const std::string_view& target_section_name = "__text");
 
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address,
+                                          const std::string_view& target_section_name = "__text")
+        {
+            return scan_for_pattern_in_loaded_module(module_base_address, target_section_name,
+                                                     &MachOPatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
         [[nodiscard]]
         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");
 
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                 const std::string_view& target_section_name = "__text")
+        {
+            return scan_for_pattern_in_file(path_to_file, target_section_name,
+                                            &MachOPatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
         [[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");
+
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data,
+                                        const std::string_view& target_section_name = "__text")
+        {
+            return scan_for_pattern_in_memory_file(file_data, target_section_name,
+                                                   &MachOPatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
+    private:
+        using SectionScanFunction = std::optional<std::ptrdiff_t> (*)(std::span<const std::byte>);
+
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<std::ptrdiff_t> scan_section_for_pattern(const std::span<const std::byte> section_data)
+        {
+            const auto result = PatternScanner::scan_for_pattern<Pattern>(section_data.begin(), section_data.end());
+
+            if (result == section_data.end())
+                return std::nullopt;
+
+            return result - section_data.begin();
+        }
+
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& target_section_name,
+                                          SectionScanFunction scan_pattern);
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult> scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                                                         const std::string_view& target_section_name,
+                                                                         SectionScanFunction scan_pattern);
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data,
+                                        const std::string_view& target_section_name, SectionScanFunction scan_pattern);
     };
 } // namespace omath

include/omath/utility/pattern_scan.hpp

@@ -3,9 +3,12 @@
 //
 
 #pragma once
+#include <algorithm>
+#include <array>
 #include <expected>
 #include <optional>
 #include <span>
+#include <stdexcept>
 #include <string_view>
 #include <vector>
 
@@ -15,6 +18,8 @@ class unit_test_pattern_scan_corner_case_1_Test;
 class unit_test_pattern_scan_corner_case_2_Test;
 class unit_test_pattern_scan_corner_case_3_Test;
 class unit_test_pattern_scan_corner_case_4_Test;
+class unit_test_pattern_scan_consteval_read_test_Test;
+class unit_test_pattern_scan_consteval_spacing_and_case_Test;
 // ReSharper restore CppInconsistentNaming
 namespace omath
 {
@@ -29,8 +34,26 @@ namespace omath
         friend unit_test_pattern_scan_corner_case_2_Test;
         friend unit_test_pattern_scan_corner_case_3_Test;
         friend unit_test_pattern_scan_corner_case_4_Test;
+        friend unit_test_pattern_scan_consteval_read_test_Test;
+        friend unit_test_pattern_scan_consteval_spacing_and_case_Test;
 
     public:
+        template<std::size_t Length>
+        struct ConstevalPattern final
+        {
+            char value[Length]{};
+
+            // ReSharper disable once CppNonExplicitConvertingConstructor
+            constexpr ConstevalPattern(const char (&text)[Length]) // NOLINT(*-explicit-constructor)
+            {
+                std::ranges::copy(text, value);
+            }
+            [[nodiscard("You forgot to use string")]]
+            constexpr operator std::string_view() const noexcept // NOLINT(*-explicit-constructor)
+            {
+                return {value, Length - 1};
+            }
+        };
         [[nodiscard]]
         static std::span<std::byte>::iterator scan_for_pattern(const std::span<std::byte>& range,
                                                                const std::string_view& pattern);
@@ -49,9 +72,26 @@ namespace omath
             if (!parsed_pattern) [[unlikely]]
                 return end;
 
+            return scan_for_parsed_pattern(begin, end, parsed_pattern.value());
+        }
+        template<ConstevalPattern Pattern, class IteratorType>
+        requires std::input_or_output_iterator<std::remove_cvref_t<IteratorType>>
+        static IteratorType scan_for_pattern(const IteratorType& begin, const IteratorType& end)
+        {
+            constexpr auto parsed_pattern = parse_pattern<Pattern>();
+
+            return scan_for_parsed_pattern(begin, end, parsed_pattern);
+        }
+
+    private:
+        template<class IteratorType, class ParsedPattern>
+        requires std::input_or_output_iterator<std::remove_cvref_t<IteratorType>>
+        static IteratorType scan_for_parsed_pattern(const IteratorType& begin, const IteratorType& end,
+                                                    const ParsedPattern& parsed_pattern)
+        {
             const auto whole_range_size = static_cast<std::ptrdiff_t>(std::distance(begin, end));
 
-            const auto pattern_size = static_cast<std::ptrdiff_t>(parsed_pattern->size());
+            const auto pattern_size = static_cast<std::ptrdiff_t>(parsed_pattern.size());
             const std::ptrdiff_t scan_size = whole_range_size - pattern_size;
 
             if (scan_size < 0)
@@ -61,9 +101,9 @@ namespace omath
             {
                 bool found = true;
 
-                for (std::ptrdiff_t j = 0; j < static_cast<std::ptrdiff_t>(parsed_pattern->size()); j++)
+                for (std::ptrdiff_t j = 0; j < static_cast<std::ptrdiff_t>(parsed_pattern.size()); j++)
                 {
-                    found = parsed_pattern->at(j) == std::nullopt || parsed_pattern->at(j) == *(begin + i + j);
+                    found = parsed_pattern.at(j) == std::nullopt || parsed_pattern.at(j) == *(begin + i + j);
 
                     if (!found)
                         break;
@@ -73,10 +113,97 @@ namespace omath
             }
             return end;
         }
-
-    private:
         [[nodiscard]]
         static std::expected<std::vector<std::optional<std::byte>>, PatternScanError>
         parse_pattern(const std::string_view& pattern_string);
+
+        [[nodiscard]]
+        constexpr static bool is_space(const char c)
+        {
+            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+        }
+
+        [[nodiscard]]
+        constexpr static int hex_value(const char c)
+        {
+            if (c >= '0' && c <= '9')
+                return c - '0';
+            if (c >= 'A' && c <= 'F')
+                return c - 'A' + 10;
+            if (c >= 'a' && c <= 'f')
+                return c - 'a' + 10;
+            return -1;
+        }
+        template<ConstevalPattern Pattern>
+        [[nodiscard]]
+        static consteval std::size_t signature_size()
+        {
+            std::size_t count = 0;
+            bool in_token = false;
+
+            for (std::size_t i = 0; i + 1 < sizeof(Pattern.value); ++i)
+            {
+                if (is_space(Pattern.value[i]))
+                {
+                    in_token = false;
+                }
+                else if (!in_token)
+                {
+                    ++count;
+                    in_token = true;
+                }
+            }
+
+            return count;
+        }
+
+        template<ConstevalPattern Pattern>
+        static consteval std::array<std::optional<std::byte>, signature_size<Pattern>()> parse_pattern()
+        {
+            std::array<std::optional<std::byte>, signature_size<Pattern>()> result{};
+            std::size_t out = 0;
+            std::size_t i = 0;
+
+            while (i + 1 < sizeof(Pattern.value))
+            {
+                while (i + 1 < sizeof(Pattern.value) && is_space(Pattern.value[i]))
+                    ++i;
+
+                const std::size_t token_start = i;
+
+                while (i + 1 < sizeof(Pattern.value) && !is_space(Pattern.value[i]))
+                    ++i;
+
+                const std::size_t token_size = i - token_start;
+
+                if (token_size == 0)
+                    continue;
+
+                // ReSharper disable once CppTooWideScope
+                const bool is_wildcard = (token_size == 1 || token_size == 2) && Pattern.value[token_start] == '?';
+
+                if (is_wildcard)
+                {
+                    if (token_size == 2 && Pattern.value[token_start + 1] != '?')
+                        throw std::logic_error("invalid wildcard token");
+
+                    result[out++] = std::nullopt;
+                    continue;
+                }
+
+                if (token_size != 2)
+                    throw std::logic_error("invalid byte token");
+
+                const int high = hex_value(Pattern.value[token_start]);
+                const int low = hex_value(Pattern.value[token_start + 1]);
+
+                if (high < 0 || low < 0)
+                    throw std::logic_error("invalid hex byte");
+
+                result[out++] = static_cast<std::byte>((high << 4) | low);
+            }
+
+            return result;
+        }
     };
 } // namespace omath

include/omath/utility/pe_pattern_scan.hpp

@@ -3,12 +3,13 @@
 //
 
 #pragma once
+#include "pattern_scan.hpp"
+#include "section_scan_result.hpp"
 #include <cstdint>
 #include <filesystem>
 #include <optional>
 #include <span>
 #include <string_view>
-#include "section_scan_result.hpp"
 namespace omath
 {
 
@@ -20,14 +21,74 @@ namespace omath
         scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& pattern,
                                           const std::string_view& target_section_name = ".text");
 
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address,
+                                          const std::string_view& target_section_name = ".text")
+        {
+            return scan_for_pattern_in_loaded_module(module_base_address, target_section_name,
+                                                     &PePatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
         [[nodiscard]]
         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");
 
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                 const std::string_view& target_section_name = ".text")
+        {
+            return scan_for_pattern_in_file(path_to_file, target_section_name,
+                                            &PePatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
         [[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");
+
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data,
+                                        const std::string_view& target_section_name = ".text")
+        {
+            return scan_for_pattern_in_memory_file(file_data, target_section_name,
+                                                   &PePatternScanner::scan_section_for_pattern<Pattern>);
+        }
+
+    private:
+        using SectionScanFunction = std::optional<std::ptrdiff_t> (*)(std::span<const std::byte>);
+
+        template<PatternScanner::ConstevalPattern Pattern>
+        [[nodiscard]]
+        static std::optional<std::ptrdiff_t> scan_section_for_pattern(const std::span<const std::byte> section_data)
+        {
+            const auto result = PatternScanner::scan_for_pattern<Pattern>(section_data.begin(), section_data.end());
+
+            if (result == section_data.end())
+                return std::nullopt;
+
+            return result - section_data.begin();
+        }
+
+        [[nodiscard]]
+        static std::optional<std::uintptr_t>
+        scan_for_pattern_in_loaded_module(const void* module_base_address, const std::string_view& target_section_name,
+                                          SectionScanFunction scan_pattern);
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult> scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
+                                                                         const std::string_view& target_section_name,
+                                                                         SectionScanFunction scan_pattern);
+
+        [[nodiscard]]
+        static std::optional<SectionScanResult>
+        scan_for_pattern_in_memory_file(std::span<const std::byte> file_data,
+                                        const std::string_view& target_section_name, SectionScanFunction scan_pattern);
     };
 } // namespace omath

modules/omath.cppm

@@ -0,0 +1,59 @@
+module;
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <expected>
+#include <filesystem>
+#include <format>
+#include <functional>
+#include <initializer_list>
+#include <iomanip>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <memory_resource>
+#include <numbers>
+#include <numeric>
+#include <optional>
+#include <queue>
+#include <ranges>
+#include <span>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <variant>
+#include <vector>
+
+#if defined(OMATH_USE_AVX2)
+#include <immintrin.h>
+#endif
+
+#if defined(OMATH_IMGUI_INTEGRATION)
+#include <imgui.h>
+#endif
+
+#if defined(_WIN32)
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#elif defined(__APPLE__)
+#include <mach-o/dyld.h>
+#elif defined(__linux__) || defined(__unix__)
+#include <link.h>
+#endif
+
+export module omath;
+
+export {
+#include "omath/omath.hpp"
+}

scripts/coverage-llvm.sh

@@ -177,9 +177,7 @@ if command -v genhtml >/dev/null 2>&1; then
         --title "Omath Coverage Report" \
         --show-details \
         --legend \
-        --demangle-cpp \
         --num-spaces 4 \
-        --sort \
         --function-coverage \
         --branch-coverage
     

source/engines/cry_engine/formulas.cpp

@@ -1,70 +0,0 @@
-//
-// Created by Vlad on 3/22/2025.
-//
-#include "omath/engines/cry_engine/formulas.hpp"
-
-namespace omath::cry_engine
-{
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), right_vector(angles),
-                                                               up_vector(angles), cam_origin);
-    }
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.yaw)
-               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.roll)
-               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
-    }
-
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_origin(mat);
-    }
-
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_scale(mat);
-    }
-
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
-    {
-        const auto angles = mat_extract_rotation_zyx(mat);
-        return {
-                PitchAngle::from_degrees(angles.x),
-                YawAngle::from_degrees(angles.z),
-                RollAngle::from_degrees(angles.y),
-        };
-    }
-
-    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return mat_perspective_left_handed_vertical_fov<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_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-                    field_of_view, aspect_ratio, near, far);
-        std::unreachable();
-    }
-} // namespace omath::cry_engine

source/engines/cry_engine/traits/camera_trait.cpp

@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/cry_engine/traits/camera_trait.hpp"
-
-namespace omath::cry_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(std::asin(direction.z)),
-                YawAngle::from_radians(-std::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return cry_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
-                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::cry_engine

source/engines/frostbite_engine/formulas.cpp

@@ -1,71 +0,0 @@
-//
-// Created by Vlad on 3/22/2025.
-//
-#include "omath/engines/frostbite_engine/formulas.hpp"
-
-namespace omath::frostbite_engine
-{
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), right_vector(angles),
-                                                               up_vector(angles), cam_origin);
-    }
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll)
-               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
-               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
-    }
-
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_origin(mat);
-    }
-
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_scale(mat);
-    }
-
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
-    {
-        const auto angles = mat_extract_rotation_zyx(mat);
-        return {
-                PitchAngle::from_degrees(angles.x),
-                YawAngle::from_degrees(angles.y),
-                RollAngle::from_degrees(angles.z),
-        };
-    }
-
-    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return mat_perspective_left_handed_vertical_fov<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_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-                    field_of_view, aspect_ratio, near, far);
-
-        std::unreachable();
-    }
-} // namespace omath::unity_engine

source/engines/frostbite_engine/traits/camera_trait.cpp

@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/frostbite_engine/traits/camera_trait.hpp"
-
-namespace omath::frostbite_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(-std::asin(direction.y)),
-                YawAngle::from_radians(std::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return frostbite_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
-                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::unity_engine

source/engines/iw_engine/formulas.cpp

@@ -1,79 +0,0 @@
-//
-// Created by Vlad on 3/19/2025.
-//
-#include "omath/engines/iw_engine/formulas.hpp"
-
-namespace omath::iw_engine
-{
-
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
-    }
-
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_origin(mat);
-    }
-
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_scale(mat);
-    }
-
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
-    {
-        const auto angles = mat_extract_rotation_zyx(mat);
-        return {
-                PitchAngle::from_degrees(angles.y),
-                YawAngle::from_degrees(angles.z),
-                RollAngle::from_degrees(angles.x),
-        };
-    }
-
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
-    }
-
-    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        // InfinityWard Engine (inherited from Quake) stores FOV as horizontal FOV at a 4:3
-        // reference aspect. Convert to true vertical FOV, then delegate to the
-        // standard vertical-FOV left-handed builder with the caller's actual
-        // aspect ratio.
-        //   vfov = 2 · atan( tan(hfov_4:3 / 2) / (4/3) )
-        constexpr float k_source_reference_aspect = 4.f / 3.f;
-        const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect);
-
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return mat_perspective_left_handed_vertical_fov<
-                    float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                    vertical_fov, aspect_ratio, near, far);
-        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return mat_perspective_left_handed_vertical_fov<
-                    float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-                    vertical_fov, aspect_ratio, near, far);
-        std::unreachable();
-    };
-} // namespace omath::iw_engine

source/engines/iw_engine/traits/camera_trait.cpp

@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/iw_engine/traits/camera_trait.hpp"
-#include "omath/engines/iw_engine/formulas.hpp"
-namespace omath::iw_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(-std::asin(direction.z)),
-                YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return iw_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
-                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::iw_engine

source/engines/opengl_engine/formulas.cpp

@@ -1,73 +0,0 @@
-//
-// Created by Vlad on 3/19/2025.
-//
-#include "omath/engines/opengl_engine/formulas.hpp"
-
-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);
-
-        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);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_up);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return mat_look_at_right_handed(cam_origin, cam_origin + forward_vector(angles), up_vector(angles));
-    }
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll)
-               * mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(angles.yaw)
-               * mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(angles.pitch);
-    }
-
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_origin(mat);
-    }
-
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_scale(mat);
-    }
-
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
-    {
-        const auto angles = mat_extract_rotation_zyx(mat);
-        return {
-                PitchAngle::from_degrees(angles.x),
-                YawAngle::from_degrees(angles.y),
-                RollAngle::from_degrees(angles.z),
-        };
-    }
-
-    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return mat_perspective_right_handed_vertical_fov<float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-                    field_of_view, aspect_ratio, near, far);
-
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return mat_perspective_right_handed_vertical_fov<float, MatStoreType::COLUMN_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                        field_of_view, aspect_ratio, near, far);
-
-        std::unreachable();
-    }
-} // namespace omath::opengl_engine

source/engines/opengl_engine/traits/camera_trait.cpp

@@ -1,28 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/opengl_engine/traits/camera_trait.hpp"
-#include "omath/engines/opengl_engine/formulas.hpp"
-
-namespace omath::opengl_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(std::asin(direction.y)),
-                YawAngle::from_radians(-std::atan2(direction.x, -direction.z)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return opengl_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
-                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::opengl_engine

source/engines/rage_engine/formulas.cpp

@@ -1,71 +0,0 @@
-//
-// Created by Orange on 6/3/2026.
-//
-#include "omath/engines/rage_engine/formulas.hpp"
-
-namespace omath::rage_engine
-{
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), right_vector(angles),
-                                                               up_vector(angles), cam_origin);
-    }
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.yaw)
-               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.roll)
-               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
-    }
-
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_origin(mat);
-    }
-
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_scale(mat);
-    }
-
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
-    {
-        const auto angles = mat_extract_rotation_zyx(mat);
-        return {
-                PitchAngle::from_degrees(angles.x),
-                YawAngle::from_degrees(angles.z),
-                RollAngle::from_degrees(angles.y),
-        };
-    }
-
-    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return mat_perspective_left_handed_vertical_fov<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_vertical_fov<float, MatStoreType::ROW_MAJOR,
-                                                            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-                    field_of_view, aspect_ratio, near, far);
-        std::unreachable();
-    }
-} // namespace omath::rage_engine

source/engines/rage_engine/traits/camera_trait.cpp

@@ -1,27 +0,0 @@
-//
-// Created by Orange on 6/3/2026.
-//
-#include "omath/engines/rage_engine/traits/camera_trait.hpp"
-
-namespace omath::rage_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(std::asin(direction.z)),
-                YawAngle::from_radians(-std::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return rage_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near, const float far,
-                                               const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::rage_engine

source/engines/source_engine/formulas.cpp

@@ -1,79 +0,0 @@
-//
-// Created by Vlad on 3/19/2025.
-//
-#include <omath/engines/source_engine/formulas.hpp>
-
-namespace omath::source_engine
-{
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
-    }
-
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_origin(mat);
-    }
-
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_scale(mat);
-    }
-
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
-    {
-        const auto angles = mat_extract_rotation_zyx(mat);
-        return {
-                PitchAngle::from_degrees(angles.y),
-                YawAngle::from_degrees(angles.z),
-                RollAngle::from_degrees(angles.x),
-        };
-    }
-
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
-    }
-
-    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        // Source (inherited from Quake) stores FOV as horizontal FOV at a 4:3
-        // reference aspect. Convert to true vertical FOV, then delegate to the
-        // standard vertical-FOV left-handed builder with the caller's actual
-        // aspect ratio.
-        //   vfov = 2 · atan( tan(hfov_4:3 / 2) / (4/3) )
-        constexpr float k_source_reference_aspect = 4.f / 3.f;
-        const auto vertical_fov = angles::horizontal_fov_to_vertical(field_of_view, k_source_reference_aspect);
-
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return mat_perspective_left_handed_vertical_fov<
-                    float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                    vertical_fov, aspect_ratio, near, far);
-        if (ndc_depth_range == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return mat_perspective_left_handed_vertical_fov<
-                    float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-                    vertical_fov, aspect_ratio, near, far);
-        std::unreachable();
-    }
-} // namespace omath::source_engine

source/engines/source_engine/traits/camera_trait.cpp

@@ -1,28 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/source_engine/traits/camera_trait.hpp"
-#include "omath/engines/source_engine/formulas.hpp"
-namespace omath::source_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-
-        return {PitchAngle::from_radians(-std::asin(direction.z)),
-                YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return source_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
-                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::source_engine

source/engines/unity_engine/formulas.cpp

@@ -1,70 +0,0 @@
-//
-// Created by Vlad on 3/22/2025.
-//
-#include "omath/engines/unity_engine/formulas.hpp"
-
-namespace omath::unity_engine
-{
-    Vector3<float> forward_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Vector3<float> right_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Vector3<float> up_vector(const ViewAngles& angles) noexcept
-    {
-        const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
-
-        return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
-    }
-    Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return mat_camera_view<float, MatStoreType::ROW_MAJOR>(-forward_vector(angles), right_vector(angles),
-                                                               up_vector(angles), cam_origin);
-    }
-    Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
-    {
-        return mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll)
-               * mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
-               * mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch);
-    }
-
-    Vector3<float> extract_origin(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_origin(mat);
-    }
-
-    Vector3<float> extract_scale(const Mat4X4& mat) noexcept
-    {
-        return mat_extract_scale(mat);
-    }
-
-    ViewAngles extract_rotation_angles(const Mat4X4& mat) noexcept
-    {
-        const auto angles = mat_extract_rotation_zyx(mat);
-        return {
-                PitchAngle::from_degrees(angles.x),
-                YawAngle::from_degrees(angles.y),
-                RollAngle::from_degrees(angles.z),
-        };
-    }
-
-    Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
-                                              const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        if (ndc_depth_range == NDCDepthRange::ZERO_TO_ONE)
-            return omath::mat_perspective_right_handed_vertical_fov<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_vertical_fov<float, MatStoreType::ROW_MAJOR,
-                                                       NDCDepthRange::NEGATIVE_ONE_TO_ONE>(field_of_view, aspect_ratio,
-                                                                                           near, far);
-        std::unreachable();
-    }
-} // namespace omath::unity_engine

source/engines/unity_engine/traits/camera_trait.cpp

@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/unity_engine/traits/camera_trait.hpp"
-
-namespace omath::unity_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<float>& cam_origin, const Vector3<float>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(-std::asin(direction.y)),
-                YawAngle::from_radians(std::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
-    {
-        return unity_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const float near,
-                                               const float far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::unity_engine

source/engines/unreal_engine/formulas.cpp

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

source/engines/unreal_engine/traits/camera_trait.cpp

@@ -1,27 +0,0 @@
-//
-// Created by Vlad on 8/11/2025.
-//
-#include "omath/engines/unreal_engine/traits/camera_trait.hpp"
-
-namespace omath::unreal_engine
-{
-
-    ViewAngles CameraTrait::calc_look_at_angle(const Vector3<double>& cam_origin, const Vector3<double>& look_at) noexcept
-    {
-        const auto direction = (look_at - cam_origin).normalized();
-
-        return {PitchAngle::from_radians(std::asin(direction.z)),
-                YawAngle::from_radians(std::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
-    }
-    Mat4X4 CameraTrait::calc_view_matrix(const ViewAngles& angles, const Vector3<double>& cam_origin) noexcept
-    {
-        return unreal_engine::calc_view_matrix(angles, cam_origin);
-    }
-    Mat4X4 CameraTrait::calc_projection_matrix(const projection::FieldOfView& fov,
-                                               const projection::ViewPort& view_port, const double near,
-                                               const double far, const NDCDepthRange ndc_depth_range) noexcept
-    {
-        return calc_perspective_projection_matrix(fov.as_degrees(), view_port.aspect_ratio(), near, far,
-                                                  ndc_depth_range);
-    }
-} // namespace omath::unreal_engine

source/hud/entity_overlay.cpp

@@ -2,6 +2,7 @@
 // Created by orange on 13.03.2026.
 //
 #include "omath/hud/entity_overlay.hpp"
+#include <limits>
 
 namespace omath::hud
 {
@@ -20,6 +21,20 @@ namespace omath::hud
 
         return *this;
     }
+
+    EntityOverlay& EntityOverlay::add_2d_box(const Color& box_color, const Gradient& fill_gradient,
+                                             const Color& outline_color, const float thickness)
+    {
+        const auto points = m_canvas.as_array();
+
+        if (outline_color.value().w > 0.f)
+            m_renderer->add_polyline({points.data(), points.size()}, outline_color, thickness + 2.f);
+
+        m_renderer->add_polyline({points.data(), points.size()}, box_color, thickness);
+        m_renderer->add_gradient_rectangle(m_canvas.top_left_corner, m_canvas.bottom_right_corner, fill_gradient);
+
+        return *this;
+    }
     EntityOverlay& EntityOverlay::add_cornered_2d_box(const Color& box_color, const Color& fill_color,
                                                       const Color& outline_color, const float corner_ratio_len,
                                                       const float thickness)
@@ -38,11 +53,9 @@ namespace omath::hud
         };
 
         // Left Side
-        draw_corner_line(m_canvas.top_left_corner,
-                         m_canvas.top_left_corner + Vector2<float>{corner_line_length, 0.f});
+        draw_corner_line(m_canvas.top_left_corner, m_canvas.top_left_corner + Vector2<float>{corner_line_length, 0.f});
 
-        draw_corner_line(m_canvas.top_left_corner,
-                         m_canvas.top_left_corner + Vector2<float>{0.f, corner_line_length});
+        draw_corner_line(m_canvas.top_left_corner, m_canvas.top_left_corner + Vector2<float>{0.f, corner_line_length});
 
         draw_corner_line(m_canvas.bottom_left_corner,
                          m_canvas.bottom_left_corner - Vector2<float>{0.f, corner_line_length});
@@ -64,76 +77,84 @@ namespace omath::hud
 
         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)
+    EntityOverlay& EntityOverlay::add_right_bar(const widget::BarPaint& color, const Color& outline_color,
+                                                const Color& bg_color, const float width, float ratio,
+                                                const float offset, const std::optional<widget::Glow>& glow)
     {
         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);
+        const auto bar_min = bar_start - Vector2<float>{0.f, max_bar_height};
+        const auto bar_max = bar_start + Vector2<float>{width, 0.f};
+        const auto fill_min = bar_start - Vector2<float>{0.f, max_bar_height * ratio};
+        m_renderer->add_filled_rectangle(bar_min, bar_max, 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);
+        draw_glow_rectangle(fill_min, bar_max, glow);
+        draw_filled_rectangle(fill_min, bar_max, resolve_bar_paint(color, ratio, true));
+        m_renderer->add_rectangle(bar_min, bar_max, 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)
+    EntityOverlay& EntityOverlay::add_left_bar(const widget::BarPaint& color, const Color& outline_color,
+                                               const Color& bg_color, const float width, float ratio,
+                                               const float offset, const std::optional<widget::Glow>& glow)
     {
         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);
+        const auto bar_min = bar_start - Vector2<float>{0.f, max_bar_height};
+        const auto bar_max = bar_start + Vector2<float>{width, 0.f};
+        const auto fill_min = bar_start - Vector2<float>{0.f, max_bar_height * ratio};
+        m_renderer->add_filled_rectangle(bar_min, bar_max, 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);
+        draw_glow_rectangle(fill_min, bar_max, glow);
+        draw_filled_rectangle(fill_min, bar_max, resolve_bar_paint(color, ratio, true));
+        m_renderer->add_rectangle(bar_min, bar_max, outline_color);
 
         m_text_cursor_left.x -= offset + width;
 
         return *this;
     }
-    EntityOverlay& EntityOverlay::add_right_label(const Color& color, const float offset,
-                                                  const widget::Outlined outlined,
-                                                  const std::string_view& text)
+    EntityOverlay& EntityOverlay::add_right_label(const widget::Paint& color, const float offset,
+                                                  const widget::Outlined outlined, const std::string_view& text,
+                                                  const std::optional<widget::Glow>& glow)
     {
-        if (outlined == widget::Outlined::On)
-            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());
+        draw_label(m_text_cursor_right + Vector2<float>{offset, 0.f}, color, outlined, text, glow);
 
         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 widget::Outlined outlined,
-                                                const std::string_view text)
+    EntityOverlay& EntityOverlay::add_top_label(const widget::Paint& color, const float offset,
+                                                const widget::Outlined outlined, const std::string_view text,
+                                                const std::optional<widget::Glow>& glow)
     {
         m_text_cursor_top.y -= m_renderer->calc_text_size(text.data()).y;
 
-        if (outlined == widget::Outlined::On)
-            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());
+        draw_label(m_text_cursor_top + Vector2<float>{0.f, -offset}, color, outlined, text, glow);
 
         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)
+    EntityOverlay& EntityOverlay::add_top_bar(const widget::BarPaint& color, const Color& outline_color,
+                                              const Color& bg_color, const float height, float ratio,
+                                              const float offset, const std::optional<widget::Glow>& glow)
     {
         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);
+        const auto bar_min = bar_start - Vector2<float>{0.f, height};
+        const auto bar_max = bar_start + Vector2<float>{max_bar_width, 0.f};
+        const auto fill_max = Vector2<float>{bar_start.x + max_bar_width * ratio, bar_start.y};
+        m_renderer->add_filled_rectangle(bar_min, bar_max, 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);
+        draw_glow_rectangle(bar_min, fill_max, glow);
+        draw_filled_rectangle(bar_min, fill_max, resolve_bar_paint(color, ratio, false));
+        m_renderer->add_rectangle(bar_min, bar_max, outline_color);
 
         m_text_cursor_top.y -= offset + height;
 
@@ -316,6 +337,14 @@ namespace omath::hud
         return *this;
     }
 
+    EntityOverlay& EntityOverlay::add_skeleton(const std::span<const widget::Bone> bones, const Color& color,
+                                               const float thickness)
+    {
+        for (const auto& bone : bones)
+            m_renderer->add_line(bone.start, bone.end, 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
     {
@@ -366,84 +395,265 @@ namespace omath::hud
         return *this;
     }
 
-    void EntityOverlay::draw_outlined_text(const Vector2<float>& position, const Color& color,
-                                           const std::string_view& text)
+    void EntityOverlay::draw_label(const Vector2<float>& position, const widget::Paint& paint,
+                                   const widget::Outlined outlined, const std::string_view& text,
+                                   const std::optional<widget::Glow>& glow)
+    {
+        if (glow)
+        {
+            const int radius = static_cast<int>(std::ceil(std::max(glow->radius, 0.f)));
+            for (int layer = radius; layer > 0; --layer)
+            {
+                const float alpha = glow->color.value().w * std::max(glow->intensity, 0.f)
+                                    * (1.f - static_cast<float>(layer - 1) / static_cast<float>(radius + 1));
+                const auto value = glow->color.value();
+                const Color color{value.x, value.y, value.z, alpha / static_cast<float>(radius)};
+                for (int x = -layer; x <= layer; ++x)
+                {
+                    m_renderer->add_text(position + Vector2<float>{static_cast<float>(x), static_cast<float>(-layer)},
+                                         color, text);
+                    m_renderer->add_text(position + Vector2<float>{static_cast<float>(x), static_cast<float>(layer)},
+                                         color, text);
+                }
+                for (int y = -layer + 1; y < layer; ++y)
+                {
+                    m_renderer->add_text(position + Vector2<float>{static_cast<float>(-layer), static_cast<float>(y)},
+                                         color, text);
+                    m_renderer->add_text(position + Vector2<float>{static_cast<float>(layer), static_cast<float>(y)},
+                                         color, text);
+                }
+            }
+        }
+
+        if (outlined == widget::Outlined::On)
         {
             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());
+                m_renderer->add_text(position + outline_offset, Color{0.f, 0.f, 0.f, 1.f}, text);
         }
-    EntityOverlay& EntityOverlay::add_bottom_bar(const Color& color, const Color& outline_color, const Color& bg_color,
-                                                 const float height, float ratio, const float offset)
+
+        std::visit(
+                widget::Overloaded{
+                        [&](const Color& color)
+                        {
+                            m_renderer->add_text(position, color, text);
+                        },
+                        [&](const Gradient& gradient)
+                        {
+                            m_renderer->add_gradient_text(position, gradient, text);
+                        },
+                },
+                paint);
+    }
+
+    void EntityOverlay::draw_glow_polyline(const std::span<const Vector2<float>>& points, const widget::Glow& glow,
+                                           const float thickness) const
+    {
+        const int radius = static_cast<int>(std::ceil(std::max(glow.radius, 0.f)));
+        const auto value = glow.color.value();
+        for (int layer = radius; layer > 0; --layer)
+        {
+            const float falloff = 1.f - static_cast<float>(layer - 1) / static_cast<float>(radius + 1);
+            const Color color{value.x, value.y, value.z,
+                              value.w * std::max(glow.intensity, 0.f) * falloff / static_cast<float>(radius)};
+            m_renderer->add_polyline(points, color, thickness + static_cast<float>(layer) * 2.f);
+        }
+    }
+
+    void EntityOverlay::draw_glow_line(const Vector2<float>& from, const Vector2<float>& to, const widget::Glow& glow,
+                                       const float thickness) const
+    {
+        const int radius = static_cast<int>(std::ceil(std::max(glow.radius, 0.f)));
+        const auto value = glow.color.value();
+        for (int layer = radius; layer > 0; --layer)
+        {
+            const float falloff = 1.f - static_cast<float>(layer - 1) / static_cast<float>(radius + 1);
+            const Color color{value.x, value.y, value.z,
+                              value.w * std::max(glow.intensity, 0.f) * falloff / static_cast<float>(radius)};
+            m_renderer->add_line(from, to, color, thickness + static_cast<float>(layer) * 2.f);
+        }
+    }
+
+    void EntityOverlay::draw_glow_rectangle(const Vector2<float>& min, const Vector2<float>& max,
+                                            const std::optional<widget::Glow>& glow) const
+    {
+        if (!glow || glow->radius <= 0.f)
+            return;
+
+        const std::array points = {
+                Vector2<float>{std::min(min.x, max.x), std::min(min.y, max.y)},
+                Vector2<float>{std::max(min.x, max.x), std::min(min.y, max.y)},
+                Vector2<float>{std::max(min.x, max.x), std::max(min.y, max.y)},
+                Vector2<float>{std::min(min.x, max.x), std::max(min.y, max.y)},
+        };
+        draw_glow_polyline(points, *glow, 1.f);
+    }
+
+    void EntityOverlay::draw_canvas_glow(const widget::CanvasGlow& canvas_glow) const
+    {
+        const int layers = std::max(canvas_glow.layers, 2);
+        const auto min = m_canvas.top_left_corner;
+        const auto max = m_canvas.bottom_right_corner;
+        const auto value = canvas_glow.glow.color.value();
+        const float intensity = std::max(canvas_glow.glow.intensity, 0.f);
+
+        constexpr int corner_segments = 12;
+        const float max_rounding = std::min(std::abs(max.x - min.x), std::abs(max.y - min.y)) * 0.5f;
+        const float rounding = std::clamp(canvas_glow.rounding, 0.f, max_rounding);
+        const float extent = std::max(canvas_glow.glow.radius, 0.f);
+        const float stroke = std::max(extent / static_cast<float>(layers - 1) * 2.f, 1.f);
+        for (int layer = 0; layer < layers; ++layer)
+        {
+            const float progress = static_cast<float>(layer) / static_cast<float>(layers - 1);
+            const float expansion = extent * (1.f - progress);
+            const float falloff = progress * progress * (3.f - 2.f * progress);
+            const Color color{value.x, value.y, value.z, value.w * intensity * falloff * 0.35f};
+            const auto expanded_min = min - Vector2<float>{expansion, expansion};
+            const auto expanded_max = max + Vector2<float>{expansion, expansion};
+            const float expanded_rounding = rounding + expansion;
+            const std::array corner_centers = {
+                    expanded_min + Vector2<float>{expanded_rounding, expanded_rounding},
+                    Vector2<float>{expanded_max.x - expanded_rounding, expanded_min.y + expanded_rounding},
+                    expanded_max - Vector2<float>{expanded_rounding, expanded_rounding},
+                    Vector2<float>{expanded_min.x + expanded_rounding, expanded_max.y - expanded_rounding},
+            };
+            std::array<Vector2<float>, corner_segments * 4> points;
+            for (int corner = 0; corner < 4; ++corner)
+            {
+                const float start_angle =
+                        std::numbers::pi_v<float> + static_cast<float>(corner) * std::numbers::pi_v<float> * 0.5f;
+                for (int segment = 0; segment < corner_segments; ++segment)
+                {
+                    const float arc_progress = static_cast<float>(segment) / static_cast<float>(corner_segments - 1);
+                    const float angle = start_angle + arc_progress * std::numbers::pi_v<float> * 0.5f;
+                    points[corner * corner_segments + segment] =
+                            corner_centers[corner]
+                            + Vector2<float>{std::cos(angle) * expanded_rounding, std::sin(angle) * expanded_rounding};
+                }
+            }
+            constexpr float clip_extent = std::numeric_limits<float>::max() * 0.25f;
+            m_renderer->add_polyline_clipped(points, {-clip_extent, -clip_extent}, {clip_extent, min.y}, color, stroke);
+            m_renderer->add_polyline_clipped(points, {-clip_extent, max.y}, {clip_extent, clip_extent}, color, stroke);
+            m_renderer->add_polyline_clipped(points, {-clip_extent, min.y}, {min.x, max.y}, color, stroke);
+            m_renderer->add_polyline_clipped(points, {max.x, min.y}, {clip_extent, max.y}, color, stroke);
+        }
+    }
+
+    void EntityOverlay::draw_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max,
+                                              const widget::Paint& paint) const
+    {
+        const Vector2<float> top_left{std::min(min.x, max.x), std::min(min.y, max.y)};
+        const Vector2<float> bottom_right{std::max(min.x, max.x), std::max(min.y, max.y)};
+        std::visit(
+                widget::Overloaded{
+                        [&](const Color& color)
+                        {
+                            m_renderer->add_filled_rectangle(top_left, bottom_right, color);
+                        },
+                        [&](const Gradient& gradient)
+                        {
+                            m_renderer->add_gradient_rectangle(top_left, bottom_right, gradient);
+                        },
+                },
+                paint);
+    }
+
+    widget::Paint EntityOverlay::resolve_bar_paint(const widget::BarPaint& paint, const float ratio,
+                                                   const bool vertical)
+    {
+        return std::visit(
+                widget::Overloaded{
+                        [](const Color& color) -> widget::Paint
+                        {
+                            return color;
+                        },
+                        [](const Gradient& gradient) -> widget::Paint
+                        {
+                            return gradient;
+                        },
+                        [&](const widget::BarGradient& gradient) -> widget::Paint
+                        {
+                            const float value = std::clamp(ratio, 0.f, 1.f);
+                            const auto current = Color{gradient.empty_color.value() * (1.f - value)
+                                                       + gradient.full_color.value() * value};
+                            if (vertical)
+                                return Gradient{current, current, gradient.empty_color, gradient.empty_color};
+                            return Gradient{gradient.empty_color, current, current, gradient.empty_color};
+                        },
+                },
+                paint);
+    }
+    EntityOverlay& EntityOverlay::add_bottom_bar(const widget::BarPaint& color, const Color& outline_color,
+                                                 const Color& bg_color, const float height, float ratio,
+                                                 const float offset, const std::optional<widget::Glow>& glow)
     {
         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);
+        const auto bar_min = bar_start;
+        const auto bar_max = bar_start + Vector2<float>{max_bar_width, height};
+        const auto fill_max = bar_start + Vector2<float>{max_bar_width * ratio, height};
+        m_renderer->add_filled_rectangle(bar_min, bar_max, bg_color);
+        draw_glow_rectangle(bar_min, fill_max, glow);
+        draw_filled_rectangle(bar_min, fill_max, resolve_bar_paint(color, ratio, false));
+        m_renderer->add_rectangle(bar_min, bar_max, outline_color);
 
         m_text_cursor_bottom.y += offset + height;
 
         return *this;
     }
 
-    EntityOverlay& EntityOverlay::add_bottom_label(const Color& color, const float offset, const widget::Outlined outlined,
-                                                   const std::string_view text)
+    EntityOverlay& EntityOverlay::add_bottom_label(const widget::Paint& color, const float offset,
+                                                   const widget::Outlined outlined, const std::string_view text,
+                                                   const std::optional<widget::Glow>& glow)
     {
         const auto text_size = m_renderer->calc_text_size(text);
 
-        if (outlined == widget::Outlined::On)
-            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);
+        draw_label(m_text_cursor_bottom + Vector2<float>{0.f, offset}, color, outlined, text, glow);
 
         m_text_cursor_bottom.y += text_size.y;
 
         return *this;
     }
 
-    EntityOverlay& EntityOverlay::add_left_label(const Color& color, const float offset, const widget::Outlined outlined,
-                                                 const std::string_view& text)
+    EntityOverlay& EntityOverlay::add_left_label(const widget::Paint& color, const float offset,
+                                                 const widget::Outlined outlined, const std::string_view& text,
+                                                 const std::optional<widget::Glow>& glow)
     {
         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 == widget::Outlined::On)
-            draw_outlined_text(pos, color, text);
-        else
-            m_renderer->add_text(pos, color, text);
+        draw_label(pos, color, outlined, text, glow);
 
         m_text_cursor_left.y += text_size.y;
 
         return *this;
     }
 
-    EntityOverlay& EntityOverlay::add_centered_bottom_label(const Color& color, const float offset, const widget::Outlined outlined,
-                                                            const std::string_view& text)
+    EntityOverlay& EntityOverlay::add_centered_bottom_label(const widget::Paint& color, const float offset,
+                                                            const widget::Outlined outlined,
+                                                            const std::string_view& text,
+                                                            const std::optional<widget::Glow>& glow)
     {
         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 == widget::Outlined::On)
-            draw_outlined_text(pos, color, text);
-        else
-            m_renderer->add_text(pos, color, text);
+        draw_label(pos, color, outlined, text, glow);
 
         m_text_cursor_bottom.y += text_size.y;
 
         return *this;
     }
 
-    EntityOverlay& EntityOverlay::add_centered_top_label(const Color& color, const float offset, const widget::Outlined outlined,
-                                                         const std::string_view& text)
+    EntityOverlay& EntityOverlay::add_centered_top_label(const widget::Paint& color, const float offset,
+                                                         const widget::Outlined outlined, const std::string_view& text,
+                                                         const std::optional<widget::Glow>& glow)
     {
         const auto text_size = m_renderer->calc_text_size(text);
         const auto box_center_x =
@@ -452,10 +662,7 @@ namespace omath::hud
         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 == widget::Outlined::On)
-            draw_outlined_text(pos, color, text);
-        else
-            m_renderer->add_text(pos, color, text);
+        draw_label(pos, color, outlined, text, glow);
 
         return *this;
     }
@@ -601,11 +808,43 @@ namespace omath::hud
     // ── widget dispatch ───────────────────────────────────────────────────────
     void EntityOverlay::dispatch(const widget::Box& box)
     {
-        add_2d_box(box.color, box.fill, box.outline, box.thickness);
+        if (box.glow)
+        {
+            const auto points = m_canvas.as_array();
+            draw_glow_polyline(points, *box.glow, box.thickness);
+        }
+        std::visit(
+                [&](const auto& fill)
+                {
+                    add_2d_box(box.color, fill, box.outline, box.thickness);
+                },
+                box.fill);
+    }
+
+    void EntityOverlay::dispatch(const widget::CanvasGlow& canvas_glow)
+    {
+        draw_canvas_glow(canvas_glow);
     }
 
     void EntityOverlay::dispatch(const widget::CorneredBox& cornered_box)
     {
+        if (cornered_box.glow)
+        {
+            const float length =
+                    std::abs(m_canvas.top_left_corner.x - m_canvas.top_right_corner.x) * cornered_box.corner_ratio;
+            const std::array lines = {
+                    std::pair{m_canvas.top_left_corner, m_canvas.top_left_corner + Vector2<float>{length, 0.f}},
+                    std::pair{m_canvas.top_left_corner, m_canvas.top_left_corner + Vector2<float>{0.f, length}},
+                    std::pair{m_canvas.bottom_left_corner, m_canvas.bottom_left_corner - Vector2<float>{0.f, length}},
+                    std::pair{m_canvas.bottom_left_corner, m_canvas.bottom_left_corner + Vector2<float>{length, 0.f}},
+                    std::pair{m_canvas.top_right_corner, m_canvas.top_right_corner - Vector2<float>{length, 0.f}},
+                    std::pair{m_canvas.top_right_corner, m_canvas.top_right_corner + Vector2<float>{0.f, length}},
+                    std::pair{m_canvas.bottom_right_corner, m_canvas.bottom_right_corner - Vector2<float>{0.f, length}},
+                    std::pair{m_canvas.bottom_right_corner, m_canvas.bottom_right_corner - Vector2<float>{length, 0.f}},
+            };
+            for (const auto& [from, to] : lines)
+                draw_glow_line(from, to, *cornered_box.glow, cornered_box.thickness);
+        }
         add_cornered_2d_box(cornered_box.color, cornered_box.fill, cornered_box.outline, cornered_box.corner_ratio,
                             cornered_box.thickness);
     }
@@ -617,7 +856,10 @@ namespace omath::hud
 
     void EntityOverlay::dispatch(const widget::Skeleton& skeleton)
     {
+        if (skeleton.bones.empty())
             add_skeleton(skeleton.color, skeleton.thickness);
+        else
+            add_skeleton(skeleton.bones, skeleton.color, skeleton.thickness);
     }
 
     void EntityOverlay::dispatch(const widget::SnapLine& snap_line)
@@ -704,7 +946,7 @@ namespace omath::hud
                             },
                             [this](const widget::Bar& w)
                             {
-                                add_right_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset);
+                                add_right_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset, w.glow);
                             },
                             [this](const widget::DashedBar& w)
                             {
@@ -713,11 +955,12 @@ namespace omath::hud
                             },
                             [this](const widget::Label& w)
                             {
-                                add_right_label(w.color, w.offset, w.outlined, w.text);
+                                add_right_label(w.color, w.offset, w.outlined, w.text, w.glow);
                             },
                             [this](const widget::Centered<widget::Label>& w)
                             {
-                                add_right_label(w.child.color, w.child.offset, w.child.outlined, w.child.text);
+                                add_right_label(w.child.color, w.child.offset, w.child.outlined, w.child.text,
+                                                w.child.glow);
                             },
                             [this](const widget::SpaceVertical& w)
                             {
@@ -750,7 +993,7 @@ namespace omath::hud
                             },
                             [this](const widget::Bar& w)
                             {
-                                add_left_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset);
+                                add_left_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset, w.glow);
                             },
                             [this](const widget::DashedBar& w)
                             {
@@ -759,11 +1002,12 @@ namespace omath::hud
                             },
                             [this](const widget::Label& w)
                             {
-                                add_left_label(w.color, w.offset, w.outlined, w.text);
+                                add_left_label(w.color, w.offset, w.outlined, w.text, w.glow);
                             },
                             [this](const widget::Centered<widget::Label>& w)
                             {
-                                add_left_label(w.child.color, w.child.offset, w.child.outlined, w.child.text);
+                                add_left_label(w.child.color, w.child.offset, w.child.outlined, w.child.text,
+                                               w.child.glow);
                             },
                             [this](const widget::SpaceVertical& w)
                             {
@@ -796,7 +1040,7 @@ namespace omath::hud
                             },
                             [this](const widget::Bar& w)
                             {
-                                add_top_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset);
+                                add_top_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset, w.glow);
                             },
                             [this](const widget::DashedBar& w)
                             {
@@ -805,11 +1049,12 @@ namespace omath::hud
                             },
                             [this](const widget::Label& w)
                             {
-                                add_top_label(w.color, w.offset, w.outlined, w.text);
+                                add_top_label(w.color, w.offset, w.outlined, w.text, w.glow);
                             },
                             [this](const widget::Centered<widget::Label>& w)
                             {
-                                add_centered_top_label(w.child.color, w.child.offset, w.child.outlined, w.child.text);
+                                add_centered_top_label(w.child.color, w.child.offset, w.child.outlined, w.child.text,
+                                                       w.child.glow);
                             },
                             [this](const widget::SpaceVertical& w)
                             {
@@ -841,7 +1086,7 @@ namespace omath::hud
                             },
                             [this](const widget::Bar& w)
                             {
-                                add_bottom_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset);
+                                add_bottom_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset, w.glow);
                             },
                             [this](const widget::DashedBar& w)
                             {
@@ -850,12 +1095,12 @@ namespace omath::hud
                             },
                             [this](const widget::Label& w)
                             {
-                                add_bottom_label(w.color, w.offset, w.outlined, w.text);
+                                add_bottom_label(w.color, w.offset, w.outlined, w.text, w.glow);
                             },
                             [this](const widget::Centered<widget::Label>& w)
                             {
-                                add_centered_bottom_label(w.child.color, w.child.offset, w.child.outlined,
-                                                          w.child.text);
+                                add_centered_bottom_label(w.child.color, w.child.offset, w.child.outlined, w.child.text,
+                                                          w.child.glow);
                             },
                             [this](const widget::SpaceVertical& w)
                             {

source/hud/renderer_realizations/imgui_renderer.cpp

@@ -4,7 +4,9 @@
 #include "omath/hud/renderer_realizations/imgui_renderer.hpp"
 
 #ifdef OMATH_IMGUI_INTEGRATION
+#include <cmath>
 #include <imgui.h>
+#include <imgui_internal.h>
 
 namespace omath::hud
 {
@@ -25,6 +27,17 @@ namespace omath::hud
                                                     ImDrawFlags_Closed, thickness);
     }
 
+    void ImguiHudRenderer::add_polyline_clipped(const std::span<const Vector2<float>>& vertexes,
+                                                const Vector2<float>& clip_min, const Vector2<float>& clip_max,
+                                                const Color& color, const float thickness)
+    {
+        auto* draw_list = ImGui::GetBackgroundDrawList();
+        draw_list->PushClipRect(clip_min.to_im_vec2(), clip_max.to_im_vec2(), true);
+        draw_list->AddPolyline(reinterpret_cast<const ImVec2*>(vertexes.data()), static_cast<int>(vertexes.size()),
+                               color.to_im_color(), ImDrawFlags_Closed, thickness);
+        draw_list->PopClipRect();
+    }
+
     void ImguiHudRenderer::add_filled_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color)
     {
         ImGui::GetBackgroundDrawList()->AddConvexPolyFilled(reinterpret_cast<const ImVec2*>(vertexes.data()),
@@ -42,10 +55,19 @@ namespace omath::hud
         ImGui::GetBackgroundDrawList()->AddRectFilled(min.to_im_vec2(), max.to_im_vec2(), color.to_im_color());
     }
 
+    void ImguiHudRenderer::add_gradient_rectangle(const Vector2<float>& min, const Vector2<float>& max,
+                                                  const Gradient& gradient)
+    {
+        ImGui::GetBackgroundDrawList()->AddRectFilledMultiColor(
+                min.to_im_vec2(), max.to_im_vec2(), gradient.top_left.to_im_color(), gradient.top_right.to_im_color(),
+                gradient.bottom_right.to_im_color(), gradient.bottom_left.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);
+        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,
@@ -54,8 +76,8 @@ namespace omath::hud
         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)
+    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);
@@ -73,6 +95,61 @@ namespace omath::hud
         ImGui::GetBackgroundDrawList()->AddText(position.to_im_vec2(), color.to_im_color(), text.data(),
                                                 text.data() + text.size());
     }
+
+    void ImguiHudRenderer::add_gradient_text(const Vector2<float>& position, const Gradient& gradient,
+                                             const std::string_view& text)
+    {
+        auto* draw_list = ImGui::GetBackgroundDrawList();
+        if (gradient.animated)
+        {
+            const float animation_offset = static_cast<float>(ImGui::GetTime()) * gradient.animation_speed;
+            const float direction = gradient.direction == GradientDirection::RightToLeft ? 1.f : -1.f;
+            float cursor_x = position.x;
+            const char* glyph_start = text.data();
+            const char* const text_end = text.data() + text.size();
+            int glyph_index = 0;
+            while (glyph_start < text_end)
+            {
+                unsigned int codepoint;
+                const int glyph_size = ImTextCharFromUtf8(&codepoint, glyph_start, text_end);
+                if (glyph_size <= 0)
+                    break;
+                static_cast<void>(codepoint);
+
+                const char* const glyph_end = glyph_start + glyph_size;
+                const float blend =
+                        (std::sin(animation_offset + direction * static_cast<float>(glyph_index)
+                                                             * gradient.animation_spread)
+                         + 1.f)
+                        * 0.5f;
+                const auto color = gradient.top_left.value() * (1.f - blend) + gradient.top_right.value() * blend;
+                draw_list->AddText({cursor_x, position.y}, Color{color}.to_im_color(), glyph_start, glyph_end);
+                cursor_x += ImGui::CalcTextSize(glyph_start, glyph_end).x;
+                glyph_start = glyph_end;
+                ++glyph_index;
+            }
+            return;
+        }
+
+        const int vertex_start = draw_list->VtxBuffer.Size;
+        draw_list->AddText(position.to_im_vec2(), IM_COL32_WHITE, text.data(), text.data() + text.size());
+
+        const auto size = calc_text_size(text);
+        const float width = std::max(size.x, 1.f);
+        const float height = std::max(size.y, 1.f);
+        for (int i = vertex_start; i < draw_list->VtxBuffer.Size; ++i)
+        {
+            auto& vertex = draw_list->VtxBuffer[i];
+            const float x = std::clamp((vertex.pos.x - position.x) / width, 0.f, 1.f);
+            const float y = std::clamp((vertex.pos.y - position.y) / height, 0.f, 1.f);
+            const auto top = gradient.top_left.value() * (1.f - x) + gradient.top_right.value() * x;
+            const auto bottom = gradient.bottom_left.value() * (1.f - x) + gradient.bottom_right.value() * x;
+            const auto color = top * (1.f - y) + bottom * y;
+            const auto alpha = static_cast<int>(((vertex.col >> IM_COL32_A_SHIFT) & 0xff) * color.w);
+            vertex.col = IM_COL32(static_cast<int>(color.x * 255.f), static_cast<int>(color.y * 255.f),
+                                  static_cast<int>(color.z * 255.f), alpha);
+        }
+    }
     [[nodiscard]]
     Vector2<float> ImguiHudRenderer::calc_text_size(const std::string_view& text)
     {

source/lua/lua_collision.cpp

@@ -119,11 +119,11 @@ namespace
         switch (axis)
         {
         case omath::primitives::UpAxis::X:
-            return aabb.top<omath::primitives::UpAxis::X>();
+            return omath::primitives::Aabb<float, omath::primitives::UpAxis::X>{aabb.min, aabb.max}.top();
         case omath::primitives::UpAxis::Y:
-            return aabb.top<omath::primitives::UpAxis::Y>();
+            return aabb.top();
         case omath::primitives::UpAxis::Z:
-            return aabb.top<omath::primitives::UpAxis::Z>();
+            return omath::primitives::Aabb<float, omath::primitives::UpAxis::Z>{aabb.min, aabb.max}.top();
         }
         std::unreachable();
     }
@@ -133,11 +133,11 @@ namespace
         switch (axis)
         {
         case omath::primitives::UpAxis::X:
-            return aabb.bottom<omath::primitives::UpAxis::X>();
+            return omath::primitives::Aabb<float, omath::primitives::UpAxis::X>{aabb.min, aabb.max}.bottom();
         case omath::primitives::UpAxis::Y:
-            return aabb.bottom<omath::primitives::UpAxis::Y>();
+            return aabb.bottom();
         case omath::primitives::UpAxis::Z:
-            return aabb.bottom<omath::primitives::UpAxis::Z>();
+            return omath::primitives::Aabb<float, omath::primitives::UpAxis::Z>{aabb.min, aabb.max}.bottom();
         }
         std::unreachable();
     }

source/lua/lua_engine_cry.cpp

@@ -0,0 +1,13 @@
+#ifdef OMATH_ENABLE_LUA
+#include "lua_engines_detail.hpp"
+#include <omath/engines/cry_engine/camera.hpp>
+
+namespace omath::lua::detail
+{
+    void register_cry_engine(sol::table& omath_table)
+    {
+        register_engine<omath::cry_engine::Camera, omath::cry_engine::PitchAngle, omath::cry_engine::ViewAngles>(
+                omath_table, "cry");
+    }
+} // namespace omath::lua::detail
+#endif

source/lua/lua_engine_frostbite.cpp

@@ -0,0 +1,13 @@
+#ifdef OMATH_ENABLE_LUA
+#include "lua_engines_detail.hpp"
+#include <omath/engines/frostbite_engine/camera.hpp>
+
+namespace omath::lua::detail
+{
+    void register_frostbite_engine(sol::table& omath_table)
+    {
+        register_engine<omath::frostbite_engine::Camera, omath::frostbite_engine::PitchAngle,
+                        omath::frostbite_engine::ViewAngles>(omath_table, "frostbite");
+    }
+} // namespace omath::lua::detail
+#endif

source/lua/lua_engine_iw.cpp

@@ -0,0 +1,13 @@
+#ifdef OMATH_ENABLE_LUA
+#include "lua_engines_detail.hpp"
+#include <omath/engines/iw_engine/camera.hpp>
+
+namespace omath::lua::detail
+{
+    void register_iw_engine(sol::table& omath_table)
+    {
+        register_engine<omath::iw_engine::Camera, omath::iw_engine::PitchAngle, omath::iw_engine::ViewAngles>(
+                omath_table, "iw");
+    }
+} // namespace omath::lua::detail
+#endif

source/lua/lua_engine_opengl.cpp

@@ -0,0 +1,13 @@
+#ifdef OMATH_ENABLE_LUA
+#include "lua_engines_detail.hpp"
+#include <omath/engines/opengl_engine/camera.hpp>
+
+namespace omath::lua::detail
+{
+    void register_opengl_engine(sol::table& omath_table)
+    {
+        register_engine<omath::opengl_engine::Camera, omath::opengl_engine::PitchAngle,
+                        omath::opengl_engine::ViewAngles>(omath_table, "opengl");
+    }
+} // namespace omath::lua::detail
+#endif

source/lua/lua_engine_rage.cpp

@@ -0,0 +1,13 @@
+#ifdef OMATH_ENABLE_LUA
+#include "lua_engines_detail.hpp"
+#include <omath/engines/rage_engine/camera.hpp>
+
+namespace omath::lua::detail
+{
+    void register_rage_engine(sol::table& omath_table)
+    {
+        register_engine<omath::rage_engine::Camera, omath::rage_engine::PitchAngle, omath::rage_engine::ViewAngles>(
+                omath_table, "rage");
+    }
+} // namespace omath::lua::detail
+#endif

source/lua/lua_engine_source.cpp

@@ -0,0 +1,13 @@
+#ifdef OMATH_ENABLE_LUA
+#include "lua_engines_detail.hpp"
+#include <omath/engines/source_engine/camera.hpp>
+
+namespace omath::lua::detail
+{
+    void register_source_engine(sol::table& omath_table)
+    {
+        register_engine<omath::source_engine::Camera, omath::source_engine::PitchAngle,
+                        omath::source_engine::ViewAngles>(omath_table, "source");
+    }
+} // namespace omath::lua::detail
+#endif