5.5.2

.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:
@@ -455,32 +458,36 @@ jobs:
         with:
           submodules: recursive
 
-      - name: Build and Test
-        uses: cross-platform-actions/action@v0.31.0
+      - name: Start FreeBSD VM
+        uses: cross-platform-actions/action@v1.3.0
         with:
           operating_system: freebsd
           architecture: ${{ matrix.arch }}
           version: '15.0'
           memory: '12G'
           cpu_count: 4
-          run: |
-            sudo pkg install -y git curl zip unzip gmake llvm gsed bash perl5 openssl 7-zip coreutils cmake ninja pkgconf patchelf
-            git config --global --add safe.directory `pwd`
-            # Build vcpkg in /tmp to avoid sshfs timestamp sync issues
-            export VCPKG_ROOT=/tmp/vcpkg
-            rm -rf "$VCPKG_ROOT"
-            git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
-            cd "$VCPKG_ROOT"
-            ./bootstrap-vcpkg.sh
-            cd -
-            export VCPKG_FORCE_SYSTEM_BINARIES=0
-            cmake --preset ${{ matrix.preset }} \
-              -DOMATH_BUILD_TESTS=ON \
-              -DOMATH_BUILD_BENCHMARK=OFF \
-              -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua" \
-              -DVCPKG_INSTALL_OPTIONS="--allow-unsupported"
-            cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
-            ./out/Release/unit_tests
+
+      - name: Build and Test
+        shell: cpa.sh {0}
+        run: |
+          sudo pkg install -y git curl zip unzip gmake llvm gsed bash perl5 openssl 7-zip coreutils cmake ninja pkgconf patchelf
+          git config --global --add safe.directory `pwd`
+          # Build vcpkg in /tmp to avoid sshfs timestamp sync issues
+          export VCPKG_ROOT=/tmp/vcpkg
+          rm -rf "$VCPKG_ROOT"
+          # FreeBSD 15 packages CMake 3.31; newer vcpkg requires CMake 4.3.
+          git clone --branch 2026.06.24 --depth 1 https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+          cd -
+          export VCPKG_FORCE_SYSTEM_BINARIES=0
+          cmake --preset ${{ matrix.preset }} \
+            -DOMATH_BUILD_TESTS=ON \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2;tests;lua" \
+            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported"
+          cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
+          ./out/Release/unit_tests
 
       - name: Upload logs on failure
         if: ${{ failure() }}
@@ -706,8 +713,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:
@@ -372,33 +375,37 @@ jobs:
         with:
           submodules: recursive
 
-      - name: Build and Package
-        uses: cross-platform-actions/action@v0.31.0
+      - name: Start FreeBSD VM
+        uses: cross-platform-actions/action@v1.3.0
         with:
           operating_system: freebsd
           architecture: ${{ matrix.arch }}
           version: '15.0'
           memory: '12G'
           cpu_count: 4
-          run: |
-            sudo pkg install -y git curl zip unzip gmake llvm gsed bash perl5 openssl 7-zip coreutils cmake ninja pkgconf patchelf
-            git config --global --add safe.directory `pwd`
-            # Build vcpkg in /tmp to avoid sshfs timestamp sync issues
-            export VCPKG_ROOT=/tmp/vcpkg
-            rm -rf "$VCPKG_ROOT"
-            git clone https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
-            cd "$VCPKG_ROOT"
-            ./bootstrap-vcpkg.sh
-            cd -
-            export VCPKG_FORCE_SYSTEM_BINARIES=0
-            cmake --preset ${{ matrix.preset }} \
-              -DOMATH_BUILD_TESTS=OFF \
-              -DOMATH_BUILD_BENCHMARK=OFF \
-              -DVCPKG_MANIFEST_FEATURES="imgui;avx2" \
-              -DVCPKG_INSTALL_OPTIONS="--allow-unsupported"
-            cmake --build cmake-build/build/${{ matrix.preset }} --target omath
-            cmake --install cmake-build/build/${{ matrix.preset }} --prefix staging
-            tar -czf ${{ matrix.archive }}.tar.gz -C staging .
+
+      - name: Build and Package
+        shell: cpa.sh {0}
+        run: |
+          sudo pkg install -y git curl zip unzip gmake llvm gsed bash perl5 openssl 7-zip coreutils cmake ninja pkgconf patchelf
+          git config --global --add safe.directory `pwd`
+          # Build vcpkg in /tmp to avoid sshfs timestamp sync issues
+          export VCPKG_ROOT=/tmp/vcpkg
+          rm -rf "$VCPKG_ROOT"
+          # FreeBSD 15 packages CMake 3.31; newer vcpkg requires CMake 4.3.
+          git clone --branch 2026.06.24 --depth 1 https://github.com/microsoft/vcpkg "$VCPKG_ROOT"
+          cd "$VCPKG_ROOT"
+          ./bootstrap-vcpkg.sh
+          cd -
+          export VCPKG_FORCE_SYSTEM_BINARIES=0
+          cmake --preset ${{ matrix.preset }} \
+            -DOMATH_BUILD_TESTS=OFF \
+            -DOMATH_BUILD_BENCHMARK=OFF \
+            -DVCPKG_MANIFEST_FEATURES="imgui;avx2" \
+            -DVCPKG_INSTALL_OPTIONS="--allow-unsupported"
+          cmake --build cmake-build/build/${{ matrix.preset }} --target omath
+          cmake --install cmake-build/build/${{ matrix.preset }} --prefix staging
+          tar -czf ${{ matrix.archive }}.tar.gz -C staging .
 
       - name: Upload release asset
         env:

VERSION

@@ -1 +1 @@
-5.5.1
+5.5.2

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

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_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,6 +14,8 @@ bool show_menu = true;
 
 namespace
 {
+    constexpr UINT srv_heap_size = 64;
+
     struct frame_context
     {
         ID3D12Resource* render_target = nullptr;
@@ -27,15 +30,95 @@ 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;
     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 allocate_srv_descriptor(ImGui_ImplDX12_InitInfo*, D3D12_CPU_DESCRIPTOR_HANDLE* cpu_handle,
+                                 D3D12_GPU_DESCRIPTOR_HANDLE* gpu_handle)
+    {
+        IM_ASSERT(!g_free_srv_indices.empty());
+        const UINT index = g_free_srv_indices.back();
+        g_free_srv_indices.pop_back();
+
+        *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;
+
+        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()
     {
@@ -215,25 +298,62 @@ namespace
 
     void init(IDXGISwapChain* swap_chain)
     {
-        g_init_attempted = true;
-
-        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&g_swap_chain))))
+        IDXGISwapChain3* swap_chain3 = nullptr;
+        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&swap_chain3))))
             return;
 
-        if (FAILED(swap_chain->GetDevice(IID_PPV_ARGS(&g_device))))
+        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{};
-        swap_chain->GetDesc(&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 = buffer_count;
+            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))
@@ -252,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();
@@ -264,8 +392,10 @@ namespace
                     if (!show_menu)
                         return std::nullopt;
 
-                    ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp);
-                    return true;
+                    if (ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp))
+                        return true;
+
+                    return std::nullopt;
                 });
         std::ignore = mgr.hook_wnd_proc(desc.OutputWindow);
 
@@ -274,13 +404,8 @@ namespace
 
     void on_execute_command_lists(ID3D12CommandQueue* queue, UINT, ID3D12CommandList* const*)
     {
-        // The overlay records DIRECT command lists; executing them on COPY/COMPUTE queues can remove the device.
-        if (!g_command_queue)
-        {
-            const D3D12_COMMAND_QUEUE_DESC desc = queue->GetDesc();
-            if (desc.Type == D3D12_COMMAND_LIST_TYPE_DIRECT)
-                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);
     }
 
     bool ensure_initialized(IDXGISwapChain* swap_chain)
@@ -288,7 +413,7 @@ namespace
         if (g_initialized)
             return true;
 
-        if (!g_init_attempted && g_command_queue)
+        if (!g_init_attempted)
             init(swap_chain);
 
         return false;
@@ -402,6 +527,9 @@ namespace
 
     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;
 
@@ -413,8 +541,11 @@ namespace
         std::ignore = submit_overlay_commands(*fc);
     }
 
-    void on_resize_buffers(IDXGISwapChain*, UINT, UINT, UINT, DXGI_FORMAT, UINT)
+    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();
@@ -431,16 +562,36 @@ namespace
             g_srv_heap->Release();
             g_srv_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
 

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

@@ -4,7 +4,6 @@
 
 #pragma once
 #include "omath/engines/cry_engine/formulas.hpp"
-#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 namespace omath::cry_engine
 {
@@ -16,8 +15,8 @@ namespace omath::cry_engine
                                                        const Vector3<float>& look_at) noexcept
         {
             const auto direction = (look_at - cam_origin).normalized();
-            return {PitchAngle::from_radians(internal::asin(direction.z)),
-                    YawAngle::from_radians(-internal::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)};
+            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")]]

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

@@ -4,7 +4,6 @@
 
 #pragma once
 #include "omath/engines/frostbite_engine/formulas.hpp"
-#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::frostbite_engine
@@ -18,8 +17,8 @@ namespace omath::frostbite_engine
         {
             const auto direction = (look_at - cam_origin).normalized();
 
-            return {PitchAngle::from_radians(-internal::asin(direction.y)),
-                    YawAngle::from_radians(internal::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)};
+            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")]]

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

@@ -4,7 +4,6 @@
 
 #pragma once
 #include "omath/engines/iw_engine/formulas.hpp"
-#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::iw_engine
@@ -18,8 +17,8 @@ namespace omath::iw_engine
         {
             const auto direction = (look_at - cam_origin).normalized();
 
-            return {PitchAngle::from_radians(-internal::asin(direction.z)),
-                    YawAngle::from_radians(internal::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
+            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")]]

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

@@ -4,7 +4,6 @@
 
 #pragma once
 #include "omath/engines/opengl_engine/formulas.hpp"
-#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::opengl_engine
@@ -18,8 +17,8 @@ namespace omath::opengl_engine
         {
             const auto direction = (look_at - cam_origin).normalized();
 
-            return {PitchAngle::from_radians(internal::asin(direction.y)),
-                    YawAngle::from_radians(-internal::atan2(direction.x, -direction.z)), RollAngle::from_radians(0.f)};
+            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")]]

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

@@ -4,7 +4,6 @@
 
 #pragma once
 #include "omath/engines/rage_engine/formulas.hpp"
-#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::rage_engine
@@ -18,8 +17,8 @@ namespace omath::rage_engine
         {
             const auto direction = (look_at - cam_origin).normalized();
 
-            return {PitchAngle::from_radians(internal::asin(direction.z)),
-                    YawAngle::from_radians(-internal::atan2(direction.x, direction.y)), RollAngle::from_radians(0.f)};
+            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")]]

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

@@ -4,7 +4,6 @@
 
 #pragma once
 #include "omath/engines/source_engine/formulas.hpp"
-#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::source_engine
@@ -18,8 +17,8 @@ namespace omath::source_engine
         {
             const auto direction = (look_at - cam_origin).normalized();
 
-            return {PitchAngle::from_radians(-internal::asin(direction.z)),
-                    YawAngle::from_radians(internal::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
+            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")]]

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

@@ -4,7 +4,6 @@
 
 #pragma once
 #include "omath/engines/unity_engine/formulas.hpp"
-#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::unity_engine
@@ -18,8 +17,8 @@ namespace omath::unity_engine
         {
             const auto direction = (look_at - cam_origin).normalized();
 
-            return {PitchAngle::from_radians(-internal::asin(direction.y)),
-                    YawAngle::from_radians(internal::atan2(direction.x, direction.z)), RollAngle::from_radians(0.f)};
+            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")]]

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

@@ -4,7 +4,6 @@
 
 #pragma once
 #include "omath/engines/unreal_engine/formulas.hpp"
-#include "omath/internal/constexpr_math.hpp"
 #include "omath/projection/camera.hpp"
 
 namespace omath::unreal_engine
@@ -18,8 +17,8 @@ namespace omath::unreal_engine
         {
             const auto direction = (look_at - cam_origin).normalized();
 
-            return {PitchAngle::from_radians(internal::asin(direction.z)),
-                    YawAngle::from_radians(internal::atan2(direction.y, direction.x)), RollAngle::from_radians(0.f)};
+            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")]]

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/gradient.hpp

@@ -9,7 +9,7 @@ namespace omath::hud
         LeftToRight,
     };
 
-    struct Gradient
+    struct Gradient final
     {
         Color top_left;
         Color top_right;

include/omath/linear_algebra/mat.hpp

@@ -186,7 +186,14 @@ namespace omath
                 else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
                     return cache_friendly_multiply_col_major(other);
             }
-            if constexpr (StoreType == MatStoreType::ROW_MAJOR)
+            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);
@@ -429,13 +436,22 @@ 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;
         }
 
@@ -444,13 +460,22 @@ 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;
         }
 #ifdef OMATH_USE_AVX2
@@ -466,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);
-                    for (std::size_t k = 0; k < Columns; ++k)
+                    std::size_t i = 0;
+                    for (; i + block_size <= Rows; i += block_size)
                     {
-                        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;
-                        for (; i + vector_size <= Rows; i += vector_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)
                         {
-                            __m256 cvec = _mm256_loadu_ps(c_col + i);
+                            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_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;
+                        _mm256_storeu_ps(c_col + i, cvec);
                     }
+                    for (; i < Rows; ++i)
+                        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);
-                    for (std::size_t k = 0; k < Columns; ++k)
+                    std::size_t i = 0;
+                    for (; i + block_size <= Rows; i += block_size)
                     {
-                        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;
-                        for (; i + vector_size <= Rows; i += vector_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)
                         {
-                            __m256d cvec = _mm256_loadu_pd(c_col + i);
+                            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_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;
+                        _mm256_storeu_pd(c_col + i, cvec);
                     }
+                    for (; i < Rows; ++i)
+                        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
@@ -536,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;
-                    for (std::size_t k = 0; k < Columns; ++k)
+                    auto* c_row = reinterpret_cast<float*>(result_mat_data + i * OtherColumns);
+                    std::size_t j = 0;
+                    for (; j + block_size <= OtherColumns; j += block_size)
                     {
-                        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;
-                        for (; j + vector_size <= OtherColumns; j += vector_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)
                         {
-                            __m256 cvec = _mm256_loadu_ps(c_row + j);
+                            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_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];
+                        _mm256_storeu_ps(c_row + j, cvec);
                     }
+                    for (; j < OtherColumns; ++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;
-                    for (std::size_t k = 0; k < Columns; ++k)
+                    auto* c_row = reinterpret_cast<double*>(result_mat_data + i * OtherColumns);
+                    std::size_t j = 0;
+                    for (; j + block_size <= OtherColumns; j += block_size)
                     {
-                        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;
-                        for (; j + vector_size <= OtherColumns; j += vector_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)
                         {
-                            __m256d cvec = _mm256_loadu_pd(c_row + j);
+                            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_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];
+                        _mm256_storeu_pd(c_row + j, cvec);
                     }
+                    for (; j < OtherColumns; ++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

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/trigonometry/angle.hpp

@@ -6,7 +6,9 @@
 #include "omath/internal/constexpr_math.hpp"
 #include "omath/trigonometry/angles.hpp"
 #include <algorithm>
+#include <compare>
 #include <format>
+#include <type_traits>
 #include <utility>
 
 namespace omath
@@ -18,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;
@@ -43,7 +45,7 @@ namespace omath
         {
             return Angle{degrees};
         }
-        constexpr Angle() noexcept: m_angle(0)
+        constexpr Angle() noexcept: Angle(Type{0})
         {
         }
         [[nodiscard]]
@@ -52,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
         {
@@ -88,12 +114,6 @@ namespace omath
             return internal::tan(as_radians());
         }
 
-        [[nodiscard]]
-        constexpr Type atan() const noexcept
-        {
-            return internal::atan(as_radians());
-        }
-
         [[nodiscard]]
         constexpr Type cot() const noexcept
         {
@@ -121,7 +141,8 @@ namespace omath
 
         constexpr Angle& operator-=(const Angle& other) noexcept
         {
-            return operator+=(-other);
+            *this = Angle{m_angle - other.m_angle};
+            return *this;
         }
 
         [[nodiscard]]
@@ -142,7 +163,7 @@ namespace omath
         [[nodiscard]]
         constexpr Angle operator-(const Angle& other) const noexcept
         {
-            return operator+(-other);
+            return Angle{m_angle - other.m_angle};
         }
 
         [[nodiscard]]
@@ -172,7 +193,6 @@ struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char> final // NOLINT(*-dc
         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> final // NOLINT(*-dcl58-cpp)
@@ -193,24 +213,3 @@ struct std::formatter<omath::Angle<T, MinV, MaxV, F>, wchar_t> final // NOLINT(*
         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> 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();
-    }
-
-    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

@@ -48,10 +48,10 @@ namespace omath::angles
     }
 
     template<class Type>
-    requires std::is_arithmetic_v<Type>
+    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;

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

source/lua/lua_engine_unity.cpp

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

source/lua/lua_engine_unreal.cpp

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

source/lua/lua_engines.cpp

@@ -2,269 +2,75 @@
 // Created by orange on 07.03.2026.
 //
 #ifdef OMATH_ENABLE_LUA
-#include "omath/lua/lua.hpp"
-#include "omath/omath.hpp"
-#include "omath/projection/error_codes.hpp"
-#include <omath/engines/cry_engine/camera.hpp>
-#include <omath/engines/frostbite_engine/camera.hpp>
-#include <omath/engines/iw_engine/camera.hpp>
-#include <omath/engines/opengl_engine/camera.hpp>
-#include <omath/engines/rage_engine/camera.hpp>
-#include <omath/engines/source_engine/camera.hpp>
-#include <omath/engines/unity_engine/camera.hpp>
-#include <omath/engines/unreal_engine/camera.hpp>
-#include <sol/sol.hpp>
-#include <string_view>
-#include <type_traits>
-#include <utility>
-
-namespace
-{
-    // ---- Canonical shared C++ type aliases ----------------------------------
-    // Each unique template instantiation must be registered exactly once.
-
-    using PitchAngle90 = omath::Angle<float, -90.f, 90.f, omath::AngleFlags::Clamped>;
-    using PitchAngle89 = omath::Angle<float, -89.f, 89.f, omath::AngleFlags::Clamped>;
-    using SharedYawRoll = omath::Angle<float, -180.f, 180.f, omath::AngleFlags::Normalized>;
-    using SharedFoV = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>;
-    using ViewAngles90 = omath::ViewAngles<PitchAngle90, SharedYawRoll, SharedYawRoll>;
-    using ViewAngles89 = omath::ViewAngles<PitchAngle89, SharedYawRoll, SharedYawRoll>;
-
-    std::string projection_error_to_string(omath::projection::Error e)
-    {
-        switch (e)
-        {
-        case omath::projection::Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS:
-            return "world position is out of screen bounds";
-        case omath::projection::Error::INV_VIEW_PROJ_MAT_DET_EQ_ZERO:
-            return "inverse view-projection matrix determinant is zero";
-        case omath::projection::Error::PERSPECTIVE_DIVIDER_LESS_EQ_ZERO:
-            return "perspective divider is less or equal to zero";
-        }
-        return "unknown error";
-    }
-
-    template<class AngleType>
-    void register_angle(sol::table& table, const char* name)
-    {
-        table.new_usertype<AngleType>(
-                name, sol::no_constructor, "from_degrees", &AngleType::from_degrees, "from_radians",
-                &AngleType::from_radians, "as_degrees", &AngleType::as_degrees, "as_radians", &AngleType::as_radians,
-                "sin", &AngleType::sin, "cos", &AngleType::cos, "tan", &AngleType::tan, "cot", &AngleType::cot,
-                sol::meta_function::addition, [](const AngleType& a, const AngleType& b)
-                { return AngleType::from_degrees(a.as_degrees() + b.as_degrees()); }, sol::meta_function::subtraction,
-                [](const AngleType& a, const AngleType& b)
-                { return AngleType::from_degrees(a.as_degrees() - b.as_degrees()); }, sol::meta_function::unary_minus,
-                [](const AngleType& a) { return AngleType::from_degrees(-a.as_degrees()); },
-                sol::meta_function::equal_to, [](const AngleType& a, const AngleType& b) { return a == b; },
-                sol::meta_function::to_string, [](const AngleType& a) { return std::format("{}deg", a.as_degrees()); });
-    }
-
-    // Set aliases in an engine subtable pointing to the already-registered shared types
-    template<class PitchAngleType, class ViewAnglesType>
-    void set_engine_aliases(sol::table& engine_table, sol::table& types)
-    {
-        if constexpr (std::is_same_v<PitchAngleType, PitchAngle90>)
-            engine_table["PitchAngle"] = types["PitchAngle90"];
-        else
-            engine_table["PitchAngle"] = types["PitchAngle89"];
-
-        engine_table["YawAngle"] = types["YawRoll"];
-        engine_table["RollAngle"] = types["YawRoll"];
-        engine_table["FieldOfView"] = types["FieldOfView"];
-        engine_table["ViewPort"] = types["ViewPort"];
-
-        if constexpr (std::is_same_v<ViewAnglesType, ViewAngles90>)
-            engine_table["ViewAngles"] = types["ViewAngles90"];
-        else
-            engine_table["ViewAngles"] = types["ViewAngles89"];
-    }
-
-    // Register an engine: alias shared types, register unique Camera
-    template<class EngineTraits, class ArithmeticType = float>
-    requires std::is_arithmetic_v<ArithmeticType>
-    void register_engine(sol::table& omath_table, const char* subtable_name)
-    {
-        using PitchAngle = typename EngineTraits::PitchAngle;
-        using ViewAngles = typename EngineTraits::ViewAngles;
-        using Camera = typename EngineTraits::Camera;
-        using Mat4X4 = std::remove_cvref_t<decltype(std::declval<const Camera&>().get_view_matrix())>;
-
-        auto engine_table = omath_table[subtable_name].get_or_create<sol::table>();
-        auto types = omath_table["_types"].get<sol::table>();
-
-        set_engine_aliases<PitchAngle, ViewAngles>(engine_table, types);
-
-        auto camera_type = engine_table.new_usertype<Camera>(
-                "Camera",
-                sol::constructors<Camera(const omath::Vector3<ArithmeticType>&, const ViewAngles&,
-                                         const omath::projection::ViewPort&, const omath::projection::FieldOfView&,
-                                         ArithmeticType, ArithmeticType)>());
-
-        camera_type["look_at"] = &Camera::look_at;
-        camera_type["get_forward"] = &Camera::get_forward;
-        camera_type["get_right"] = &Camera::get_right;
-        camera_type["get_up"] = &Camera::get_up;
-        camera_type["get_origin"] = &Camera::get_origin;
-        camera_type["get_view_angles"] = &Camera::get_view_angles;
-        camera_type["get_near_plane"] = &Camera::get_near_plane;
-        camera_type["get_far_plane"] = &Camera::get_far_plane;
-        camera_type["get_field_of_view"] = &Camera::get_field_of_view;
-        camera_type["set_origin"] = &Camera::set_origin;
-        camera_type["set_view_angles"] = &Camera::set_view_angles;
-        camera_type["set_view_port"] = &Camera::set_view_port;
-        camera_type["set_field_of_view"] = &Camera::set_field_of_view;
-        camera_type["set_near_plane"] = &Camera::set_near_plane;
-        camera_type["set_far_plane"] = &Camera::set_far_plane;
-
-        camera_type["get_view_matrix"] = [](const Camera& cam) -> Mat4X4
-        {
-            return cam.get_view_matrix();
-        };
-        camera_type["get_projection_matrix"] = [](const Camera& cam) -> Mat4X4
-        {
-            return cam.get_projection_matrix();
-        };
-        camera_type["get_view_projection_matrix"] = [](const Camera& cam) -> Mat4X4
-        {
-            return cam.get_view_projection_matrix();
-        };
-        camera_type["extract_projection_params"] = [](const Mat4X4& projection_matrix)
-        {
-            const auto params = Camera::extract_projection_params(projection_matrix);
-            return std::make_tuple(params.fov, params.aspect_ratio);
-        };
-        camera_type["calc_view_angles_from_view_matrix"] = &Camera::calc_view_angles_from_view_matrix;
-        camera_type["calc_origin_from_view_matrix"] = &Camera::calc_origin_from_view_matrix;
-
-        camera_type["world_to_screen"] = [](const Camera& cam, const omath::Vector3<ArithmeticType>& pos)
-                -> std::tuple<sol::optional<omath::Vector3<ArithmeticType>>, sol::optional<std::string>>
-        {
-            auto result = cam.world_to_screen(pos);
-            if (result)
-                return {*result, sol::nullopt};
-            return {sol::nullopt, projection_error_to_string(result.error())};
-        };
-
-        camera_type["screen_to_world"] = [](const Camera& cam, const omath::Vector3<ArithmeticType>& pos)
-                -> std::tuple<sol::optional<omath::Vector3<ArithmeticType>>, sol::optional<std::string>>
-        {
-            auto result = cam.screen_to_world(pos);
-            if (result)
-                return {*result, sol::nullopt};
-            return {sol::nullopt, projection_error_to_string(result.error())};
-        };
-    }
-
-    // ---- Engine trait structs -----------------------------------------------
-
-    struct OpenGLEngineTraits
-    {
-        using PitchAngle = omath::opengl_engine::PitchAngle;
-        using ViewAngles = omath::opengl_engine::ViewAngles;
-        using Camera = omath::opengl_engine::Camera;
-    };
-    struct FrostbiteEngineTraits
-    {
-        using PitchAngle = omath::frostbite_engine::PitchAngle;
-        using ViewAngles = omath::frostbite_engine::ViewAngles;
-        using Camera = omath::frostbite_engine::Camera;
-    };
-    struct IWEngineTraits
-    {
-        using PitchAngle = omath::iw_engine::PitchAngle;
-        using ViewAngles = omath::iw_engine::ViewAngles;
-        using Camera = omath::iw_engine::Camera;
-    };
-    struct SourceEngineTraits
-    {
-        using PitchAngle = omath::source_engine::PitchAngle;
-        using ViewAngles = omath::source_engine::ViewAngles;
-        using Camera = omath::source_engine::Camera;
-    };
-    struct RageEngineTraits
-    {
-        using PitchAngle = omath::rage_engine::PitchAngle;
-        using ViewAngles = omath::rage_engine::ViewAngles;
-        using Camera = omath::rage_engine::Camera;
-    };
-    struct UnityEngineTraits
-    {
-        using PitchAngle = omath::unity_engine::PitchAngle;
-        using ViewAngles = omath::unity_engine::ViewAngles;
-        using Camera = omath::unity_engine::Camera;
-    };
-    struct UnrealEngineTraits
-    {
-        using PitchAngle = omath::unreal_engine::PitchAngle;
-        using ViewAngles = omath::unreal_engine::ViewAngles;
-        using Camera = omath::unreal_engine::Camera;
-    };
-    struct CryEngineTraits
-    {
-        using PitchAngle = omath::cry_engine::PitchAngle;
-        using ViewAngles = omath::cry_engine::ViewAngles;
-        using Camera = omath::cry_engine::Camera;
-    };
-} // namespace
+#include "lua_engines_detail.hpp"
 
 namespace omath::lua
 {
     void LuaInterpreter::register_shared_types(sol::table& omath_table)
     {
-        auto t = omath_table["_types"].get_or_create<sol::table>();
+        auto types = omath_table["_types"].get_or_create<sol::table>();
 
-        register_angle<PitchAngle90>(t, "PitchAngle90");
-        register_angle<PitchAngle89>(t, "PitchAngle89");
-        register_angle<SharedYawRoll>(t, "YawRoll");
-        register_angle<SharedFoV>(t, "FieldOfView");
+        detail::register_angle<detail::PitchAngle90>(types, "PitchAngle90");
+        detail::register_angle<detail::PitchAngle89>(types, "PitchAngle89");
+        detail::register_angle<detail::SharedYawRoll>(types, "YawRoll");
+        detail::register_angle<detail::SharedFoV>(types, "FieldOfView");
 
-        t.new_usertype<omath::projection::ViewPort>(
-                "ViewPort", sol::factories([](float w, float h) { return omath::projection::ViewPort{w, h}; }), "width",
-                sol::property([](const omath::projection::ViewPort& vp) { return vp.m_width; },
-                              [](omath::projection::ViewPort& vp, float val) { vp.m_width = val; }),
+        types.new_usertype<projection::ViewPort>(
+                "ViewPort",
+                sol::factories([](float width, float height) { return projection::ViewPort{width, height}; }),
+                "width",
+                sol::property([](const projection::ViewPort& view_port) { return view_port.m_width; },
+                              [](projection::ViewPort& view_port, float value) { view_port.m_width = value; }),
                 "height",
-                sol::property([](const omath::projection::ViewPort& vp) { return vp.m_height; },
-                              [](omath::projection::ViewPort& vp, float val) { vp.m_height = val; }),
-                "aspect_ratio", &omath::projection::ViewPort::aspect_ratio);
+                sol::property([](const projection::ViewPort& view_port) { return view_port.m_height; },
+                              [](projection::ViewPort& view_port, float value) { view_port.m_height = value; }),
+                "aspect_ratio", &projection::ViewPort::aspect_ratio);
 
-        t.new_usertype<ViewAngles90>(
+        types.new_usertype<detail::ViewAngles90>(
                 "ViewAngles90",
-                sol::factories([](PitchAngle90 p, SharedYawRoll y, SharedYawRoll r) { return ViewAngles90{p, y, r}; }),
+                sol::factories([](detail::PitchAngle90 pitch, detail::SharedYawRoll yaw, detail::SharedYawRoll roll)
+                               { return detail::ViewAngles90{pitch, yaw, roll}; }),
                 "pitch",
-                sol::property([](const ViewAngles90& va) { return va.pitch; },
-                              [](ViewAngles90& va, const PitchAngle90& val) { va.pitch = val; }),
+                sol::property([](const detail::ViewAngles90& view_angles) { return view_angles.pitch; },
+                              [](detail::ViewAngles90& view_angles, const detail::PitchAngle90& value)
+                              { view_angles.pitch = value; }),
                 "yaw",
-                sol::property([](const ViewAngles90& va) { return va.yaw; },
-                              [](ViewAngles90& va, const SharedYawRoll& val) { va.yaw = val; }),
+                sol::property([](const detail::ViewAngles90& view_angles) { return view_angles.yaw; },
+                              [](detail::ViewAngles90& view_angles, const detail::SharedYawRoll& value)
+                              { view_angles.yaw = value; }),
                 "roll",
-                sol::property([](const ViewAngles90& va) { return va.roll; },
-                              [](ViewAngles90& va, const SharedYawRoll& val) { va.roll = val; }));
+                sol::property([](const detail::ViewAngles90& view_angles) { return view_angles.roll; },
+                              [](detail::ViewAngles90& view_angles, const detail::SharedYawRoll& value)
+                              { view_angles.roll = value; }));
 
-        t.new_usertype<ViewAngles89>(
+        types.new_usertype<detail::ViewAngles89>(
                 "ViewAngles89",
-                sol::factories([](PitchAngle89 p, SharedYawRoll y, SharedYawRoll r) { return ViewAngles89{p, y, r}; }),
+                sol::factories([](detail::PitchAngle89 pitch, detail::SharedYawRoll yaw, detail::SharedYawRoll roll)
+                               { return detail::ViewAngles89{pitch, yaw, roll}; }),
                 "pitch",
-                sol::property([](const ViewAngles89& va) { return va.pitch; },
-                              [](ViewAngles89& va, const PitchAngle89& val) { va.pitch = val; }),
+                sol::property([](const detail::ViewAngles89& view_angles) { return view_angles.pitch; },
+                              [](detail::ViewAngles89& view_angles, const detail::PitchAngle89& value)
+                              { view_angles.pitch = value; }),
                 "yaw",
-                sol::property([](const ViewAngles89& va) { return va.yaw; },
-                              [](ViewAngles89& va, const SharedYawRoll& val) { va.yaw = val; }),
+                sol::property([](const detail::ViewAngles89& view_angles) { return view_angles.yaw; },
+                              [](detail::ViewAngles89& view_angles, const detail::SharedYawRoll& value)
+                              { view_angles.yaw = value; }),
                 "roll",
-                sol::property([](const ViewAngles89& va) { return va.roll; },
-                              [](ViewAngles89& va, const SharedYawRoll& val) { va.roll = val; }));
+                sol::property([](const detail::ViewAngles89& view_angles) { return view_angles.roll; },
+                              [](detail::ViewAngles89& view_angles, const detail::SharedYawRoll& value)
+                              { view_angles.roll = value; }));
     }
 
     void LuaInterpreter::register_engines(sol::table& omath_table)
     {
-        register_engine<OpenGLEngineTraits>(omath_table, "opengl");
-        register_engine<FrostbiteEngineTraits>(omath_table, "frostbite");
-        register_engine<IWEngineTraits>(omath_table, "iw");
-        register_engine<SourceEngineTraits>(omath_table, "source");
-        register_engine<RageEngineTraits>(omath_table, "rage");
-        register_engine<UnityEngineTraits>(omath_table, "unity");
-        register_engine<UnrealEngineTraits, double>(omath_table, "unreal");
-        register_engine<CryEngineTraits>(omath_table, "cry");
+        detail::register_opengl_engine(omath_table);
+        detail::register_frostbite_engine(omath_table);
+        detail::register_iw_engine(omath_table);
+        detail::register_source_engine(omath_table);
+        detail::register_rage_engine(omath_table);
+        detail::register_unity_engine(omath_table);
+        detail::register_unreal_engine(omath_table);
+        detail::register_cry_engine(omath_table);
     }
-} // namespace omath::lua::detail
+} // namespace omath::lua
 #endif

source/lua/lua_engines_detail.hpp

@@ -0,0 +1,142 @@
+#pragma once
+
+#include "omath/lua/lua.hpp"
+#include "omath/projection/camera.hpp"
+#include "omath/projection/error_codes.hpp"
+#include "omath/trigonometry/view_angles.hpp"
+#include <sol/sol.hpp>
+#include <format>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace omath::lua::detail
+{
+    using PitchAngle90 = Angle<float, -90.f, 90.f, AngleFlags::Clamped>;
+    using PitchAngle89 = Angle<float, -89.f, 89.f, AngleFlags::Clamped>;
+    using SharedYawRoll = Angle<float, -180.f, 180.f, AngleFlags::Normalized>;
+    using SharedFoV = Angle<float, 0.f, 180.f, AngleFlags::Clamped>;
+    using ViewAngles90 = ViewAngles<PitchAngle90, SharedYawRoll, SharedYawRoll>;
+    using ViewAngles89 = ViewAngles<PitchAngle89, SharedYawRoll, SharedYawRoll>;
+
+    inline std::string projection_error_to_string(projection::Error error)
+    {
+        switch (error)
+        {
+        case projection::Error::WORLD_POSITION_IS_OUT_OF_SCREEN_BOUNDS:
+            return "world position is out of screen bounds";
+        case projection::Error::INV_VIEW_PROJ_MAT_DET_EQ_ZERO:
+            return "inverse view-projection matrix determinant is zero";
+        case projection::Error::PERSPECTIVE_DIVIDER_LESS_EQ_ZERO:
+            return "perspective divider is less or equal to zero";
+        }
+        return "unknown error";
+    }
+
+    template<class AngleType>
+    void register_angle(sol::table& table, const char* name)
+    {
+        table.new_usertype<AngleType>(
+                name, sol::no_constructor, "from_degrees", &AngleType::from_degrees, "from_radians",
+                &AngleType::from_radians, "as_degrees", &AngleType::as_degrees, "as_radians", &AngleType::as_radians,
+                "sin", &AngleType::sin, "cos", &AngleType::cos, "tan", &AngleType::tan, "cot", &AngleType::cot,
+                sol::meta_function::addition, [](const AngleType& a, const AngleType& b)
+                { return AngleType::from_degrees(a.as_degrees() + b.as_degrees()); }, sol::meta_function::subtraction,
+                [](const AngleType& a, const AngleType& b)
+                { return AngleType::from_degrees(a.as_degrees() - b.as_degrees()); }, sol::meta_function::unary_minus,
+                [](const AngleType& a) { return AngleType::from_degrees(-a.as_degrees()); },
+                sol::meta_function::equal_to, [](const AngleType& a, const AngleType& b) { return a == b; },
+                sol::meta_function::to_string, [](const AngleType& a) { return std::format("{}deg", a.as_degrees()); });
+    }
+
+    template<class PitchAngleType, class ViewAnglesType>
+    void set_engine_aliases(sol::table& engine_table, sol::table& types)
+    {
+        if constexpr (std::is_same_v<PitchAngleType, PitchAngle90>)
+            engine_table["PitchAngle"] = types["PitchAngle90"];
+        else
+            engine_table["PitchAngle"] = types["PitchAngle89"];
+
+        engine_table["YawAngle"] = types["YawRoll"];
+        engine_table["RollAngle"] = types["YawRoll"];
+        engine_table["FieldOfView"] = types["FieldOfView"];
+        engine_table["ViewPort"] = types["ViewPort"];
+
+        if constexpr (std::is_same_v<ViewAnglesType, ViewAngles90>)
+            engine_table["ViewAngles"] = types["ViewAngles90"];
+        else
+            engine_table["ViewAngles"] = types["ViewAngles89"];
+    }
+
+    template<class Camera, class PitchAngleType, class ViewAnglesType, class ArithmeticType = float>
+    requires std::is_arithmetic_v<ArithmeticType>
+    void register_engine(sol::table& omath_table, const char* subtable_name)
+    {
+        using Mat4X4 = std::remove_cvref_t<decltype(std::declval<const Camera&>().get_view_matrix())>;
+
+        auto engine_table = omath_table[subtable_name].get_or_create<sol::table>();
+        auto types = omath_table["_types"].get<sol::table>();
+
+        set_engine_aliases<PitchAngleType, ViewAnglesType>(engine_table, types);
+
+        auto camera_type = engine_table.new_usertype<Camera>(
+                "Camera",
+                sol::constructors<Camera(const Vector3<ArithmeticType>&, const ViewAnglesType&,
+                                         const projection::ViewPort&, const projection::FieldOfView&, ArithmeticType,
+                                         ArithmeticType)>());
+
+        camera_type["look_at"] = &Camera::look_at;
+        camera_type["get_forward"] = &Camera::get_forward;
+        camera_type["get_right"] = &Camera::get_right;
+        camera_type["get_up"] = &Camera::get_up;
+        camera_type["get_origin"] = &Camera::get_origin;
+        camera_type["get_view_angles"] = &Camera::get_view_angles;
+        camera_type["get_near_plane"] = &Camera::get_near_plane;
+        camera_type["get_far_plane"] = &Camera::get_far_plane;
+        camera_type["get_field_of_view"] = &Camera::get_field_of_view;
+        camera_type["set_origin"] = &Camera::set_origin;
+        camera_type["set_view_angles"] = &Camera::set_view_angles;
+        camera_type["set_view_port"] = &Camera::set_view_port;
+        camera_type["set_field_of_view"] = &Camera::set_field_of_view;
+        camera_type["set_near_plane"] = &Camera::set_near_plane;
+        camera_type["set_far_plane"] = &Camera::set_far_plane;
+        camera_type["get_view_matrix"] = [](const Camera& camera) -> Mat4X4 { return camera.get_view_matrix(); };
+        camera_type["get_projection_matrix"] = [](const Camera& camera) -> Mat4X4
+        { return camera.get_projection_matrix(); };
+        camera_type["get_view_projection_matrix"] = [](const Camera& camera) -> Mat4X4
+        { return camera.get_view_projection_matrix(); };
+        camera_type["extract_projection_params"] = [](const Mat4X4& projection_matrix)
+        {
+            const auto params = Camera::extract_projection_params(projection_matrix);
+            return std::make_tuple(params.fov, params.aspect_ratio);
+        };
+        camera_type["calc_view_angles_from_view_matrix"] = &Camera::calc_view_angles_from_view_matrix;
+        camera_type["calc_origin_from_view_matrix"] = &Camera::calc_origin_from_view_matrix;
+        camera_type["world_to_screen"] = [](const Camera& camera, const Vector3<ArithmeticType>& position)
+                -> std::tuple<sol::optional<Vector3<ArithmeticType>>, sol::optional<std::string>>
+        {
+            auto result = camera.world_to_screen(position);
+            if (result)
+                return {*result, sol::nullopt};
+            return {sol::nullopt, projection_error_to_string(result.error())};
+        };
+        camera_type["screen_to_world"] = [](const Camera& camera, const Vector3<ArithmeticType>& position)
+                -> std::tuple<sol::optional<Vector3<ArithmeticType>>, sol::optional<std::string>>
+        {
+            auto result = camera.screen_to_world(position);
+            if (result)
+                return {*result, sol::nullopt};
+            return {sol::nullopt, projection_error_to_string(result.error())};
+        };
+    }
+
+    void register_opengl_engine(sol::table& omath_table);
+    void register_frostbite_engine(sol::table& omath_table);
+    void register_iw_engine(sol::table& omath_table);
+    void register_source_engine(sol::table& omath_table);
+    void register_rage_engine(sol::table& omath_table);
+    void register_unity_engine(sol::table& omath_table);
+    void register_unreal_engine(sol::table& omath_table);
+    void register_cry_engine(sol::table& omath_table);
+} // namespace omath::lua::detail

tests/general/unit_test_angle.cpp

@@ -14,9 +14,14 @@ namespace
 
     // Handy aliases (defaults: Type=float, [0,360], Normalized)
     using Deg = Angle<float, static_cast<float>(0), static_cast<float>(360), AngleFlags::Normalized>;
+    using Fov = Angle<float, static_cast<float>(0), static_cast<float>(180), AngleFlags::Clamped>;
+    using Offset = Angle<float, static_cast<float>(10), static_cast<float>(20), AngleFlags::Clamped>;
     using Pitch = Angle<float, static_cast<float>(-90), static_cast<float>(90), AngleFlags::Clamped>;
     using Turn = Angle<float, static_cast<float>(-180), static_cast<float>(180), AngleFlags::Normalized>;
 
+    template<class Type>
+    concept SupportedAngleType = requires { typename Angle<Type>; };
+
     constexpr float k_eps = 1e-5f;
 
     constexpr bool close_to(const float actual, const float expected, const float epsilon)
@@ -36,6 +41,12 @@ TEST(UnitTestAngle, DefaultConstructor_IsZeroDegrees)
     EXPECT_FLOAT_EQ(a.as_degrees(), 0.0f);
 }
 
+TEST(UnitTestAngle, DefaultConstructor_AppliesRangePolicy)
+{
+    constexpr Offset a;
+    EXPECT_FLOAT_EQ(a.as_degrees(), 10.0f);
+}
+
 TEST(UnitTestAngle, FromDegrees_Normalized_WrapsAboveMax)
 {
     const Deg a = Deg::from_degrees(370.0f);
@@ -66,6 +77,14 @@ TEST(UnitTestAngle, FromRadians_And_AsRadians)
     EXPECT_NEAR(b.as_radians(), std::numbers::pi_v<float>, 1e-6f);
 }
 
+TEST(UnitTestAngle, FromInverseTrigonometricFunctions)
+{
+    EXPECT_NEAR(Pitch::from_asin(0.5f).as_degrees(), 30.0f, k_eps);
+    EXPECT_NEAR(Pitch::from_acos(0.5f).as_degrees(), 60.0f, k_eps);
+    EXPECT_NEAR(Pitch::from_atan(1.0f).as_degrees(), 45.0f, k_eps);
+    EXPECT_NEAR(Turn::from_atan2(-1.0f, -1.0f).as_degrees(), -135.0f, k_eps);
+}
+
 // ---------- Unary minus & deref ----------
 
 TEST(UnitTestAngle, UnaryMinus_Normalized)
@@ -101,17 +120,6 @@ TEST(UnitTestAngle, SinCosTanCot_BasicCases)
     EXPECT_NEAR(a90.cos(), 0.0f, 1e-4f);
 }
 
-TEST(UnitTestAngle, Atan_IsAtanOfRadians)
-{
-    // atan(as_radians). For 0° -> atan(0)=0.
-    const Deg a0 = Deg::from_degrees(0.0f);
-    EXPECT_NEAR(a0.atan(), 0.0f, k_eps);
-
-    const Deg a45 = Deg::from_degrees(45.0f);
-    // atan(pi/4) ≈ 0.665773...
-    EXPECT_NEAR(a45.atan(), 0.66577375f, 1e-6f);
-}
-
 // ---------- Compound arithmetic ----------
 
 TEST(UnitTestAngle, PlusEquals_Normalized_Wraps)
@@ -142,6 +150,16 @@ TEST(UnitTestAngle, MinusEquals_Clamped_Clamps)
     EXPECT_FLOAT_EQ(p.as_degrees(), -90.0f);
 }
 
+TEST(UnitTestAngle, Subtraction_ClampedNonSymmetricRange)
+{
+    Fov compound = Fov::from_degrees(90.0f);
+    compound -= Fov::from_degrees(10.0f);
+    EXPECT_FLOAT_EQ(compound.as_degrees(), 80.0f);
+
+    const Fov binary = Fov::from_degrees(90.0f) - Fov::from_degrees(10.0f);
+    EXPECT_FLOAT_EQ(binary.as_degrees(), 80.0f);
+}
+
 // ---------- Alternative ranges ----------
 
 TEST(UnitTestAngle, NormalizedRange_Neg180To180)
@@ -205,5 +223,12 @@ static_assert(close_to(Pitch::from_degrees(45.0f).tan(), 1.0f, 1e-4f),
               "Tan should be constexpr with embedded constexpr math");
 static_assert(close_to(Pitch::from_degrees(45.0f).cot(), 1.0f, 1e-4f),
               "Cot should be constexpr with embedded constexpr math");
-static_assert(close_to(Pitch::from_degrees(45.0f).atan(), 0.66577375f, 1e-6f),
-              "Atan should be constexpr with embedded constexpr math");
+static_assert(close_to(Pitch::from_asin(0.5f).as_degrees(), 30.0f, k_eps),
+              "From asin should be constexpr with embedded constexpr math");
+static_assert(close_to(Pitch::from_acos(0.5f).as_degrees(), 60.0f, k_eps),
+              "From acos should be constexpr with embedded constexpr math");
+static_assert(close_to(Pitch::from_atan(1.0f).as_degrees(), 45.0f, k_eps),
+              "From atan should be constexpr with embedded constexpr math");
+static_assert(close_to(Turn::from_atan2(-1.0f, -1.0f).as_degrees(), -135.0f, k_eps),
+              "From atan2 should be constexpr with embedded constexpr math");
+static_assert(!SupportedAngleType<int>, "Angle should only accept floating-point types");

tests/general/unit_test_angles.cpp

@@ -47,3 +47,10 @@ TEST(unit_test_angles, wrap_angle_negative_range)
 
     EXPECT_NEAR(wrapped, 270.f, 0.01f);
 }
+
+TEST(unit_test_angles, wrap_angle_maximum_maps_to_minimum)
+{
+    const float wrapped = omath::angles::wrap_angle(360.f, 0.f, 360.f);
+
+    EXPECT_FLOAT_EQ(wrapped, 0.f);
+}

tests/general/unit_test_hashing.cpp

@@ -0,0 +1,34 @@
+#include <gtest/gtest.h>
+#include <omath/hashing.hpp>
+
+TEST(unit_test_hashing, fnv1a)
+{
+    constexpr auto hash = omath::hashing::fnv1a("hello");
+
+    static_assert(hash == 0xA430D84680AABD0BULL);
+    EXPECT_EQ(hash, 0xA430D84680AABD0BULL);
+}
+
+TEST(unit_test_hashing, crc32)
+{
+    constexpr auto crc = omath::hashing::crc32("123456789");
+
+    static_assert(crc == 0xCBF43926U);
+    EXPECT_EQ(crc, 0xCBF43926U);
+}
+
+TEST(unit_test_hashing, base64_encode)
+{
+    static_assert(omath::hashing::base64_encode("foo") == "Zm9v");
+    EXPECT_EQ(omath::hashing::base64_encode("foobar"), "Zm9vYmFy");
+}
+
+TEST(unit_test_hashing, base64_decode)
+{
+    static_assert(omath::hashing::base64_decode("Zm9v").has_value());
+    static_assert(omath::hashing::base64_decode("Zm9v").value() == "foo");
+    EXPECT_EQ(omath::hashing::base64_decode("Zm9vYmFy").value(), "foobar");
+    EXPECT_EQ(omath::hashing::base64_decode("Zm9v=").error(), omath::hashing::Base64Error::INVALID_LENGTH);
+    EXPECT_EQ(omath::hashing::base64_decode("Zm?v").error(), omath::hashing::Base64Error::INVALID_CHARACTER);
+    EXPECT_EQ(omath::hashing::base64_decode("Zm9=").error(), omath::hashing::Base64Error::INVALID_PADDING);
+}

tests/general/unit_test_mat.cpp

@@ -16,6 +16,21 @@ namespace
         const float diff = actual - expected;
         return (diff < 0.0f ? -diff : diff) <= epsilon;
     }
+
+    template<size_t Rows, size_t Columns, size_t OtherColumns, class Type, MatStoreType StoreType>
+    void expect_multiplication_matches_scalar_reference(const Mat<Rows, Columns, Type, StoreType>& left,
+                                                        const Mat<Columns, OtherColumns, Type, StoreType>& right)
+    {
+        const auto result = left * right;
+        for (size_t row = 0; row < Rows; ++row)
+            for (size_t column = 0; column < OtherColumns; ++column)
+            {
+                Type expected{};
+                for (size_t shared_index = 0; shared_index < Columns; ++shared_index)
+                    expected += left.at(row, shared_index) * right.at(shared_index, column);
+                EXPECT_EQ(result.at(row, column), expected);
+            }
+    }
 } // namespace
 
 class UnitTestMat : public ::testing::Test
@@ -92,6 +107,45 @@ TEST_F(UnitTestMat, Operator_Multiplication_Matrix)
     EXPECT_FLOAT_EQ(m3.at(1, 1), 22.0f);
 }
 
+TEST(UnitTestMatStandalone, Operator_Multiplication_RowMajorSimdAndTail)
+{
+    Mat<3, 5, float, MatStoreType::ROW_MAJOR> left;
+    Mat<5, 33, float, MatStoreType::ROW_MAJOR> right;
+    for (size_t row = 0; row < left.row_count(); ++row)
+        for (size_t column = 0; column < left.columns_count(); ++column)
+            left.at(row, column) = static_cast<float>(row * 3 + column + 1);
+    for (size_t row = 0; row < right.row_count(); ++row)
+        for (size_t column = 0; column < right.columns_count(); ++column)
+            right.at(row, column) = static_cast<float>((row + 1) * (column % 5 + 1));
+
+    expect_multiplication_matches_scalar_reference(left, right);
+}
+
+TEST(UnitTestMatStandalone, Operator_Multiplication_ColumnMajorSimdAndTail)
+{
+    Mat<17, 5, double, MatStoreType::COLUMN_MAJOR> left;
+    Mat<5, 3, double, MatStoreType::COLUMN_MAJOR> right;
+    for (size_t row = 0; row < left.row_count(); ++row)
+        for (size_t column = 0; column < left.columns_count(); ++column)
+            left.at(row, column) = static_cast<double>(row * 3 + column + 1);
+    for (size_t row = 0; row < right.row_count(); ++row)
+        for (size_t column = 0; column < right.columns_count(); ++column)
+            right.at(row, column) = static_cast<double>((row + 1) * (column + 1));
+
+    expect_multiplication_matches_scalar_reference(left, right);
+}
+
+TEST(UnitTestMatStandalone, Operator_Multiplication_IntegerFallsBackFromAvx)
+{
+    constexpr Mat<2, 3, int> left{{1, 2, 3}, {4, 5, 6}};
+    constexpr Mat<3, 2, int> right{{7, 8}, {9, 10}, {11, 12}};
+    constexpr auto result = left * right;
+    static_assert(result.at(0, 0) == 58);
+    static_assert(result.at(1, 1) == 154);
+
+    expect_multiplication_matches_scalar_reference(left, right);
+}
+
 TEST_F(UnitTestMat, Operator_Multiplication_Scalar)
 {
     Mat<2, 2> m3 = m2 * 2.0f;

vcpkg-configuration.json

@@ -1,7 +1,7 @@
 {
   "default-registry": {
     "kind": "git",
-    "baseline": "b1b19307e2d2ec1eefbdb7ea069de7d4bcd31f01",
+    "baseline": "0878b5224d4a4968940ee296a2e7fae2d3b62983",
     "repository": "https://github.com/microsoft/vcpkg"
   },
   "registries": [

vcpkg.json

@@ -21,7 +21,11 @@
       "dependencies": [
         {
           "name": "omath",
-          "features": ["imgui", "lua", "hooking"]
+          "features": [
+            "imgui",
+            "lua",
+            "hooking"
+          ]
         }
       ]
     },
@@ -50,16 +54,26 @@
         "opengl",
         {
           "name": "omath",
-          "features": ["hooking"],
+          "features": [
+            "hooking"
+          ],
           "platform": "windows & !arm & !uwp"
         },
         {
           "name": "imgui",
-          "features": ["glfw-binding", "opengl3-binding"]
+          "features": [
+            "glfw-binding",
+            "opengl3-binding"
+          ]
         },
         {
           "name": "imgui",
-          "features": ["dx9-binding", "dx11-binding", "dx12-binding", "win32-binding"],
+          "features": [
+            "dx9-binding",
+            "dx11-binding",
+            "dx12-binding",
+            "win32-binding"
+          ],
           "platform": "windows & !arm & !uwp"
         }
       ]