improved prediction

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

@@ -87,9 +87,6 @@ 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:
@@ -709,7 +706,12 @@ jobs:
             -DVCPKG_MANIFEST_FEATURES="imgui;tests;lua"
 
       - name: Build
-        run: cmake --build cmake-build/build/${{ matrix.preset }} --target unit_tests omath
+        run: |
+          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,9 +116,6 @@ 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,22 +2,105 @@
 // Created by Vlad on 9/18/2025.
 //
 #include <benchmark/benchmark.h>
-#include <omath/omath.hpp>
+#include <omath/projectile_prediction/proj_pred_engine_legacy.hpp>
-using namespace omath;
 
-using namespace omath::projectile_prediction;
+namespace
-
-constexpr float simulation_time_step = 1.f / 1000.f;
-constexpr float hit_distance_tolerance = 5.f;
-
-void source_engine_projectile_prediction(benchmark::State& state)
 {
-    constexpr Target<float> target{.m_origin = {100, 0, 90}, .m_velocity = {0, 0, 0}, .m_is_airborne = false};
+    using Engine = omath::projectile_prediction::ProjPredEngineLegacy<>;
-    constexpr Projectile<float> projectile = {.m_origin = {3, 2, 1}, .m_launch_speed = 5000.f, .m_gravity_scale = 0.4f};
+    using Projectile = omath::projectile_prediction::Projectile<float>;
+    using Target = omath::projectile_prediction::Target<float>;
 
-    for ([[maybe_unused]] const auto _: state)
+    struct PredictionScenario
-        std::ignore = ProjPredEngineLegacy<>(400.f, simulation_time_step, 50.f, hit_distance_tolerance)
+    {
-                              .maybe_calculate_aim_point(projectile, target);
+        Projectile projectile;
-}
+        Target target;
+        float gravity;
+        float simulation_time_step;
+        float maximum_simulation_time;
+        float distance_tolerance;
+        bool expects_solution;
+    };
 
-BENCHMARK(source_engine_projectile_prediction)->Iterations(10'000);
+    void run_prediction_benchmark(benchmark::State& state, const PredictionScenario& scenario)
+    {
+        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,7 +5,6 @@
 #include <imgui.h>
 #include <imgui_impl_dx12.h>
 #include <imgui_impl_win32.h>
-#include <mutex>
 #include <tuple>
 #include <vector>
 
@@ -14,8 +13,6 @@ bool show_menu = true;
 
 namespace
 {
-    constexpr UINT srv_heap_size = 64;
-
     struct frame_context
     {
         ID3D12Resource* render_target = nullptr;
@@ -30,95 +27,15 @@ 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()
     {
@@ -298,62 +215,25 @@ namespace
 
     void init(IDXGISwapChain* swap_chain)
     {
-        IDXGISwapChain3* swap_chain3 = nullptr;
+        g_init_attempted = true;
-        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&swap_chain3))))
+
+        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&g_swap_chain))))
             return;
 
-        ID3D12Device* device = nullptr;
+        if (FAILED(swap_chain->GetDevice(IID_PPV_ARGS(&g_device))))
-        if (FAILED(swap_chain->GetDevice(IID_PPV_ARGS(&device))))
-        {
-            swap_chain3->Release();
             return;
-        }
-
-        IUnknown* swap_chain_identity = nullptr;
-        if (FAILED(swap_chain->QueryInterface(IID_PPV_ARGS(&swap_chain_identity))))
-        {
-            device->Release();
-            swap_chain3->Release();
-            return;
-        }
 
         DXGI_SWAP_CHAIN_DESC desc{};
-        if (FAILED(swap_chain->GetDesc(&desc)))
+        swap_chain->GetDesc(&desc);
-        {
-            swap_chain_identity->Release();
-            device->Release();
-            swap_chain3->Release();
-            return;
-        }
-
-        ID3D12CommandQueue* command_queue = take_command_queue_for_device(device);
-        if (!command_queue)
-        {
-            swap_chain_identity->Release();
-            device->Release();
-            swap_chain3->Release();
-            return;
-        }
-
-        g_init_attempted = true;
-        g_swap_chain = swap_chain3;
-        g_swap_chain_identity = swap_chain_identity;
-        g_device = device;
-        g_command_queue = command_queue;
         const UINT buffer_count = desc.BufferCount;
 
         {
             D3D12_DESCRIPTOR_HEAP_DESC heap_desc{};
             heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
-            heap_desc.NumDescriptors = srv_heap_size;
+            heap_desc.NumDescriptors = buffer_count;
             heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
             if (FAILED(g_device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&g_srv_heap))))
                 return;
-
-            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))
@@ -372,17 +252,9 @@ 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,
-        ImGui_ImplDX12_InitInfo init_info{};
+                            g_srv_heap->GetCPUDescriptorHandleForHeapStart(),
-        init_info.Device = g_device;
+                            g_srv_heap->GetGPUDescriptorHandleForHeapStart());
-        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();
@@ -392,10 +264,8 @@ namespace
                     if (!show_menu)
                         return std::nullopt;
 
-                    if (ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp))
+                    ImGui_ImplWin32_WndProcHandler(h, msg, wp, lp);
-                        return true;
+                    return true;
-
-                    return std::nullopt;
                 });
         std::ignore = mgr.hook_wnd_proc(desc.OutputWindow);
 
@@ -404,8 +274,13 @@ namespace
 
     void on_execute_command_lists(ID3D12CommandQueue* queue, UINT, ID3D12CommandList* const*)
     {
-        // The most recently used DIRECT queue is the best available proxy for the swap chain's presentation queue.
+        // The overlay records DIRECT command lists; executing them on COPY/COMPUTE queues can remove the device.
-        remember_direct_command_queue(queue);
+        if (!g_command_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)
@@ -413,7 +288,7 @@ namespace
         if (g_initialized)
             return true;
 
-        if (!g_init_attempted)
+        if (!g_init_attempted && g_command_queue)
             init(swap_chain);
 
         return false;
@@ -527,9 +402,6 @@ 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;
 
@@ -541,11 +413,8 @@ namespace
         std::ignore = submit_overlay_commands(*fc);
     }
 
-    void on_resize_buffers(IDXGISwapChain* swap_chain, UINT, UINT, UINT, DXGI_FORMAT, UINT)
+    void on_resize_buffers(IDXGISwapChain*, UINT, UINT, UINT, DXGI_FORMAT, UINT)
     {
-        if (!is_target_swap_chain(swap_chain))
-            return;
-
         wait_for_gpu();
         release_command_objects();
         release_frame_contexts();
@@ -562,36 +431,16 @@ 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,6 +6,8 @@
 #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
@@ -14,19 +16,58 @@ namespace omath::source_engine
     {
     public:
         [[nodiscard("projectile position result should not be discarded")]]
-        constexpr static Vector3<float> predict_projectile_position(const projectile_prediction::Projectile<float>& projectile,
+        constexpr static Vector3<float>
-                                                                    const float pitch, const float yaw,
+        predict_projectile_position(const projectile_prediction::Projectile<float>& projectile, const float pitch,
-                                                                    const float time, const float gravity) noexcept
+                                    const float yaw, const float time, const float gravity) noexcept
         {
             const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
-            auto current_pos = launch_pos
+            const auto pitch_angle = PitchAngle::from_degrees(-pitch);
-                               + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
+            const auto yaw_angle = YawAngle::from_degrees(yaw);
-                                                 RollAngle::from_degrees(0)})
+            const auto pitch_cos = pitch_angle.cos();
-                                         * projectile.m_launch_speed * time;
+            // Roll is always zero here, so this is the exact first column of the rotation matrix.
+            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
@@ -78,4 +119,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

@@ -1,130 +0,0 @@
-#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,7 +6,6 @@
 #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,6 +9,7 @@
 #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
@@ -17,9 +18,8 @@ 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,
+                     Vector3<ArithmeticType> v3, ArithmeticType pitch, ArithmeticType yaw, ArithmeticType time,
-                     ArithmeticType pitch, ArithmeticType yaw, ArithmeticType time, ArithmeticType gravity,
+                     ArithmeticType gravity, std::optional<ArithmeticType> maybe_pitch) {
-                     std::optional<ArithmeticType> maybe_pitch) {
                 {
                     T::predict_projectile_position(projectile, pitch, yaw, time, gravity)
                 } -> std::same_as<Vector3<ArithmeticType>>;
@@ -44,8 +44,7 @@ namespace omath::projectile_prediction
     class ProjPredEngineLegacy final : public ProjPredEngineInterface<ArithmeticType>
     {
     public:
-        explicit ProjPredEngineLegacy(const ArithmeticType gravity_constant,
+        explicit ProjPredEngineLegacy(const ArithmeticType gravity_constant, const ArithmeticType simulation_time_step,
-                                      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),
@@ -54,8 +53,9 @@ namespace omath::projectile_prediction
         }
 
         [[nodiscard]]
-        std::optional<Vector3<ArithmeticType>> maybe_calculate_aim_point(
+        std::optional<Vector3<ArithmeticType>>
-            const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target) const override
+        maybe_calculate_aim_point(const Projectile<ArithmeticType>& projectile,
+                                  const Target<ArithmeticType>& target) const override
         {
             const auto solution = find_solution(projectile, target);
             if (!solution)
@@ -66,15 +66,16 @@ namespace omath::projectile_prediction
         }
 
         [[nodiscard]]
-        std::optional<AimAngles<ArithmeticType>> maybe_calculate_aim_angles(
+        std::optional<AimAngles<ArithmeticType>>
-            const Projectile<ArithmeticType>& projectile, const Target<ArithmeticType>& target) const override
+        maybe_calculate_aim_angles(const Projectile<ArithmeticType>& projectile,
+                                   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(
+            const auto yaw = EngineTrait::calc_direct_yaw_angle(projectile.m_origin + projectile.m_launch_offset,
-                projectile.m_origin + projectile.m_launch_offset, solution->predicted_target_position);
+                                                                solution->predicted_target_position);
             return AimAngles<ArithmeticType>{solution->pitch, yaw};
         }
 
@@ -89,23 +90,39 @@ namespace omath::projectile_prediction
         std::optional<Solution> find_solution(const Projectile<ArithmeticType>& projectile,
                                               const Target<ArithmeticType>& target) const
         {
-            for (ArithmeticType time = ArithmeticType{0}; time < m_maximum_simulation_time;
+            if (!std::isfinite(m_simulation_time_step) || m_simulation_time_step <= ArithmeticType{0}
-                 time += m_simulation_time_step)
+                || !std::isfinite(m_maximum_simulation_time) || m_maximum_simulation_time < ArithmeticType{0}
+                || !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);
 
-                const auto projectile_pitch =
+                if (is_target_potentially_reachable(projectile, predicted_target_position, time))
-                        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()) [[unlikely]]
+                    if (projectile_pitch.has_value()) [[likely]]
-                    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, projectile_pitch.value(),
+                        if (is_projectile_reached_target(predicted_target_position, projectile,
-                                                  time))
+                                                         projectile_pitch.value(), yaw, time))
-                    continue;
+                            return Solution{predicted_target_position, projectile_pitch.value()};
+                    }
+                }
 
-                return Solution{predicted_target_position, projectile_pitch.value()};
+                if (time == m_maximum_simulation_time)
+                    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;
         }
@@ -144,29 +161,46 @@ 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
+            ArithmeticType root = launch_speed_sqr * launch_speed_sqr - bullet_gravity * ballistic_term;
-                                  - 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);
-            const ArithmeticType angle = std::atan((launch_speed_sqr - root) / (bullet_gravity * distance2d));
+            // This rationalized form avoids cancellation in launch_speed_sqr - root for low-angle shots.
+            const ArithmeticType angle = std::atan2(ballistic_term, distance2d * (launch_speed_sqr + root));
 
             return angles::radians_to_degrees(angle);
         }
 
         [[nodiscard]]
-        bool is_projectile_reached_target(const Vector3<ArithmeticType>& target_position,
+        bool is_target_potentially_reachable(const Projectile<ArithmeticType>& projectile,
-                                          const Projectile<ArithmeticType>& projectile,
+                                             const Vector3<ArithmeticType>& target_position,
-                                          const ArithmeticType pitch, const ArithmeticType time) const noexcept
+                                             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 ArithmeticType yaw, 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

@@ -1,13 +0,0 @@
-#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

@@ -1,13 +0,0 @@
-#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

@@ -1,13 +0,0 @@
-#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

@@ -1,13 +0,0 @@
-#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

@@ -1,13 +0,0 @@
-#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

@@ -1,13 +0,0 @@
-#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

@@ -1,13 +0,0 @@
-#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

@@ -1,13 +0,0 @@
-#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,75 +2,269 @@
 // Created by orange on 07.03.2026.
 //
 #ifdef OMATH_ENABLE_LUA
-#include "lua_engines_detail.hpp"
+#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
 
 namespace omath::lua
 {
     void LuaInterpreter::register_shared_types(sol::table& omath_table)
     {
-        auto types = omath_table["_types"].get_or_create<sol::table>();
+        auto t = omath_table["_types"].get_or_create<sol::table>();
 
-        detail::register_angle<detail::PitchAngle90>(types, "PitchAngle90");
+        register_angle<PitchAngle90>(t, "PitchAngle90");
-        detail::register_angle<detail::PitchAngle89>(types, "PitchAngle89");
+        register_angle<PitchAngle89>(t, "PitchAngle89");
-        detail::register_angle<detail::SharedYawRoll>(types, "YawRoll");
+        register_angle<SharedYawRoll>(t, "YawRoll");
-        detail::register_angle<detail::SharedFoV>(types, "FieldOfView");
+        register_angle<SharedFoV>(t, "FieldOfView");
 
-        types.new_usertype<projection::ViewPort>(
+        t.new_usertype<omath::projection::ViewPort>(
-                "ViewPort",
+                "ViewPort", sol::factories([](float w, float h) { return omath::projection::ViewPort{w, h}; }), "width",
-                sol::factories([](float width, float height) { return projection::ViewPort{width, height}; }),
+                sol::property([](const omath::projection::ViewPort& vp) { return vp.m_width; },
-                "width",
+                              [](omath::projection::ViewPort& vp, float val) { vp.m_width = val; }),
-                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 projection::ViewPort& view_port) { return view_port.m_height; },
+                sol::property([](const omath::projection::ViewPort& vp) { return vp.m_height; },
-                              [](projection::ViewPort& view_port, float value) { view_port.m_height = value; }),
+                              [](omath::projection::ViewPort& vp, float val) { vp.m_height = val; }),
-                "aspect_ratio", &projection::ViewPort::aspect_ratio);
+                "aspect_ratio", &omath::projection::ViewPort::aspect_ratio);
 
-        types.new_usertype<detail::ViewAngles90>(
+        t.new_usertype<ViewAngles90>(
                 "ViewAngles90",
-                sol::factories([](detail::PitchAngle90 pitch, detail::SharedYawRoll yaw, detail::SharedYawRoll roll)
+                sol::factories([](PitchAngle90 p, SharedYawRoll y, SharedYawRoll r) { return ViewAngles90{p, y, r}; }),
-                               { return detail::ViewAngles90{pitch, yaw, roll}; }),
                 "pitch",
-                sol::property([](const detail::ViewAngles90& view_angles) { return view_angles.pitch; },
+                sol::property([](const ViewAngles90& va) { return va.pitch; },
-                              [](detail::ViewAngles90& view_angles, const detail::PitchAngle90& value)
+                              [](ViewAngles90& va, const PitchAngle90& val) { va.pitch = val; }),
-                              { view_angles.pitch = value; }),
                 "yaw",
-                sol::property([](const detail::ViewAngles90& view_angles) { return view_angles.yaw; },
+                sol::property([](const ViewAngles90& va) { return va.yaw; },
-                              [](detail::ViewAngles90& view_angles, const detail::SharedYawRoll& value)
+                              [](ViewAngles90& va, const SharedYawRoll& val) { va.yaw = val; }),
-                              { view_angles.yaw = value; }),
                 "roll",
-                sol::property([](const detail::ViewAngles90& view_angles) { return view_angles.roll; },
+                sol::property([](const ViewAngles90& va) { return va.roll; },
-                              [](detail::ViewAngles90& view_angles, const detail::SharedYawRoll& value)
+                              [](ViewAngles90& va, const SharedYawRoll& val) { va.roll = val; }));
-                              { view_angles.roll = value; }));
 
-        types.new_usertype<detail::ViewAngles89>(
+        t.new_usertype<ViewAngles89>(
                 "ViewAngles89",
-                sol::factories([](detail::PitchAngle89 pitch, detail::SharedYawRoll yaw, detail::SharedYawRoll roll)
+                sol::factories([](PitchAngle89 p, SharedYawRoll y, SharedYawRoll r) { return ViewAngles89{p, y, r}; }),
-                               { return detail::ViewAngles89{pitch, yaw, roll}; }),
                 "pitch",
-                sol::property([](const detail::ViewAngles89& view_angles) { return view_angles.pitch; },
+                sol::property([](const ViewAngles89& va) { return va.pitch; },
-                              [](detail::ViewAngles89& view_angles, const detail::PitchAngle89& value)
+                              [](ViewAngles89& va, const PitchAngle89& val) { va.pitch = val; }),
-                              { view_angles.pitch = value; }),
                 "yaw",
-                sol::property([](const detail::ViewAngles89& view_angles) { return view_angles.yaw; },
+                sol::property([](const ViewAngles89& va) { return va.yaw; },
-                              [](detail::ViewAngles89& view_angles, const detail::SharedYawRoll& value)
+                              [](ViewAngles89& va, const SharedYawRoll& val) { va.yaw = val; }),
-                              { view_angles.yaw = value; }),
                 "roll",
-                sol::property([](const detail::ViewAngles89& view_angles) { return view_angles.roll; },
+                sol::property([](const ViewAngles89& va) { return va.roll; },
-                              [](detail::ViewAngles89& view_angles, const detail::SharedYawRoll& value)
+                              [](ViewAngles89& va, const SharedYawRoll& val) { va.roll = val; }));
-                              { view_angles.roll = value; }));
     }
 
     void LuaInterpreter::register_engines(sol::table& omath_table)
     {
-        detail::register_opengl_engine(omath_table);
+        register_engine<OpenGLEngineTraits>(omath_table, "opengl");
-        detail::register_frostbite_engine(omath_table);
+        register_engine<FrostbiteEngineTraits>(omath_table, "frostbite");
-        detail::register_iw_engine(omath_table);
+        register_engine<IWEngineTraits>(omath_table, "iw");
-        detail::register_source_engine(omath_table);
+        register_engine<SourceEngineTraits>(omath_table, "source");
-        detail::register_rage_engine(omath_table);
+        register_engine<RageEngineTraits>(omath_table, "rage");
-        detail::register_unity_engine(omath_table);
+        register_engine<UnityEngineTraits>(omath_table, "unity");
-        detail::register_unreal_engine(omath_table);
+        register_engine<UnrealEngineTraits, double>(omath_table, "unreal");
-        detail::register_cry_engine(omath_table);
+        register_engine<CryEngineTraits>(omath_table, "cry");
     }
-} // namespace omath::lua
+} // namespace omath::lua::detail
 #endif

source/lua/lua_engines_detail.hpp

@@ -1,142 +0,0 @@
-#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

@@ -1,34 +0,0 @@
-#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,4 +1,5 @@
 // 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>
@@ -77,6 +78,77 @@ 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,4 +1,5 @@
 #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>
@@ -15,25 +16,45 @@ struct FakeEngineZeroGravity
     {
         return t.m_origin;
     }
-    static Vector3<float> predict_projectile_position(const Projectile& /*p*/, float /*pitch*/, float /*yaw*/, float /*time*/, float /*gravity*/) noexcept
+    static Vector3<float> predict_projectile_position(const Projectile& /*p*/, float /*pitch*/, float /*yaw*/,
+                                                      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 { return std::hypot(v.x, v.y); }
+    static float calc_vector_2d_distance(const Vector3<float>& v) 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 std::hypot(v.x, v.y);
+    }
+    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 { return 12.5f; }
+    static float calc_direct_pitch_angle(const Vector3<float>& /*a*/, const Vector3<float>& /*b*/) noexcept
-    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);
@@ -117,3 +138,77 @@ 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));
+}