fix

.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:
@@ -706,12 +709,7 @@ jobs:
             -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"
 
       - name: Build
-        run: |
+        run: cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
-          if [[ "${{ matrix.msystem }}" == "MINGW32" ]]; then
-            cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath --parallel 1
-          else
-            cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
-          fi
 
       - 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:

benchmark/benchmark_projectile_pred.cpp

@@ -2,105 +2,22 @@
 // Created by Vlad on 9/18/2025.
 //
 #include <benchmark/benchmark.h>
-#include <omath/projectile_prediction/proj_pred_engine_legacy.hpp>
+#include <omath/omath.hpp>
+using namespace omath;
 
-namespace
+using namespace omath::projectile_prediction;
+
+constexpr float simulation_time_step = 1.f / 1000.f;
+constexpr float hit_distance_tolerance = 5.f;
+
+void source_engine_projectile_prediction(benchmark::State& state)
 {
-    using Engine = omath::projectile_prediction::ProjPredEngineLegacy<>;
+    constexpr Target<float> target{.m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
-    using Projectile = omath::projectile_prediction::Projectile<float>;
+    constexpr Projectile<float> projectile = {.m_origin = {3, 2, 1}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
-    using Target = omath::projectile_prediction::Target<float>;
 
-    struct PredictionScenario
+    for ([[maybe_unused]] const auto _: state)
-    {
+        std::ignore = ProjPredEngineLegacy<>(400.f, simulation_time_step, 50.f, hit_distance_tolerance)
-        Projectile projectile;
+                              .maybe_calculate_aim_point(projectile, target);
-        Target target;
+}
-        float gravity;
-        float simulation_time_step;
-        float maximum_simulation_time;
-        float distance_tolerance;
-        bool expects_solution;
-    };
 
-    void run_prediction_benchmark(benchmark::State& state, const PredictionScenario& scenario)
+BENCHMARK(source_engine_projectile_prediction)->Iterations(10'000);
-    {
-        const Engine engine(scenario.gravity, scenario.simulation_time_step, scenario.maximum_simulation_time,
-                            scenario.distance_tolerance);
-        auto projectile = scenario.projectile;
-        auto target = scenario.target;
-
-        if (engine.maybe_calculate_aim_point(projectile, target).has_value() != scenario.expects_solution)
-        {
-            state.SkipWithError("Projectile benchmark scenario returned an unexpected result");
-            return;
-        }
-
-        for ([[maybe_unused]] const auto _ : state)
-        {
-            benchmark::DoNotOptimize(projectile);
-            benchmark::DoNotOptimize(target);
-            auto result = engine.maybe_calculate_aim_point(projectile, target);
-            benchmark::DoNotOptimize(result);
-        }
-    }
-
-    void projectile_prediction_near_static_hit(benchmark::State& state)
-    {
-        constexpr PredictionScenario scenario{
-                .projectile = {.m_origin = {3.f, 2.f, 1.f}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f},
-                .target = {.m_origin = {100.f, 0.f, 90.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false},
-                .gravity = 400.f,
-                .simulation_time_step = 1.f / 1000.f,
-                .maximum_simulation_time = 50.f,
-                .distance_tolerance = 5.f,
-                .expects_solution = true,
-        };
-        run_prediction_benchmark(state, scenario);
-    }
-
-    void projectile_prediction_moving_hit(benchmark::State& state)
-    {
-        constexpr PredictionScenario scenario{
-                .projectile = {.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 3000.f, .m_gravity_scale = 1.f},
-                .target = {.m_origin = {500.f, 100.f, 0.f}, .m_velocity = {-50.f, 20.f, 0.f}, .m_is_airborne = false},
-                .gravity = 800.f,
-                .simulation_time_step = 1.f / 500.f,
-                .maximum_simulation_time = 30.f,
-                .distance_tolerance = 10.f,
-                .expects_solution = true,
-        };
-        run_prediction_benchmark(state, scenario);
-    }
-
-    void projectile_prediction_unreachable_full_scan(benchmark::State& state)
-    {
-        constexpr PredictionScenario scenario{
-                .projectile = {.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 1.f, .m_gravity_scale = 1.f},
-                .target = {.m_origin = {100'000.f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false},
-                .gravity = 9.81f,
-                .simulation_time_step = 1.f / 1000.f,
-                .maximum_simulation_time = 2.f,
-                .distance_tolerance = 5.f,
-                .expects_solution = false,
-        };
-        run_prediction_benchmark(state, scenario);
-    }
-
-    void projectile_prediction_receding_full_scan(benchmark::State& state)
-    {
-        constexpr PredictionScenario scenario{
-                .projectile = {.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 100.f, .m_gravity_scale = 0.f},
-                .target = {.m_origin = {100.f, 0.f, 0.f}, .m_velocity = {200.f, 0.f, 0.f}, .m_is_airborne = false},
-                .gravity = 9.81f,
-                .simulation_time_step = 1.f / 1000.f,
-                .maximum_simulation_time = 2.f,
-                .distance_tolerance = 0.01f,
-                .expects_solution = false,
-        };
-        run_prediction_benchmark(state, scenario);
-    }
-} // namespace
-
-BENCHMARK(projectile_prediction_near_static_hit);
-BENCHMARK(projectile_prediction_moving_hit);
-BENCHMARK(projectile_prediction_unreachable_full_scan);
-BENCHMARK(projectile_prediction_receding_full_scan);

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;
+        IDXGISwapChain3* swap_chain3 = nullptr;
-
+        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&swap_chain3))))
-        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&g_swap_chain))))
             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(),
+        ImGui_ImplDX12_InitInfo init_info{};
-                            g_srv_heap->GetGPUDescriptorHandleForHeapStart());
+        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);
+                    if (ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp))
-                    return true;
+                        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.
+        // The most recently used DIRECT queue is the best available proxy for the swap chain's presentation queue.
-        if (!g_command_queue)
+        remember_direct_command_queue(queue);
-        {
-            const D3D12_COMMAND_QUEUE_DESC desc = queue->GetDesc();
-            if (desc.Type == D3D12_COMMAND_LIST_TYPE_DIRECT)
-                g_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/source_engine/traits/pred_engine_trait.hpp

@@ -6,8 +6,6 @@
 #include "omath/engines/source_engine/formulas.hpp"
 #include "omath/projectile_prediction/projectile.hpp"
 #include "omath/projectile_prediction/target.hpp"
-#include <cmath>
-#include <limits>
 #include <optional>
 
 namespace omath::source_engine
@@ -16,58 +14,19 @@ namespace omath::source_engine
     {
     public:
         [[nodiscard("projectile position result should not be discarded")]]
-        constexpr static Vector3<float>
+        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
-        predict_projectile_position(const projectile_prediction::Projectile<float>& projectile, const float pitch,
+                                                                    const float pitch, const float yaw,
-                                    const float yaw, const float time, const float gravity) noexcept
+                                                                    const float time, const float gravity) noexcept
         {
             const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
-            const auto pitch_angle = PitchAngle::from_degrees(-pitch);
+            auto current_pos = launch_pos
-            const auto yaw_angle = YawAngle::from_degrees(yaw);
+                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
-            const auto pitch_cos = pitch_angle.cos();
+                                                 RollAngle::from_degrees(0)})
-            // Roll is always zero here, so this is the exact first column of the rotation matrix.
+                                         * projectile.m_launch_speed * time;
-            const Vector3 forward{pitch_cos * yaw_angle.cos(), pitch_cos * yaw_angle.sin(), -pitch_angle.sin()};
-            auto current_pos = launch_pos + forward * projectile.m_launch_speed * time;
             current_pos.z -= (gravity * projectile.m_gravity_scale) * (time * time) * 0.5f;
 
             return current_pos;
         }
-
-        [[nodiscard("reachability result should not be discarded")]]
-        static constexpr bool
-        can_projectile_reach_target_at_time(const projectile_prediction::Projectile<float>& projectile,
-                                            const Vector3<float>& target_position, const float time,
-                                            const float gravity, const float distance_tolerance) noexcept
-        {
-            if (!(distance_tolerance >= 0.f))
-                return false;
-
-            // After undoing gravity, every possible projectile position is on a sphere with radius speed * time.
-            const auto launch_position = projectile.m_origin + projectile.m_launch_offset;
-            auto adjusted_delta = target_position - launch_position;
-            const auto gravity_displacement = (gravity * projectile.m_gravity_scale) * (time * time) * 0.5f;
-            adjusted_delta.z += gravity_displacement;
-
-            const auto target_distance_sqr = adjusted_delta.length_sqr();
-            const auto projectile_distance = std::abs(projectile.m_launch_speed * time);
-            const auto floating_point_margin =
-                    std::numeric_limits<float>::epsilon() * 8.f
-                    * (std::abs(target_position.x) + std::abs(target_position.y) + std::abs(target_position.z)
-                       + std::abs(launch_position.x) + std::abs(launch_position.y) + std::abs(launch_position.z)
-                       + std::abs(gravity_displacement) + projectile_distance + distance_tolerance + 1.f);
-
-            if (!std::isfinite(target_distance_sqr) || !std::isfinite(floating_point_margin)) [[unlikely]]
-                return true;
-
-            const auto conservative_tolerance = distance_tolerance + floating_point_margin;
-            const auto maximum_distance = projectile_distance + conservative_tolerance;
-            if (target_distance_sqr > maximum_distance * maximum_distance)
-                return false;
-
-            const auto minimum_distance =
-                    projectile_distance > conservative_tolerance ? projectile_distance - conservative_tolerance : 0.f;
-            return target_distance_sqr >= minimum_distance * minimum_distance;
-        }
-
         [[nodiscard("target position result should not be discarded")]]
         static constexpr Vector3<float> predict_target_position(const projectile_prediction::Target<float>& target,
                                                                 const float time, const float gravity) noexcept
@@ -119,4 +78,4 @@ namespace omath::source_engine
             return angles::radians_to_degrees(std::atan2(delta.y, delta.x));
         };
     };
-} // namespace omath::source_engine
+} // namespace omath::source_engine

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/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/projectile_prediction/proj_pred_engine_legacy.hpp

@@ -9,7 +9,6 @@
 #include "omath/projectile_prediction/proj_pred_engine.hpp"
 #include "omath/projectile_prediction/projectile.hpp"
 #include "omath/projectile_prediction/target.hpp"
-#include <cmath>
 #include <optional>
 
 namespace omath::projectile_prediction
@@ -18,8 +17,9 @@ namespace omath::projectile_prediction
     concept PredEngineConcept =
             requires(const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target,
                      const Vector3<ArithmeticType>& vec_a, const Vector3<ArithmeticType>& vec_b,
-                     Vector3<ArithmeticType> v3, ArithmeticType pitch, ArithmeticType yaw, ArithmeticType time,
+                     Vector3<ArithmeticType> v3,
-                     ArithmeticType gravity, std::optional<ArithmeticType> maybe_pitch) {
+                     ArithmeticType pitch, ArithmeticType yaw, ArithmeticType time, ArithmeticType gravity,
+                     std::optional<ArithmeticType> maybe_pitch) {
                 {
                     T::predict_projectile_position(projectile, pitch, yaw, time, gravity)
                 } -> std::same_as<Vector3<ArithmeticType>>;
@@ -44,7 +44,8 @@ namespace omath::projectile_prediction
     class ProjPredEngineLegacy final : public ProjPredEngineInterface<ArithmeticType>
     {
     public:
-        explicit ProjPredEngineLegacy(const ArithmeticType gravity_constant, const ArithmeticType simulation_time_step,
+        explicit ProjPredEngineLegacy(const ArithmeticType gravity_constant,
+                                      const ArithmeticType simulation_time_step,
                                       const ArithmeticType maximum_simulation_time,
                                       const ArithmeticType distance_tolerance)
             : m_gravity_constant(gravity_constant), m_simulation_time_step(simulation_time_step),
@@ -53,9 +54,8 @@ namespace omath::projectile_prediction
         }
 
         [[nodiscard]]
-        std::optional<Vector3<ArithmeticType>>
+        std::optional<Vector3<ArithmeticType>> maybe_calculate_aim_point(
-        maybe_calculate_aim_point(const Projectile<ArithmeticType>& projectile,
+            const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target) const override
-                                  const Target<ArithmeticType>& target) const override
         {
             const auto solution = find_solution(projectile, target);
             if (!solution)
@@ -66,16 +66,15 @@ namespace omath::projectile_prediction
         }
 
         [[nodiscard]]
-        std::optional<AimAngles<ArithmeticType>>
+        std::optional<AimAngles<ArithmeticType>> maybe_calculate_aim_angles(
-        maybe_calculate_aim_angles(const Projectile<ArithmeticType>& projectile,
+            const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target) const override
-                                   const Target<ArithmeticType>& target) const override
         {
             const auto solution = find_solution(projectile, target);
             if (!solution)
                 return std::nullopt;
 
-            const auto yaw = EngineTrait::calc_direct_yaw_angle(projectile.m_origin + projectile.m_launch_offset,
+            const auto yaw = EngineTrait::calc_direct_yaw_angle(
-                                                                solution->predicted_target_position);
+                projectile.m_origin + projectile.m_launch_offset, solution->predicted_target_position);
             return AimAngles<ArithmeticType>{solution->pitch, yaw};
         }
 
@@ -90,39 +89,23 @@ namespace omath::projectile_prediction
         std::optional<Solution> find_solution(const Projectile<ArithmeticType>& projectile,
                                               const Target<ArithmeticType>& target) const
         {
-            if (!std::isfinite(m_simulation_time_step) || m_simulation_time_step <= ArithmeticType{0}
+            for (ArithmeticType time = ArithmeticType{0}; time < m_maximum_simulation_time;
-                || !std::isfinite(m_maximum_simulation_time) || m_maximum_simulation_time < ArithmeticType{0}
+                 time += m_simulation_time_step)
-                || !std::isfinite(projectile.m_launch_speed) || projectile.m_launch_speed <= ArithmeticType{0}
-                || !(m_distance_tolerance >= ArithmeticType{0})) [[unlikely]]
-                return std::nullopt;
-
-            for (ArithmeticType time = ArithmeticType{0}; time <= m_maximum_simulation_time;)
             {
                 const auto predicted_target_position =
                         EngineTrait::predict_target_position(target, time, m_gravity_constant);
 
-                if (is_target_potentially_reachable(projectile, predicted_target_position, time))
+                const auto projectile_pitch =
-                {
+                        maybe_calculate_projectile_launch_pitch_angle(projectile, predicted_target_position);
-                    const auto projectile_pitch =
-                            maybe_calculate_projectile_launch_pitch_angle(projectile, predicted_target_position);
 
-                    if (projectile_pitch.has_value()) [[likely]]
+                if (!projectile_pitch.has_value()) [[unlikely]]
-                    {
+                    continue;
-                        const auto yaw = EngineTrait::calc_direct_yaw_angle(
-                                projectile.m_origin + projectile.m_launch_offset, predicted_target_position);
 
-                        if (is_projectile_reached_target(predicted_target_position, projectile,
+                if (!is_projectile_reached_target(predicted_target_position, projectile, projectile_pitch.value(),
-                                                         projectile_pitch.value(), yaw, time))
+                                                  time))
-                            return Solution{predicted_target_position, projectile_pitch.value()};
+                    continue;
-                    }
-                }
 
-                if (time == m_maximum_simulation_time)
+                return Solution{predicted_target_position, projectile_pitch.value()};
-                    break;
-                const auto next_time = time + m_simulation_time_step;
-                if (!(next_time > time)) [[unlikely]]
-                    break;
-                time = next_time < m_maximum_simulation_time ? next_time : m_maximum_simulation_time;
             }
             return std::nullopt;
         }
@@ -161,46 +144,29 @@ namespace omath::projectile_prediction
             const auto distance2d = EngineTrait::calc_vector_2d_distance(delta);
             const auto distance2d_sqr = distance2d * distance2d;
             const auto launch_speed_sqr = projectile.m_launch_speed * projectile.m_launch_speed;
-            const auto ballistic_term =
-                    bullet_gravity * distance2d_sqr
-                    + ArithmeticType{2} * EngineTrait::get_vector_height_coordinate(delta) * launch_speed_sqr;
 
-            ArithmeticType root = launch_speed_sqr * launch_speed_sqr - bullet_gravity * ballistic_term;
+            ArithmeticType root = launch_speed_sqr * launch_speed_sqr
+                                  - bullet_gravity
+                                            * (bullet_gravity * distance2d_sqr
+                                               + ArithmeticType{2} * EngineTrait::get_vector_height_coordinate(delta)
+                                                         * launch_speed_sqr);
 
             if (root < ArithmeticType{0}) [[unlikely]]
                 return std::nullopt;
 
             root = std::sqrt(root);
-            // This rationalized form avoids cancellation in launch_speed_sqr - root for low-angle shots.
+            const ArithmeticType angle = std::atan((launch_speed_sqr - root) / (bullet_gravity * distance2d));
-            const ArithmeticType angle = std::atan2(ballistic_term, distance2d * (launch_speed_sqr + root));
 
             return angles::radians_to_degrees(angle);
         }
 
-        [[nodiscard]]
-        bool is_target_potentially_reachable(const Projectile<ArithmeticType>& projectile,
-                                             const Vector3<ArithmeticType>& target_position,
-                                             const ArithmeticType time) const noexcept
-        {
-            if constexpr (requires {
-                              {
-                                  EngineTrait::can_projectile_reach_target_at_time(
-                                          projectile, target_position, time, m_gravity_constant, m_distance_tolerance)
-                              } -> std::same_as<bool>;
-                              requires noexcept(EngineTrait::can_projectile_reach_target_at_time(
-                                      projectile, target_position, time, m_gravity_constant, m_distance_tolerance));
-                          })
-                return EngineTrait::can_projectile_reach_target_at_time(projectile, target_position, time,
-                                                                        m_gravity_constant, m_distance_tolerance);
-
-            return true;
-        }
-
         [[nodiscard]]
         bool is_projectile_reached_target(const Vector3<ArithmeticType>& target_position,
-                                          const Projectile<ArithmeticType>& projectile, const ArithmeticType pitch,
+                                          const Projectile<ArithmeticType>& projectile,
-                                          const ArithmeticType yaw, const ArithmeticType time) const noexcept
+                                          const ArithmeticType pitch, const ArithmeticType time) const noexcept
         {
+            const auto yaw = EngineTrait::calc_direct_yaw_angle(
+                projectile.m_origin + projectile.m_launch_offset, target_position);
             const auto projectile_position =
                     EngineTrait::predict_projectile_position(projectile, pitch, yaw, time, m_gravity_constant);
 

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 "lua_engines_detail.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
 
 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");
+        detail::register_angle<detail::PitchAngle90>(types, "PitchAngle90");
-        register_angle<PitchAngle89>(t, "PitchAngle89");
+        detail::register_angle<detail::PitchAngle89>(types, "PitchAngle89");
-        register_angle<SharedYawRoll>(t, "YawRoll");
+        detail::register_angle<detail::SharedYawRoll>(types, "YawRoll");
-        register_angle<SharedFoV>(t, "FieldOfView");
+        detail::register_angle<detail::SharedFoV>(types, "FieldOfView");
 
-        t.new_usertype<omath::projection::ViewPort>(
+        types.new_usertype<projection::ViewPort>(
-                "ViewPort", sol::factories([](float w, float h) { return omath::projection::ViewPort{w, h}; }), "width",
+                "ViewPort",
-                sol::property([](const omath::projection::ViewPort& vp) { return vp.m_width; },
+                sol::factories([](float width, float height) { return projection::ViewPort{width, height}; }),
-                              [](omath::projection::ViewPort& vp, float val) { vp.m_width = val; }),
+                "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; },
+                sol::property([](const projection::ViewPort& view_port) { return view_port.m_height; },
-                              [](omath::projection::ViewPort& vp, float val) { vp.m_height = val; }),
+                              [](projection::ViewPort& view_port, float value) { view_port.m_height = value; }),
-                "aspect_ratio", &omath::projection::ViewPort::aspect_ratio);
+                "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; },
+                sol::property([](const detail::ViewAngles90& view_angles) { return view_angles.pitch; },
-                              [](ViewAngles90& va, const PitchAngle90& val) { va.pitch = val; }),
+                              [](detail::ViewAngles90& view_angles, const detail::PitchAngle90& value)
+                              { view_angles.pitch = value; }),
                 "yaw",
-                sol::property([](const ViewAngles90& va) { return va.yaw; },
+                sol::property([](const detail::ViewAngles90& view_angles) { return view_angles.yaw; },
-                              [](ViewAngles90& va, const SharedYawRoll& val) { va.yaw = val; }),
+                              [](detail::ViewAngles90& view_angles, const detail::SharedYawRoll& value)
+                              { view_angles.yaw = value; }),
                 "roll",
-                sol::property([](const ViewAngles90& va) { return va.roll; },
+                sol::property([](const detail::ViewAngles90& view_angles) { return view_angles.roll; },
-                              [](ViewAngles90& va, const SharedYawRoll& val) { va.roll = val; }));
+                              [](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; },
+                sol::property([](const detail::ViewAngles89& view_angles) { return view_angles.pitch; },
-                              [](ViewAngles89& va, const PitchAngle89& val) { va.pitch = val; }),
+                              [](detail::ViewAngles89& view_angles, const detail::PitchAngle89& value)
+                              { view_angles.pitch = value; }),
                 "yaw",
-                sol::property([](const ViewAngles89& va) { return va.yaw; },
+                sol::property([](const detail::ViewAngles89& view_angles) { return view_angles.yaw; },
-                              [](ViewAngles89& va, const SharedYawRoll& val) { va.yaw = val; }),
+                              [](detail::ViewAngles89& view_angles, const detail::SharedYawRoll& value)
+                              { view_angles.yaw = value; }),
                 "roll",
-                sol::property([](const ViewAngles89& va) { return va.roll; },
+                sol::property([](const detail::ViewAngles89& view_angles) { return view_angles.roll; },
-                              [](ViewAngles89& va, const SharedYawRoll& val) { va.roll = val; }));
+                              [](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");
+        detail::register_opengl_engine(omath_table);
-        register_engine<FrostbiteEngineTraits>(omath_table, "frostbite");
+        detail::register_frostbite_engine(omath_table);
-        register_engine<IWEngineTraits>(omath_table, "iw");
+        detail::register_iw_engine(omath_table);
-        register_engine<SourceEngineTraits>(omath_table, "source");
+        detail::register_source_engine(omath_table);
-        register_engine<RageEngineTraits>(omath_table, "rage");
+        detail::register_rage_engine(omath_table);
-        register_engine<UnityEngineTraits>(omath_table, "unity");
+        detail::register_unity_engine(omath_table);
-        register_engine<UnrealEngineTraits, double>(omath_table, "unreal");
+        detail::register_unreal_engine(omath_table);
-        register_engine<CryEngineTraits>(omath_table, "cry");
+        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_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_pred_engine_trait.cpp

@@ -1,5 +1,4 @@
 // Tests for PredEngineTrait
-#include <array>
 #include <gtest/gtest.h>
 #include <omath/engines/source_engine/traits/pred_engine_trait.hpp>
 #include <omath/projectile_prediction/projectile.hpp>
@@ -78,77 +77,6 @@ TEST(PredEngineTrait, PredictProjectilePositionWithLaunchOffset)
     EXPECT_NEAR(pos_t1.z, -2.f - 9.81f * 0.5f, 1e-3f);
 }
 
-TEST(PredEngineTrait, PredictProjectilePositionMatchesRotationMatrix)
-{
-    constexpr Projectile projectile{
-            .m_origin = {10.f, -20.f, 30.f},
-            .m_launch_offset = {2.f, 3.f, -4.f},
-            .m_launch_speed = 750.f,
-            .m_gravity_scale = 0.6f,
-    };
-    struct TestCase
-    {
-        float pitch;
-        float yaw;
-        float time;
-    };
-    constexpr std::array test_cases{
-            TestCase{0.f, 0.f, 0.f},
-            TestCase{25.f, 45.f, 0.25f},
-            TestCase{-60.f, -135.f, 1.5f},
-            TestCase{120.f, 540.f, 2.f},
-    };
-    constexpr float gravity = 9.81f;
-
-    for (const auto& test_case : test_cases)
-    {
-        const auto launch_position = projectile.m_origin + projectile.m_launch_offset;
-        auto expected_position = launch_position
-                                 + forward_vector({PitchAngle::from_degrees(-test_case.pitch),
-                                                   YawAngle::from_degrees(test_case.yaw), RollAngle::from_degrees(0.f)})
-                                           * projectile.m_launch_speed * test_case.time;
-        expected_position.z -= gravity * projectile.m_gravity_scale * test_case.time * test_case.time * 0.5f;
-
-        const auto actual_position = PredEngineTrait::predict_projectile_position(
-                projectile, test_case.pitch, test_case.yaw, test_case.time, gravity);
-
-        EXPECT_NEAR(actual_position.x, expected_position.x, 1e-5f);
-        EXPECT_NEAR(actual_position.y, expected_position.y, 1e-5f);
-        EXPECT_NEAR(actual_position.z, expected_position.z, 1e-5f);
-    }
-}
-
-TEST(PredEngineTrait, ReachabilityCheckUsesDistanceTolerance)
-{
-    constexpr Projectile projectile{
-            .m_origin = {0.f, 0.f, 0.f},
-            .m_launch_speed = 100.f,
-            .m_gravity_scale = 0.f,
-    };
-
-    EXPECT_FALSE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, {100.f, 0.f, 0.f}, 0.5f, 9.81f, 0.f));
-    EXPECT_TRUE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, {100.f, 0.f, 0.f}, 1.f, 9.81f, 0.f));
-    EXPECT_TRUE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, {101.f, 0.f, 0.f}, 1.f, 9.81f, 1.f));
-    EXPECT_TRUE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, {99.f, 0.f, 0.f}, 1.f, 9.81f, 1.f));
-    EXPECT_FALSE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, {101.f, 0.f, 0.f}, 1.f, 9.81f, 0.f));
-    EXPECT_FALSE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, {98.f, 0.f, 0.f}, 1.f, 9.81f, 1.f));
-}
-
-TEST(PredEngineTrait, ReachabilityCheckIncludesFloatingPointError)
-{
-    constexpr Projectile projectile{
-            .m_origin = {1.f, 2.f, 3.f},
-            .m_launch_offset = {0.1f, -0.2f, 0.3f},
-            .m_launch_speed = 100.f,
-            .m_gravity_scale = 1.f,
-    };
-    constexpr float gravity = 9.81f;
-    constexpr float time = 0.3f;
-    const auto target_position = PredEngineTrait::predict_projectile_position(projectile, 25.f, 45.f, time, gravity);
-
-    EXPECT_TRUE(PredEngineTrait::can_projectile_reach_target_at_time(projectile, target_position, time, gravity, 0.f));
-}
-
 TEST(PredEngineTrait, ZeroLaunchOffsetMatchesOriginalBehavior)
 {
     Projectile p;

tests/general/unit_test_proj_pred_engine_legacy_more.cpp

@@ -1,5 +1,4 @@
 #include <gtest/gtest.h>
-#include <limits>
 #include <omath/projectile_prediction/proj_pred_engine_legacy.hpp>
 #include <omath/projectile_prediction/projectile.hpp>
 #include <omath/projectile_prediction/target.hpp>
@@ -16,45 +15,25 @@ struct FakeEngineZeroGravity
     {
         return t.m_origin;
     }
-    static Vector3<float> predict_projectile_position(const Projectile& /*p*/, float /*pitch*/, float /*yaw*/,
+    static Vector3<float> predict_projectile_position(const Projectile& /*p*/, float /*pitch*/, float /*yaw*/, float /*time*/, float /*gravity*/) noexcept
-                                                      float /*time*/, float /*gravity*/) noexcept
     {
         // Return a fixed point matching typical target used in the test
         return Vector3<float>{100.f, 0.f, 0.f};
     }
-    static float calc_vector_2d_distance(const Vector3<float>& v) noexcept
+    static float calc_vector_2d_distance(const Vector3<float>& v) noexcept { return std::hypot(v.x, v.y); }
-    {
+    static float get_vector_height_coordinate(const Vector3<float>& v) noexcept { return v.z; }
-        return std::hypot(v.x, v.y);
+    static Vector3<float> calc_viewpoint_from_angles(const Projectile& /*p*/, Vector3<float> /*v*/, std::optional<float> /*maybe_pitch*/) noexcept
-    }
-    static float get_vector_height_coordinate(const Vector3<float>& v) noexcept
-    {
-        return v.z;
-    }
-    static Vector3<float> calc_viewpoint_from_angles(const Projectile& /*p*/, Vector3<float> /*v*/,
-                                                     std::optional<float> /*maybe_pitch*/) noexcept
     {
         return Vector3<float>{1.f, 2.f, 3.f};
     }
-    static float calc_direct_pitch_angle(const Vector3<float>& /*a*/, const Vector3<float>& /*b*/) noexcept
+    static float calc_direct_pitch_angle(const Vector3<float>& /*a*/, const Vector3<float>& /*b*/) noexcept { return 12.5f; }
-    {
+    static float calc_direct_yaw_angle(const Vector3<float>& /*a*/, const Vector3<float>& /*b*/) noexcept { return 0.f; }
-        return 12.5f;
-    }
-    static float calc_direct_yaw_angle(const Vector3<float>& /*a*/, const Vector3<float>& /*b*/) noexcept
-    {
-        return 0.f;
-    }
-    static bool can_projectile_reach_target_at_time(const Projectile& /*projectile*/,
-                                                    const Vector3<float>& /*target_position*/, float /*time*/,
-                                                    float /*gravity*/, float /*distance_tolerance*/)
-    {
-        return false;
-    }
 };
 
 TEST(ProjPredLegacyMore, ZeroGravityUsesDirectPitchAndReturnsViewpoint)
 {
-    constexpr Projectile proj{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 10.f, .m_gravity_scale = 0.f};
+    constexpr Projectile proj{ .m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 10.f, .m_gravity_scale = 0.f };
-    constexpr Target target{.m_origin = {100.f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
+    constexpr Target target{ .m_origin = {100.f, 0.f, 0.f}, .m_velocity = {0.f,0.f,0.f}, .m_is_airborne = false };
 
     using Engine = omath::projectile_prediction::ProjPredEngineLegacy<FakeEngineZeroGravity>;
     const Engine engine(9.8f, 0.1f, 5.f, 1e-3f);
@@ -138,77 +117,3 @@ TEST(ProjPredLegacyMore, AngleComputedButMissReturnsNullopt)
     const auto res = engine.maybe_calculate_aim_point(proj, target);
     EXPECT_FALSE(res.has_value());
 }
-
-TEST(ProjPredLegacyMore, IncludesMaximumSimulationTime)
-{
-    constexpr Projectile projectile{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 10.f, .m_gravity_scale = 0.f};
-    constexpr Target target{.m_origin = {10.f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
-    const omath::projectile_prediction::ProjPredEngineLegacy<> engine(0.f, 0.1f, 1.f, 0.f);
-
-    const auto result = engine.maybe_calculate_aim_point(projectile, target);
-
-    ASSERT_TRUE(result.has_value());
-    EXPECT_NEAR(result->x, target.m_origin.x, 1e-6f);
-    EXPECT_NEAR(result->y, target.m_origin.y, 1e-6f);
-    EXPECT_NEAR(result->z, target.m_origin.z, 1e-6f);
-}
-
-TEST(ProjPredLegacyMore, RejectsInvalidSimulationSteps)
-{
-    constexpr Projectile projectile{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 10.f, .m_gravity_scale = 0.f};
-    constexpr Target target{.m_origin = {10.f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
-
-    EXPECT_FALSE(omath::projectile_prediction::ProjPredEngineLegacy<>(0.f, 0.f, 1.f, 1.f)
-                         .maybe_calculate_aim_point(projectile, target));
-    EXPECT_FALSE(omath::projectile_prediction::ProjPredEngineLegacy<>(0.f, -0.1f, 1.f, 1.f)
-                         .maybe_calculate_aim_point(projectile, target));
-    EXPECT_FALSE(
-            omath::projectile_prediction::ProjPredEngineLegacy<>(0.f, std::numeric_limits<float>::infinity(), 1.f, 1.f)
-                    .maybe_calculate_aim_point(projectile, target));
-}
-
-TEST(ProjPredLegacyMore, RejectsInvalidProjectileSpeedAndTolerance)
-{
-    constexpr Target target{.m_origin = {1.f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
-    constexpr Projectile stopped_projectile{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 0.f, .m_gravity_scale = 0.f};
-    constexpr Projectile moving_projectile{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 10.f, .m_gravity_scale = 0.f};
-
-    EXPECT_FALSE(omath::projectile_prediction::ProjPredEngineLegacy<>(0.f, 0.1f, 1.f, 2.f)
-                         .maybe_calculate_aim_point(stopped_projectile, target));
-    EXPECT_FALSE(omath::projectile_prediction::ProjPredEngineLegacy<>(0.f, 0.1f, 1.f, -1.f)
-                         .maybe_calculate_aim_point(moving_projectile, target));
-}
-
-TEST(ProjPredLegacyMore, StablePitchFindsHighSpeedLowArc)
-{
-    constexpr Projectile projectile{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 10'000.f, .m_gravity_scale = 1.f};
-    constexpr Target target{.m_origin = {100.f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
-    const omath::projectile_prediction::ProjPredEngineLegacy<> engine(9.81f, 0.01f, 0.02f, 0.0001f);
-
-    const auto result = engine.maybe_calculate_aim_angles(projectile, target);
-
-    ASSERT_TRUE(result.has_value());
-    EXPECT_GT(result->pitch, 0.f);
-    EXPECT_NEAR(result->yaw, 0.f, 1e-6f);
-}
-
-TEST(ProjPredLegacyMore, CoincidentTargetReturnsLaunchOrigin)
-{
-    constexpr Projectile projectile{.m_origin = {5.f, 4.f, 3.f}, .m_launch_speed = 100.f, .m_gravity_scale = 1.f};
-    constexpr Target target{.m_origin = projectile.m_origin, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
-    const omath::projectile_prediction::ProjPredEngineLegacy<> engine(9.81f, 0.01f, 0.01f, 0.f);
-
-    const auto result = engine.maybe_calculate_aim_point(projectile, target);
-
-    ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(result.value(), projectile.m_origin);
-}
-
-TEST(ProjPredLegacyMore, TinyDistanceDoesNotUnderflowToAHit)
-{
-    constexpr Projectile projectile{.m_origin = {0.f, 0.f, 0.f}, .m_launch_speed = 1.f, .m_gravity_scale = 0.f};
-    constexpr Target target{.m_origin = {1e-30f, 0.f, 0.f}, .m_velocity = {0.f, 0.f, 0.f}, .m_is_airborne = false};
-    const omath::projectile_prediction::ProjPredEngineLegacy<> engine(0.f, 0.1f, 0.f, 0.f);
-
-    EXPECT_FALSE(engine.maybe_calculate_aim_point(projectile, target));
-}