mkdocs improvement

.github/workflows/docs.yml

@@ -37,7 +37,7 @@ jobs:
           python-version: '3.x'
 
       - name: Install mkdocs and dependencies
-        run: pip install mkdocs mkdocs-bootswatch
+        run: pip install mkdocs mkdocs-material
 
       - name: Build documentation
         run: mkdocs build --strict

.github/workflows/release.yml

@@ -28,7 +28,7 @@ jobs:
           python-version: '3.x'
 
       - name: Install mkdocs and dependencies
-        run: pip install mkdocs mkdocs-bootswatch
+        run: pip install mkdocs mkdocs-material
 
       - name: Build documentation
         run: mkdocs build --strict

CMakeLists.txt

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

CREDITS.md

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

VERSION

@@ -1 +1 @@
-5.4.0
+5.2.0

docs/styles/custom-header.css

@@ -1,11 +1,18 @@
-/* Widen the navbar container */
-.navbar .container {
-    max-width: 100%;   /* adjust to your target width */
-    width: 95%;
+/* Material header tweaks */
+.md-header,
+.md-tabs {
+    background-color: #101014;
 }
 
-/* Tighter spacing between navbar items */
-.navbar-nav > li > a {
-    padding-left: 8px;
-    padding-right: 8px;
+.md-header {
+    border-bottom: 1px solid rgba(255, 152, 0, 0.28);
+}
+
+.md-tabs {
+    border-bottom: 1px solid rgba(255, 152, 0, 0.16);
+}
+
+.md-tabs__link--active,
+.md-tabs__link:hover {
+    color: #ffb74d;
 }

docs/styles/links.css

@@ -1,65 +1,44 @@
-/* Normal links */
-a {
-    color: orange;
+/* Material dark palette overrides */
+[data-md-color-scheme="slate"] {
+    --md-default-bg-color: #0f1117;
+    --md-default-fg-color: #e8eaed;
+    --md-primary-fg-color: #101014;
+    --md-primary-fg-color--light: #1a1a21;
+    --md-primary-fg-color--dark: #09090d;
+    --md-accent-fg-color: #ff9800;
+    --md-accent-fg-color--transparent: rgba(255, 152, 0, 0.14);
+    --md-typeset-a-color: #ffb74d;
+    --md-code-bg-color: #171a22;
+    --md-code-fg-color: #f5f7fa;
 }
 
-
-/* On hover/focus */
-a:hover,
-a:focus {
-    color: #ff9900; /* a slightly different orange, optional */
-}
-/* Navbar background */
-.navbar,
-.navbar-default,
-.navbar-inverse {
-    background-color: #a26228   !important;  /* your orange */
-    border-color: #ff6600 !important;
+.md-typeset a {
+    color: var(--md-typeset-a-color);
 }
 
-/* Navbar brand + links */
-.navbar .navbar-brand,
-.navbar .navbar-nav > li > a {
-    color: #ffffff !important;
+.md-typeset a:hover,
+.md-typeset a:focus {
+    color: #ffd180;
 }
 
-/* Active and hover states */
-.navbar .navbar-nav > .active > a,
-.navbar .navbar-nav > .active > a:focus,
-.navbar .navbar-nav > .active > a:hover,
-.navbar .navbar-nav > li > a:hover,
-.navbar .navbar-nav > li > a:focus {
-    color: #ffffff !important;
-}
-/* === DROPDOWN MENU BACKGROUND === */
-.navbar .dropdown-menu {
-    border-color: #ff6600 !important;
+.md-tabs__item--active > .md-tabs__link,
+.md-tabs__link:hover,
+.md-nav__link:hover,
+.md-nav__link:focus,
+.md-nav__link--active,
+.md-nav__item .md-nav__link--active {
+    color: #ffb74d;
 }
 
-/* Caret icon (the little triangle) */
-.navbar .dropdown-toggle .caret {
-    border-top-color: #ffffff !important;
-    border-bottom-color: #ffffff !important;
+.md-typeset .md-button {
+    border-color: #ff9800;
+    color: #ffb74d;
 }
 
-/* === BOOTSTRAP 3 STYLE ITEMS (mkdocs + bootswatch darkly often use this) === */
-.navbar .dropdown-menu > li > a {
-    color: #ffffff !important;
-}
-
-.navbar .dropdown-menu > li > a:hover,
-.navbar .dropdown-menu > li > a:focus {
-    background-color: #e65c00 !important; /* darker orange on hover */
-    color: #ffffff !important;
-}
-
-/* === BOOTSTRAP 4+ STYLE ITEMS (if your theme uses .dropdown-item) === */
-.navbar .dropdown-item {
-    color: #ffffff !important;
-}
-
-.navbar .dropdown-item:hover,
-.navbar .dropdown-item:focus {
-    background-color: #e65c00 !important;
-    color: #ffffff !important;
+.md-typeset .md-button:hover,
+.md-typeset .md-button:focus,
+.md-typeset .md-button--primary {
+    background-color: #ff9800;
+    border-color: #ff9800;
+    color: #111111;
 }

examples/example_dx11_hook/dllmain.cpp

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

examples/example_dx12_hook/dllmain.cpp

@@ -16,10 +16,7 @@ namespace
     struct frame_context
     {
         ID3D12Resource* render_target = nullptr;
-        // Each back buffer gets its own allocator because allocators cannot be reset while GPU work uses them.
-        ID3D12CommandAllocator* command_allocator = nullptr;
         D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = {};
-        UINT64 fence_value = 0;
     };
 
     bool g_initialized = false;
@@ -31,188 +28,9 @@ namespace
     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;
+    ID3D12CommandAllocator* g_command_allocator = nullptr;
     std::vector<frame_context> g_frames;
 
-    // This fence tracks only the overlay work submitted by this DLL, not the game's whole frame.
-    bool create_sync_objects()
-    {
-        if (g_fence)
-            return true;
-
-        if (FAILED(g_device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&g_fence))))
-            return false;
-
-        g_fence_event = CreateEvent(nullptr, FALSE, FALSE, nullptr);
-        if (!g_fence_event)
-        {
-            g_fence->Release();
-            g_fence = nullptr;
-            return false;
-        }
-
-        g_fence_value = 0;
-        return true;
-    }
-
-    bool wait_for_fence_value(UINT64 fence_value)
-    {
-        if (!g_fence || !g_fence_event || fence_value == 0 || g_fence->GetCompletedValue() >= fence_value)
-            return true;
-
-        if (FAILED(g_fence->SetEventOnCompletion(fence_value, g_fence_event)))
-            return false;
-
-        WaitForSingleObject(g_fence_event, INFINITE);
-        return true;
-    }
-
-    void wait_for_frame(frame_context& fc)
-    {
-        // The current back buffer's allocator is safe to reset only after its previous overlay pass completes.
-        if (wait_for_fence_value(fc.fence_value))
-            fc.fence_value = 0;
-    }
-
-    void wait_for_gpu()
-    {
-        // ResizeBuffers and shutdown must not release back buffers still referenced by queued overlay commands.
-        if (!g_command_queue || !g_fence || !g_fence_event)
-            return;
-
-        const UINT64 fence_value = ++g_fence_value;
-        if (FAILED(g_command_queue->Signal(g_fence, fence_value)))
-            return;
-
-        if (wait_for_fence_value(fence_value))
-        {
-            for (auto& fc : g_frames)
-                fc.fence_value = 0;
-        }
-    }
-
-    bool signal_frame(frame_context& fc)
-    {
-        if (!g_command_queue || !g_fence)
-            return false;
-
-        const UINT64 fence_value = ++g_fence_value;
-        if (FAILED(g_command_queue->Signal(g_fence, fence_value)))
-            return false;
-
-        fc.fence_value = fence_value;
-        return true;
-    }
-
-    void release_sync_objects()
-    {
-        if (g_fence_event)
-        {
-            CloseHandle(g_fence_event);
-            g_fence_event = nullptr;
-        }
-        if (g_fence)
-        {
-            g_fence->Release();
-            g_fence = nullptr;
-        }
-        g_fence_value = 0;
-    }
-
-    void release_frame_contexts()
-    {
-        for (auto& fc : g_frames)
-        {
-            if (fc.render_target)
-            {
-                fc.render_target->Release();
-                fc.render_target = nullptr;
-            }
-            if (fc.command_allocator)
-            {
-                fc.command_allocator->Release();
-                fc.command_allocator = nullptr;
-            }
-            fc.fence_value = 0;
-        }
-        g_frames.clear();
-
-        if (g_rtv_heap)
-        {
-            g_rtv_heap->Release();
-            g_rtv_heap = nullptr;
-        }
-    }
-
-    void release_command_objects()
-    {
-        if (g_command_list)
-        {
-            g_command_list->Release();
-            g_command_list = nullptr;
-        }
-    }
-
-    bool create_command_objects()
-    {
-        if (g_frames.empty() || !g_frames[0].command_allocator)
-            return false;
-
-        if (FAILED(g_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, g_frames[0].command_allocator,
-                                               nullptr, IID_PPV_ARGS(&g_command_list))))
-        {
-            release_command_objects();
-            return false;
-        }
-
-        g_command_list->Close();
-        return true;
-    }
-
-    bool create_render_targets(IDXGISwapChain* swap_chain)
-    {
-        // These references must be released before IDXGISwapChain::ResizeBuffers reaches the original function.
-        DXGI_SWAP_CHAIN_DESC desc{};
-        if (FAILED(swap_chain->GetDesc(&desc)))
-            return false;
-
-        const UINT buffer_count = desc.BufferCount;
-
-        D3D12_DESCRIPTOR_HEAP_DESC heap_desc{};
-        heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
-        heap_desc.NumDescriptors = buffer_count;
-        heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
-        heap_desc.NodeMask = 1;
-        if (FAILED(g_device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&g_rtv_heap))))
-            return false;
-
-        g_frames.resize(buffer_count);
-        const UINT rtv_size = g_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
-        D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = g_rtv_heap->GetCPUDescriptorHandleForHeapStart();
-
-        for (UINT i = 0; i < buffer_count; ++i)
-        {
-            g_frames[i].rtv_handle = rtv_handle;
-            if (FAILED(g_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
-                                                        IID_PPV_ARGS(&g_frames[i].command_allocator))))
-            {
-                release_frame_contexts();
-                return false;
-            }
-            if (FAILED(swap_chain->GetBuffer(i, IID_PPV_ARGS(&g_frames[i].render_target))))
-            {
-                release_frame_contexts();
-                return false;
-            }
-            g_device->CreateRenderTargetView(g_frames[i].render_target, nullptr, rtv_handle);
-            rtv_handle.ptr += rtv_size;
-        }
-
-        return true;
-    }
-
     void init(IDXGISwapChain* swap_chain)
     {
         g_init_attempted = true;
@@ -235,15 +53,37 @@ namespace
             if (FAILED(g_device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&g_srv_heap))))
                 return;
         }
+        {
+            D3D12_DESCRIPTOR_HEAP_DESC heap_desc{};
+            heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
+            heap_desc.NumDescriptors = buffer_count;
+            heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
+            heap_desc.NodeMask = 1;
+            if (FAILED(g_device->CreateDescriptorHeap(&heap_desc, IID_PPV_ARGS(&g_rtv_heap))))
+                return;
+        }
 
-        if (!create_render_targets(swap_chain))
+        if (FAILED(g_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
+                                                    IID_PPV_ARGS(&g_command_allocator))))
             return;
 
-        if (!create_command_objects())
-            return;
+        g_frames.resize(buffer_count);
+        const UINT rtv_size = g_device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
+        D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle = g_rtv_heap->GetCPUDescriptorHandleForHeapStart();
 
-        if (!create_sync_objects())
+        for (UINT i = 0; i < buffer_count; ++i)
+        {
+            g_frames[i].rtv_handle = rtv_handle;
+            if (FAILED(swap_chain->GetBuffer(i, IID_PPV_ARGS(&g_frames[i].render_target))))
+                return;
+            g_device->CreateRenderTargetView(g_frames[i].render_target, nullptr, rtv_handle);
+            rtv_handle.ptr += rtv_size;
+        }
+
+        if (FAILED(g_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, g_command_allocator, nullptr,
+                                               IID_PPV_ARGS(&g_command_list))))
             return;
+        g_command_list->Close();
 
         ImGui::CreateContext();
         ImGui::StyleColorsDark();
@@ -274,65 +114,27 @@ namespace
 
     void on_execute_command_lists(ID3D12CommandQueue* queue, UINT, ID3D12CommandList* const*)
     {
-        // The overlay records DIRECT command lists; executing them on COPY/COMPUTE queues can remove the device.
         if (!g_command_queue)
+            g_command_queue = queue;
+    }
+
+    void on_present(IDXGISwapChain* swap_chain, UINT, UINT)
+    {
+        if (!g_initialized)
         {
-            const D3D12_COMMAND_QUEUE_DESC desc = queue->GetDesc();
-            if (desc.Type == D3D12_COMMAND_LIST_TYPE_DIRECT)
-                g_command_queue = queue;
+            if (!g_init_attempted && g_command_queue)
+                init(swap_chain);
+            return;
         }
-    }
 
-    bool ensure_initialized(IDXGISwapChain* swap_chain)
-    {
-        if (g_initialized)
-            return true;
+        if (!g_command_queue)
+            return;
 
-        if (!g_init_attempted && g_command_queue)
-            init(swap_chain);
-
-        return false;
-    }
-
-    bool ensure_render_targets(IDXGISwapChain* swap_chain)
-    {
-        if (!g_frames.empty() && g_rtv_heap)
-            return true;
-
-        return create_render_targets(swap_chain);
-    }
-
-    bool ensure_command_list()
-    {
-        if (g_command_list)
-            return true;
-
-        return create_command_objects();
-    }
-
-    bool ensure_sync_ready()
-    {
-        if (g_fence)
-            return true;
-
-        return create_sync_objects();
-    }
-
-    bool ensure_present_resources(IDXGISwapChain* swap_chain)
-    {
-        if (!ensure_initialized(swap_chain) || !g_command_queue)
-            return false;
-
-        return ensure_render_targets(swap_chain) && ensure_command_list() && ensure_sync_ready();
-    }
-
-    bool begin_imgui_frame()
-    {
         if (GetAsyncKeyState(VK_INSERT) & 1)
             show_menu = !show_menu;
 
         if (!show_menu)
-            return false;
+            return;
 
         ImGui_ImplDX12_NewFrame();
         ImGui_ImplWin32_NewFrame();
@@ -340,97 +142,67 @@ namespace
         ImGui::GetIO().MouseDrawCursor = true;
         ImGui::ShowDemoWindow();
         ImGui::EndFrame();
-        return true;
-    }
 
-    frame_context* current_frame_context()
-    {
         const UINT buf_idx = g_swap_chain->GetCurrentBackBufferIndex();
-        if (buf_idx >= g_frames.size())
-            return nullptr;
+        auto& fc = g_frames[buf_idx];
 
-        return &g_frames[buf_idx];
-    }
+        g_command_allocator->Reset();
+        g_command_list->Reset(g_command_allocator, nullptr);
 
-    bool reset_overlay_command_list(frame_context& fc)
-    {
-        wait_for_frame(fc);
-
-        // Both resets depend on wait_for_frame(); otherwise DLSSG/Streamline can observe invalid GPU work.
-        if (FAILED(fc.command_allocator->Reset()))
-            return false;
-
-        if (FAILED(g_command_list->Reset(fc.command_allocator, nullptr)))
-            return false;
-
-        return true;
-    }
-
-    void transition_render_target(frame_context& fc, D3D12_RESOURCE_STATES before, D3D12_RESOURCE_STATES after)
-    {
         D3D12_RESOURCE_BARRIER barrier{};
         barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
         barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
         barrier.Transition.pResource = fc.render_target;
         barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
-        barrier.Transition.StateBefore = before;
-        barrier.Transition.StateAfter = after;
+        barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
+        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
         g_command_list->ResourceBarrier(1, &barrier);
-    }
-
-    void record_overlay_commands(frame_context& fc)
-    {
-        transition_render_target(fc, D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET);
         g_command_list->OMSetRenderTargets(1, &fc.rtv_handle, FALSE, nullptr);
         g_command_list->SetDescriptorHeaps(1, &g_srv_heap);
 
         ImGui::Render();
         ImGui_ImplDX12_RenderDrawData(ImGui::GetDrawData(), g_command_list);
 
-        transition_render_target(fc, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT);
-    }
-
-    bool submit_overlay_commands(frame_context& fc)
-    {
-        if (FAILED(g_command_list->Close()))
-            return false;
+        barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
+        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_PRESENT;
+        g_command_list->ResourceBarrier(1, &barrier);
+        g_command_list->Close();
 
         ID3D12CommandList* cmd_lists[] = {g_command_list};
         g_command_queue->ExecuteCommandLists(1, cmd_lists);
-        return signal_frame(fc);
-    }
-
-    void on_present(IDXGISwapChain* swap_chain, UINT, UINT)
-    {
-        if (!ensure_present_resources(swap_chain) || !begin_imgui_frame())
-            return;
-
-        frame_context* fc = current_frame_context();
-        if (!fc || !reset_overlay_command_list(*fc))
-            return;
-
-        record_overlay_commands(*fc);
-        std::ignore = submit_overlay_commands(*fc);
-    }
-
-    void on_resize_buffers(IDXGISwapChain*, UINT, UINT, UINT, DXGI_FORMAT, UINT)
-    {
-        wait_for_gpu();
-        release_command_objects();
-        release_frame_contexts();
     }
 
     void release_dx12_resources()
     {
-        wait_for_gpu();
-        release_command_objects();
-        release_frame_contexts();
-        release_sync_objects();
+        for (auto& fc : g_frames)
+        {
+            if (fc.render_target)
+            {
+                fc.render_target->Release();
+                fc.render_target = nullptr;
+            }
+        }
+        g_frames.clear();
+        if (g_command_allocator)
+        {
+            g_command_allocator->Release();
+            g_command_allocator = nullptr;
+        }
+        if (g_command_list)
+        {
+            g_command_list->Release();
+            g_command_list = nullptr;
+        }
         if (g_srv_heap)
         {
             g_srv_heap->Release();
             g_srv_heap = nullptr;
         }
+        if (g_rtv_heap)
+        {
+            g_rtv_heap->Release();
+            g_rtv_heap = nullptr;
+        }
         if (g_swap_chain)
         {
             g_swap_chain->Release();
@@ -449,20 +221,20 @@ BOOL WINAPI DllMain(HINSTANCE h_instance, DWORD reason, LPVOID)
     if (reason == DLL_PROCESS_ATTACH)
     {
         DisableThreadLibraryCalls(h_instance);
-        std::thread(
-                []()
+        CreateThread(
+                nullptr, 0,
+                [](LPVOID) -> DWORD
                 {
                     while (!GetModuleHandle("d3d12.dll"))
                         Sleep(100);
 
                     auto& mgr = omath::hooks::HooksManager::get();
                     mgr.set_on_present(on_present);
-                    mgr.set_on_resize_buffers(on_resize_buffers);
                     mgr.set_on_execute_command_lists(on_execute_command_lists);
                     std::ignore = mgr.hook_dx12();
                     return 0;
-                })
-                .detach();
+                },
+                nullptr, 0, nullptr);
     }
     else if (reason == DLL_PROCESS_DETACH)
     {

examples/example_dx9_hook/dllmain.cpp

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

include/omath/3d_primitives/aabb.hpp

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

include/omath/algorithm/radar.hpp

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

include/omath/engines/cry_engine/formulas.hpp

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

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

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

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

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

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

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

include/omath/engines/frostbite_engine/formulas.hpp

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

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

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

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

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

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

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

include/omath/engines/iw_engine/formulas.hpp

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

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

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

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

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

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

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

include/omath/engines/opengl_engine/formulas.hpp

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

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

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

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

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

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

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

include/omath/engines/rage_engine/formulas.hpp

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

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

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

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

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

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

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

include/omath/engines/source_engine/formulas.hpp

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

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

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

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

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

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

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

include/omath/engines/unity_engine/formulas.hpp

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

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

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

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

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

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

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

include/omath/engines/unreal_engine/formulas.hpp

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

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

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

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

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

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

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

include/omath/hud/canvas_box.hpp

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

include/omath/hud/entity_overlay.hpp

@@ -5,21 +5,13 @@
 #include "canvas_box.hpp"
 #include "entity_overlay_widgets.hpp"
 #include "hud_renderer_interface.hpp"
-#include "omath/3d_primitives/aabb.hpp"
 #include "omath/linear_algebra/vector2.hpp"
 #include "omath/utility/color.hpp"
-#include <expected>
 #include <memory>
 #include <string_view>
-#include <type_traits>
+
 namespace omath::hud
 {
-    enum class EntityOverlayError
-    {
-        NO_PROJECTED_VERTEX,
-        CENTER_PROJECTION_FAILED,
-    };
-
     class EntityOverlay final
     {
     public:
@@ -65,17 +57,13 @@ namespace omath::hud
                                              float offset = 5.f);
 
         // ── Labels ───────────────────────────────────────────────────────
-        EntityOverlay& add_right_label(const Color& color, float offset, widget::Outlined outlined,
-                                       const std::string_view& text);
+        EntityOverlay& add_right_label(const Color& color, float offset, widget::Outlined outlined, const std::string_view& text);
 
-        EntityOverlay& add_left_label(const Color& color, float offset, widget::Outlined outlined,
-                                      const std::string_view& text);
+        EntityOverlay& add_left_label(const Color& color, float offset, widget::Outlined outlined, const std::string_view& text);
 
-        EntityOverlay& add_top_label(const Color& color, float offset, widget::Outlined outlined,
-                                     std::string_view text);
+        EntityOverlay& add_top_label(const Color& color, float offset, widget::Outlined outlined, std::string_view text);
 
-        EntityOverlay& add_bottom_label(const Color& color, float offset, widget::Outlined outlined,
-                                        std::string_view text);
+        EntityOverlay& add_bottom_label(const Color& color, float offset, widget::Outlined outlined, std::string_view text);
 
         EntityOverlay& add_centered_top_label(const Color& color, float offset, widget::Outlined outlined,
                                               const std::string_view& text);
@@ -84,24 +72,24 @@ namespace omath::hud
                                                  const std::string_view& text);
 
         template<typename... Args>
-        EntityOverlay& add_right_label(const Color& color, const float offset, const widget::Outlined outlined,
-                                       std::format_string<Args...> fmt, Args&&... args)
+        EntityOverlay& add_right_label(const Color& color, const float offset, const widget::Outlined outlined, std::format_string<Args...> fmt,
+                                       Args&&... args)
         {
             return add_right_label(color, offset, outlined,
                                    std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
         }
 
         template<typename... Args>
-        EntityOverlay& add_left_label(const Color& color, const float offset, const widget::Outlined outlined,
-                                      std::format_string<Args...> fmt, Args&&... args)
+        EntityOverlay& add_left_label(const Color& color, const float offset, const widget::Outlined outlined, std::format_string<Args...> fmt,
+                                      Args&&... args)
         {
             return add_left_label(color, offset, outlined,
                                   std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
         }
 
         template<typename... Args>
-        EntityOverlay& add_top_label(const Color& color, const float offset, const widget::Outlined outlined,
-                                     std::format_string<Args...> fmt, Args&&... args)
+        EntityOverlay& add_top_label(const Color& color, const float offset, const widget::Outlined outlined, std::format_string<Args...> fmt,
+                                     Args&&... args)
         {
             return add_top_label(color, offset, outlined,
                                  std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
@@ -124,9 +112,8 @@ namespace omath::hud
         }
 
         template<typename... Args>
-        EntityOverlay& add_centered_bottom_label(const Color& color, const float offset,
-                                                 const widget::Outlined outlined, std::format_string<Args...> fmt,
-                                                 Args&&... args)
+        EntityOverlay& add_centered_bottom_label(const Color& color, const float offset, const widget::Outlined outlined,
+                                                 std::format_string<Args...> fmt, Args&&... args)
         {
             return add_centered_bottom_label(color, offset, outlined,
                                              std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
@@ -177,49 +164,6 @@ namespace omath::hud
             return *this;
         }
 
-        template<class Camera, class Aabb>
-        [[nodiscard]]
-        static std::expected<EntityOverlay, EntityOverlayError>
-        from_aabb(const Camera& camera, const Aabb& aabb, const float aspect,
-                  const std::shared_ptr<HudRendererInterface>& renderer)
-        {
-            using ProjectedVector = std::invoke_result_t<decltype(&Aabb::center), const Aabb&>;
-
-            ProjectedVector top;
-            ProjectedVector bottom;
-            bool has_projected_vertex = false;
-
-            for (const auto& vertex : aabb.vertices())
-            {
-                if (auto projected = camera.world_to_screen_unclipped(vertex))
-                {
-                    if (!has_projected_vertex)
-                    {
-                        top = *projected;
-                        bottom = *projected;
-                        has_projected_vertex = true;
-                        continue;
-                    }
-
-                    if (projected->y < top.y)
-                        top = *projected;
-                    if (projected->y > bottom.y)
-                        bottom = *projected;
-                }
-            }
-
-            if (!has_projected_vertex)
-                return std::unexpected(EntityOverlayError::NO_PROJECTED_VERTEX);
-
-            auto center = camera.world_to_screen_unclipped(aabb.center());
-            if (!center)
-                return std::unexpected(EntityOverlayError::CENTER_PROJECTION_FAILED);
-
-            const auto center_x = static_cast<float>(center->x);
-            return EntityOverlay{
-                    {center_x, static_cast<float>(top.y)}, {center_x, static_cast<float>(bottom.y)}, aspect, renderer};
-        }
-
     private:
         // optional<W> dispatch — enables when() conditional widgets
         template<typename W>

include/omath/internal/constexpr_math.hpp

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

include/omath/linear_algebra/mat.hpp

@@ -2,7 +2,6 @@
 // Created by vlad on 9/29/2024.
 //
 #pragma once
-#include "omath/internal/constexpr_math.hpp"
 #include "vector3.hpp"
 #include <algorithm>
 #include <array>
@@ -11,7 +10,6 @@
 #include <numeric>
 #include <sstream>
 #include <stdexcept>
-#include <type_traits>
 #include <utility>
 
 #ifdef OMATH_USE_AVX2
@@ -43,12 +41,12 @@ namespace omath
     enum class NDCDepthRange : uint8_t
     {
         NEGATIVE_ONE_TO_ONE = 0, // OpenGL: [-1.0, 1.0]
-        ZERO_TO_ONE // DirectX / Vulkan: [0.0, 1.0]
+        ZERO_TO_ONE              // DirectX / Vulkan: [0.0, 1.0]
     };
 
-    template<typename M1, typename M2> concept MatTemplateEqual =
-            (M1::rows == M2::rows) && (M1::columns == M2::columns)
-            && std::is_same_v<typename M1::value_type, typename M2::value_type> && (M1::store_type == M2::store_type);
+    template<typename M1, typename M2> concept MatTemplateEqual
+            = (M1::rows == M2::rows) && (M1::columns == M2::columns)
+              && std::is_same_v<typename M1::value_type, typename M2::value_type> && (M1::store_type == M2::store_type);
 
     template<size_t Rows = 0, size_t Columns = 0, class Type = float, MatStoreType StoreType = MatStoreType::ROW_MAJOR>
     requires std::is_arithmetic_v<Type>
@@ -151,8 +149,7 @@ namespace omath
             }
         }
 
-        [[nodiscard("You must use element reference")]] constexpr Type& at(const size_t row_index,
-                                                                           const size_t column_index)
+        [[nodiscard("You must use element reference")]] constexpr Type& at(const size_t row_index, const size_t column_index)
         {
             return const_cast<Type&>(std::as_const(*this).at(row_index, column_index));
         }
@@ -179,13 +176,6 @@ namespace omath
         operator*(const Mat<Columns, OtherColumns, Type, StoreType>& other) const
         {
 #ifdef OMATH_USE_AVX2
-            if (std::is_constant_evaluated())
-            {
-                if constexpr (StoreType == MatStoreType::ROW_MAJOR)
-                    return cache_friendly_multiply_row_major(other);
-                else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
-                    return cache_friendly_multiply_col_major(other);
-            }
             if constexpr (StoreType == MatStoreType::ROW_MAJOR)
                 return avx_multiply_row_major(other);
             else if constexpr (StoreType == MatStoreType::COLUMN_MAJOR)
@@ -202,11 +192,7 @@ namespace omath
 
         constexpr Mat& operator*=(const Type& f) noexcept
         {
-            std::ranges::for_each(m_data,
-                                  [&f](auto& val)
-                                  {
-                                      val *= f;
-                                  });
+            std::ranges::for_each(m_data, [&f](auto& val) { val *= f; });
             return *this;
         }
 
@@ -226,11 +212,7 @@ namespace omath
 
         constexpr Mat& operator/=(const Type& value) noexcept
         {
-            std::ranges::for_each(m_data,
-                                  [&value](auto& val)
-                                  {
-                                      val /= value;
-                                  });
+            std::ranges::for_each(m_data, [&value](auto& val) { val /= value; });
             return *this;
         }
 
@@ -406,7 +388,7 @@ namespace omath
         {
             const auto det = determinant();
 
-            if (internal::abs(det) < std::numeric_limits<Type>::epsilon())
+            if (std::abs(det) < std::numeric_limits<Type>::epsilon())
                 return std::nullopt;
 
             const auto transposed_mat = transposed();
@@ -596,13 +578,13 @@ namespace omath
     };
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard("You must use row matrix")]]
-    constexpr Mat<1, 4, Type, St> mat_row_from_vector(const Vector3<Type>& vector) noexcept
+    constexpr static Mat<1, 4, Type, St> mat_row_from_vector(const Vector3<Type>& vector) noexcept
     {
         return {{vector.x, vector.y, vector.z, 1}};
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR> [[nodiscard("You must use column matrix")]]
-    constexpr Mat<4, 1, Type, St> mat_column_from_vector(const Vector3<Type>& vector) noexcept
+    constexpr static Mat<4, 1, Type, St> mat_column_from_vector(const Vector3<Type>& vector) noexcept
     {
         return {{vector.x}, {vector.y}, {vector.z}, {1}};
     }
@@ -611,7 +593,8 @@ namespace omath
     [[nodiscard("You must use translation matrix")]]
     constexpr Mat<4, 4, Type, St> mat_translation(const Vector3<Type>& diff) noexcept
     {
-        return {
+        return
+        {
                 {1, 0, 0, diff.x},
                 {0, 1, 0, diff.y},
                 {0, 0, 1, diff.z},
@@ -639,11 +622,10 @@ namespace omath
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard("You must use extracted scale")]]
-    constexpr Vector3<Type> mat_extract_scale(const Mat<4, 4, Type, St>& mat) noexcept
+    Vector3<Type> mat_extract_scale(const Mat<4, 4, Type, St>& mat) noexcept
     {
-        auto column_length = [](const Type x, const Type y, const Type z)
-        {
-            return static_cast<Type>(internal::sqrt(x * x + y * y + z * z));
+        auto column_length = [](const Type x, const Type y, const Type z) {
+            return static_cast<Type>(std::sqrt(x * x + y * y + z * z));
         };
 
         const auto scale_x = column_length(mat.at(0, 0), mat.at(1, 0), mat.at(2, 0));
@@ -653,16 +635,16 @@ namespace omath
         constexpr auto epsilon = std::numeric_limits<Type>::epsilon();
 
         return {
-                internal::abs(scale_x) < epsilon ? Type{1} : scale_x,
-                internal::abs(scale_y) < epsilon ? Type{1} : scale_y,
-                internal::abs(scale_z) < epsilon ? Type{1} : scale_z,
+                std::abs(scale_x) < epsilon ? Type{1} : scale_x,
+                std::abs(scale_y) < epsilon ? Type{1} : scale_y,
+                std::abs(scale_z) < epsilon ? Type{1} : scale_z,
         };
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     requires std::is_floating_point_v<Type>
     [[nodiscard("You must use extracted rotation")]]
-    constexpr Vector3<Type> mat_extract_rotation_zyx(const Mat<4, 4, Type, St>& mat) noexcept
+    Vector3<Type> mat_extract_rotation_zyx(const Mat<4, 4, Type, St>& mat) noexcept
     {
         const auto scale = mat_extract_scale(mat);
         const auto m00 = mat.at(0, 0) / scale.x;
@@ -672,91 +654,105 @@ namespace omath
         const auto m22 = mat.at(2, 2) / scale.z;
 
         return {
-                angles::radians_to_degrees(internal::atan2(m21, m22)),
-                angles::radians_to_degrees(internal::asin(std::clamp(-m20, Type{-1}, Type{1}))),
-                angles::radians_to_degrees(internal::atan2(m10, m00)),
+                angles::radians_to_degrees(std::atan2(m21, m22)),
+                angles::radians_to_degrees(std::asin(std::clamp(-m20, Type{-1}, Type{1}))),
+                angles::radians_to_degrees(std::atan2(m10, m00)),
         };
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
     [[nodiscard("You must use rotation matrix")]]
-    constexpr Mat<4, 4, Type, St> mat_rotation_axis_x(const Angle& angle) noexcept
+    Mat<4, 4, Type, St> mat_rotation_axis_x(const Angle& angle) noexcept
     {
-        return {{1, 0, 0, 0}, {0, angle.cos(), -angle.sin(), 0}, {0, angle.sin(), angle.cos(), 0}, {0, 0, 0, 1}};
+        return
+        {
+            {1, 0,           0,            0},
+            {0, angle.cos(), -angle.sin(), 0},
+            {0, angle.sin(), angle.cos(),  0},
+            {0, 0,           0,            1}
+        };
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
     [[nodiscard("You must use rotation matrix")]]
-    constexpr Mat<4, 4, Type, St> mat_rotation_axis_y(const Angle& angle) noexcept
+    Mat<4, 4, Type, St> mat_rotation_axis_y(const Angle& angle) noexcept
     {
-        return {{angle.cos(), 0, angle.sin(), 0}, {0, 1, 0, 0}, {-angle.sin(), 0, angle.cos(), 0}, {0, 0, 0, 1}};
+        return
+        {
+            {angle.cos(),  0, angle.sin(), 0},
+            {0           , 1,           0, 0},
+            {-angle.sin(), 0, angle.cos(), 0},
+            {0           , 0,           0, 1}
+        };
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR, class Angle>
     [[nodiscard("You must use rotation matrix")]]
-    constexpr Mat<4, 4, Type, St> mat_rotation_axis_z(const Angle& angle) noexcept
+    Mat<4, 4, Type, St> mat_rotation_axis_z(const Angle& angle) noexcept
     {
-        return {
-                {angle.cos(), -angle.sin(), 0, 0},
-                {angle.sin(), angle.cos(), 0, 0},
-                {0, 0, 1, 0},
-                {0, 0, 0, 1},
+        return
+        {
+            {angle.cos(), -angle.sin(), 0, 0},
+            {angle.sin(),  angle.cos(), 0, 0},
+            {          0,        0,     1, 0},
+            {          0,        0,     0, 1},
         };
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR>
     [[nodiscard("You must use camera view matrix")]]
-    constexpr Mat<4, 4, Type, St> mat_camera_view(const Vector3<Type>& forward, const Vector3<Type>& right,
-                                                  const Vector3<Type>& up, const Vector3<Type>& camera_origin) noexcept
+    static Mat<4, 4, Type, St> mat_camera_view(const Vector3<Type>& forward, const Vector3<Type>& right,
+                                               const Vector3<Type>& up, const Vector3<Type>& camera_origin) noexcept
     {
-        return Mat<4, 4, Type, St>{
-                       {right.x, right.y, right.z, 0},
-                       {up.x, up.y, up.z, 0},
-                       {forward.x, forward.y, forward.z, 0},
-                       {0, 0, 0, 1},
-               }
-               * mat_translation<Type, St>(-camera_origin);
+        return  Mat<4, 4, Type, St>
+        {
+            {right.x,   right.y,   right.z,   0},
+            {up.x,      up.y,      up.z,      0},
+            {forward.x, forward.y, forward.z, 0},
+            {0,         0,         0,         1},
+        } * mat_translation<Type, St>(-camera_origin);
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St>
-    mat_perspective_left_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, const Type near,
-                                             const Type far) noexcept
+    [[nodiscard("You must use perspective matrix")]]
+    Mat<4, 4, Type, St> mat_perspective_left_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio,
+                                                    const Type near, const Type far) noexcept
     {
-        const auto fov_half_tan = internal::tan(angles::degrees_to_radians(field_of_view) / Type{2});
+        const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2});
+
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}},
-                    {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}},
-                    {Type{0}, Type{0}, far / (far - near), -(near * far) / (far - near)},
-                    {Type{0}, Type{0}, Type{1}, Type{0}}};
+            return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0},                Type{0},             Type{0}},
+                    {Type{0},                                 Type{1} / fov_half_tan, Type{0},             Type{0}},
+                    {Type{0},                                 Type{0},                far / (far - near), -(near * far) / (far - near)},
+                    {Type{0},                                 Type{0},                Type{1},            Type{0}}};
         else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}},
-                    {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}},
-                    {Type{0}, Type{0}, (far + near) / (far - near), -(Type{2} * near * far) / (far - near)},
-                    {Type{0}, Type{0}, Type{1}, Type{0}}};
+            return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0},                Type{0},                      Type{0}},
+                    {Type{0},                                 Type{1} / fov_half_tan, Type{0},                      Type{0}},
+                    {Type{0},                                 Type{0},                (far + near) / (far - near), -(Type{2} * near * far) / (far - near)},
+                    {Type{0},                                 Type{0},                Type{1},                     Type{0}}};
         else
             std::unreachable();
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St>
-    mat_perspective_right_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio, const Type near,
-                                              const Type far) noexcept
+    [[nodiscard("You must use perspective matrix")]]
+    Mat<4, 4, Type, St> mat_perspective_right_handed_vertical_fov(const Type field_of_view, const Type aspect_ratio,
+                                                     const Type near, const Type far) noexcept
     {
-        const auto fov_half_tan = internal::tan(angles::degrees_to_radians(field_of_view) / Type{2});
+        const auto fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / Type{2});
 
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}},
-                    {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}},
-                    {Type{0}, Type{0}, -far / (far - near), -(near * far) / (far - near)},
-                    {Type{0}, Type{0}, -Type{1}, Type{0}}};
+            return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0},                Type{0},             Type{0}},
+                    {Type{0},                                 Type{1} / fov_half_tan, Type{0},             Type{0}},
+                    {Type{0},                                 Type{0},                -far / (far - near), -(near * far) / (far - near)},
+                    {Type{0},                                 Type{0},                -Type{1},            Type{0}}};
         else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0}, Type{0}, Type{0}},
-                    {Type{0}, Type{1} / fov_half_tan, Type{0}, Type{0}},
-                    {Type{0}, Type{0}, -(far + near) / (far - near), -(Type{2} * near * far) / (far - near)},
-                    {Type{0}, Type{0}, -Type{1}, Type{0}}};
+            return {{Type{1} / (aspect_ratio * fov_half_tan), Type{0},                Type{0},                      Type{0}},
+                    {Type{0},                                 Type{1} / fov_half_tan, Type{0},                      Type{0}},
+                    {Type{0},                                 Type{0},                -(far + near) / (far - near), -(Type{2} * near * far) / (far - near)},
+                    {Type{0},                                 Type{0},                -Type{1},                     Type{0}}};
         else
             std::unreachable();
     }
@@ -766,93 +762,105 @@ namespace omath
     // X and Y scales derived as: X = 1 / tan(hfov/2), Y = aspect / tan(hfov/2).
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St>
-    mat_perspective_left_handed_horizontal_fov(const Type horizontal_fov, const Type aspect_ratio, const Type near,
-                                               const Type far) noexcept
+    [[nodiscard("You must use perspective matrix")]]
+    Mat<4, 4, Type, St> mat_perspective_left_handed_horizontal_fov(const Type horizontal_fov,
+                                                                   const Type aspect_ratio, const Type near,
+                                                                   const Type far) noexcept
     {
-        const auto inv_tan_half_hfov = Type{1} / internal::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
+        const auto inv_tan_half_hfov = Type{1} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
         const auto x_axis = inv_tan_half_hfov;
         const auto y_axis = inv_tan_half_hfov * aspect_ratio;
 
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return {{x_axis, Type{0}, Type{0}, Type{0}},
-                    {Type{0}, y_axis, Type{0}, Type{0}},
-                    {Type{0}, Type{0}, far / (far - near), -(near * far) / (far - near)},
-                    {Type{0}, Type{0}, Type{1}, Type{0}}};
+            return {{x_axis,     Type{0},    Type{0},             Type{0}},
+                    {Type{0},    y_axis,     Type{0},             Type{0}},
+                    {Type{0},    Type{0},    far / (far - near),  -(near * far) / (far - near)},
+                    {Type{0},    Type{0},    Type{1},             Type{0}}};
         else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return {{x_axis, Type{0}, Type{0}, Type{0}},
-                    {Type{0}, y_axis, Type{0}, Type{0}},
+            return {{x_axis,  Type{0}, Type{0},                     Type{0}},
+                    {Type{0}, y_axis,  Type{0},                     Type{0}},
                     {Type{0}, Type{0}, (far + near) / (far - near), -(Type{2} * near * far) / (far - near)},
-                    {Type{0}, Type{0}, Type{1}, Type{0}}};
+                    {Type{0}, Type{0}, Type{1},                     Type{0}}};
         else
             std::unreachable();
     }
 
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard("You must use perspective matrix")]] constexpr Mat<4, 4, Type, St>
-    mat_perspective_right_handed_horizontal_fov(const Type horizontal_fov, const Type aspect_ratio, const Type near,
-                                                const Type far) noexcept
+    [[nodiscard("You must use perspective matrix")]]
+    Mat<4, 4, Type, St> mat_perspective_right_handed_horizontal_fov(const Type horizontal_fov,
+                                                                    const Type aspect_ratio, const Type near,
+                                                                    const Type far) noexcept
     {
-        const auto inv_tan_half_hfov = Type{1} / internal::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
-
+        const auto inv_tan_half_hfov = Type{1} / std::tan(angles::degrees_to_radians(horizontal_fov) / Type{2});
         const auto x_axis = inv_tan_half_hfov;
         const auto y_axis = inv_tan_half_hfov * aspect_ratio;
 
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return {{x_axis, Type{0}, Type{0}, Type{0}},
-                    {Type{0}, y_axis, Type{0}, Type{0}},
+            return {{x_axis,  Type{0}, Type{0},             Type{0}},
+                    {Type{0}, y_axis,  Type{0},             Type{0}},
                     {Type{0}, Type{0}, -far / (far - near), -(near * far) / (far - near)},
-                    {Type{0}, Type{0}, -Type{1}, Type{0}}};
+                    {Type{0}, Type{0}, -Type{1},            Type{0}}};
         else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return {{x_axis, Type{0}, Type{0}, Type{0}},
-                    {Type{0}, y_axis, Type{0}, Type{0}},
+            return {{x_axis,  Type{0}, Type{0},                      Type{0}},
+                    {Type{0}, y_axis,  Type{0},                      Type{0}},
                     {Type{0}, Type{0}, -(far + near) / (far - near), -(Type{2} * near * far) / (far - near)},
-                    {Type{0}, Type{0}, -Type{1}, Type{0}}};
+                    {Type{0}, Type{0}, -Type{1},                     Type{0}}};
         else
             std::unreachable();
     }
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard("You must use ortho matrix")]] constexpr Mat<4, 4, Type, St>
-    mat_ortho_left_handed(const Type left, const Type right, const Type bottom, const Type top, const Type near,
-                          const Type far) noexcept
+    [[nodiscard("You must use ortho matrix")]]
+    Mat<4, 4, Type, St> mat_ortho_left_handed(const Type left, const Type right, const Type bottom, const Type top,
+                                              const Type near, const Type far) noexcept
     {
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return {{static_cast<Type>(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)},
-                    {0.f, static_cast<Type>(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)},
-                    {0.f, 0.f, static_cast<Type>(1) / (far - near), -near / (far - near)},
-                    {0.f, 0.f, 0.f, 1.f}};
+            return
+            {
+                { static_cast<Type>(2) / (right - left), 0.f,       0.f,    -(right + left) / (right - left)},
+                { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,    -(top + bottom) / (top - bottom)},
+                { 0.f,      0.f,       static_cast<Type>(1) / (far - near), -near / (far - near)            },
+                { 0.f,      0.f,       0.f,                                 1.f                             }
+            };
         else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return {{static_cast<Type>(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)},
-                    {0.f, static_cast<Type>(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)},
-                    {0.f, 0.f, static_cast<Type>(2) / (far - near), -(far + near) / (far - near)},
-                    {0.f, 0.f, 0.f, 1.f}};
+            return
+            {
+                { static_cast<Type>(2) / (right - left), 0.f,       0.f,    -(right + left) / (right - left)},
+                { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,    -(top + bottom) / (top - bottom)},
+                { 0.f,      0.f,       static_cast<Type>(2) / (far - near), -(far + near) / (far - near)    },
+                { 0.f,      0.f,       0.f,                                 1.f                             }
+            };
         else
             std::unreachable();
     }
     template<class Type = float, MatStoreType St = MatStoreType::ROW_MAJOR,
              NDCDepthRange DepthRange = NDCDepthRange::NEGATIVE_ONE_TO_ONE>
-    [[nodiscard("You must use ortho matrix")]] constexpr Mat<4, 4, Type, St>
-    mat_ortho_right_handed(const Type left, const Type right, const Type bottom, const Type top, const Type near,
-                           const Type far) noexcept
+    [[nodiscard("You must use ortho matrix")]]
+    Mat<4, 4, Type, St> mat_ortho_right_handed(const Type left, const Type right, const Type bottom, const Type top,
+                                               const Type near, const Type far) noexcept
     {
         if constexpr (DepthRange == NDCDepthRange::ZERO_TO_ONE)
-            return {{static_cast<Type>(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)},
-                    {0.f, static_cast<Type>(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)},
-                    {0.f, 0.f, -static_cast<Type>(1) / (far - near), -near / (far - near)},
-                    {0.f, 0.f, 0.f, 1.f}};
+            return
+            {
+                    { static_cast<Type>(2) / (right - left), 0.f,       0.f,     -(right + left) / (right - left)},
+                    { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,     -(top + bottom) / (top - bottom)},
+                    { 0.f,      0.f,       -static_cast<Type>(1) / (far - near), -near / (far - near)            },
+                    { 0.f,      0.f,       0.f,                                  1.f                             }
+            };
         else if constexpr (DepthRange == NDCDepthRange::NEGATIVE_ONE_TO_ONE)
-            return {{static_cast<Type>(2) / (right - left), 0.f, 0.f, -(right + left) / (right - left)},
-                    {0.f, static_cast<Type>(2) / (top - bottom), 0.f, -(top + bottom) / (top - bottom)},
-                    {0.f, 0.f, -static_cast<Type>(2) / (far - near), -(far + near) / (far - near)},
-                    {0.f, 0.f, 0.f, 1.f}};
+            return
+            {
+                    { static_cast<Type>(2) / (right - left), 0.f,       0.f,     -(right + left) / (right - left)},
+                    { 0.f,      static_cast<Type>(2) / (top - bottom),  0.f,     -(top + bottom) / (top - bottom)},
+                    { 0.f,      0.f,       -static_cast<Type>(2) / (far - near), -(far + near) / (far - near)    },
+                    { 0.f,      0.f,       0.f,                                  1.f                             }
+            };
         else
             std::unreachable();
     }
     template<class T = float, MatStoreType St = MatStoreType::COLUMN_MAJOR>
-    constexpr Mat<4, 4, T, St> mat_look_at_left_handed(const Vector3<T>& eye, const Vector3<T>& center,
-                                                       const Vector3<T>& up)
+   Mat<4, 4, T, St> mat_look_at_left_handed(const Vector3<T>& eye, const Vector3<T>& center, const Vector3<T>& up)
     {
         const Vector3<T> f = (center - eye).normalized();
         const Vector3<T> s = f.cross(up).normalized();
@@ -861,8 +869,7 @@ namespace omath
     }
 
     template<class T = float, MatStoreType St = MatStoreType::COLUMN_MAJOR>
-    constexpr Mat<4, 4, T, St> mat_look_at_right_handed(const Vector3<T>& eye, const Vector3<T>& center,
-                                                        const Vector3<T>& up)
+    Mat<4, 4, T, St>mat_look_at_right_handed(const Vector3<T>& eye, const Vector3<T>& center, const Vector3<T>& up)
     {
         const Vector3<T> f = (center - eye).normalized();
         const Vector3<T> s = f.cross(up).normalized();
@@ -873,7 +880,7 @@ namespace omath
 } // namespace omath
 
 template<size_t Rows, size_t Columns, class Type, omath::MatStoreType StoreType>
-struct std::formatter<omath::Mat<Rows, Columns, Type, StoreType>> final // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Mat<Rows, Columns, Type, StoreType>> // NOLINT(*-dcl58-cpp)
 {
     using MatType = omath::Mat<Rows, Columns, Type, StoreType>;
     [[nodiscard("You must use parse iterator")]]

include/omath/linear_algebra/triangle.hpp

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

include/omath/linear_algebra/vector2.hpp

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

include/omath/linear_algebra/vector3.hpp

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

include/omath/linear_algebra/vector4.hpp

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

include/omath/pathfinding/a_star.hpp

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

include/omath/projection/camera.hpp

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

include/omath/rev_eng/internal_rev_object.hpp

@@ -21,20 +21,36 @@
 
 namespace omath::rev_eng
 {
+    template<std::size_t N>
+    struct FixedString final
+    {
+        char data[N]{};
+        // ReSharper disable once CppNonExplicitConvertingConstructor
+        constexpr FixedString(const char (&str)[N]) noexcept // NOLINT(*-explicit-constructor)
+        {
+            for (std::size_t i = 0; i < N; ++i)
+                data[i] = str[i];
+        }
+        // ReSharper disable once CppNonExplicitConversionOperator
+        constexpr operator std::string_view() const noexcept // NOLINT(*-explicit-constructor)
+        {
+            return {data, N - 1};
+        }
+    };
+    template<std::size_t N>
+    FixedString(const char (&)[N]) -> FixedString<N>;
 
     class InternalReverseEngineeredObject
     {
     protected:
         template<class Type>
-        [[nodiscard("You must use value")]]
-        Type& get_by_offset(const std::ptrdiff_t offset) noexcept
+        [[nodiscard]] Type& get_by_offset(const std::ptrdiff_t offset)
         {
             return *reinterpret_cast<Type*>(reinterpret_cast<std::uintptr_t>(this) + offset);
         }
 
         template<class Type>
-        [[nodiscard("You must use value")]]
-        const Type& get_by_offset(const std::ptrdiff_t offset) const noexcept
+        [[nodiscard]] const Type& get_by_offset(const std::ptrdiff_t offset) const
         {
             return *reinterpret_cast<Type*>(reinterpret_cast<std::uintptr_t>(this) + offset);
         }
@@ -60,16 +76,14 @@ namespace omath::rev_eng
             return reinterpret_cast<MethodType>(const_cast<void*>(ptr))(this, arg_list...);
         }
 
-        template<PatternScanner::ConstevalPattern ModuleName, PatternScanner::ConstevalPattern Pattern,
-                 class ReturnType>
+        template<FixedString ModuleName, FixedString Pattern, class ReturnType>
         ReturnType call_method(auto... arg_list)
         {
             static const auto* address = resolve_pattern(ModuleName, Pattern);
             return call_method<ReturnType>(address, arg_list...);
         }
 
-        template<PatternScanner::ConstevalPattern ModuleName, PatternScanner::ConstevalPattern Pattern,
-                 class ReturnType>
+        template<FixedString ModuleName, FixedString Pattern, class ReturnType>
         ReturnType call_method(auto... arg_list) const
         {
             static const auto* address = resolve_pattern(ModuleName, Pattern);
@@ -77,15 +91,14 @@ namespace omath::rev_eng
         }
 
         template<class ReturnType>
-        ReturnType call_method(const std::string_view& module_name, const std::string_view& pattern, auto... arg_list)
+        ReturnType call_method(const std::string_view& module_name,const std::string_view& pattern, auto... arg_list)
         {
             static const auto* address = resolve_pattern(module_name, pattern);
             return call_method<ReturnType>(address, arg_list...);
         }
 
         template<class ReturnType>
-        ReturnType call_method(const std::string_view& module_name, const std::string_view& pattern,
-                               auto... arg_list) const
+        ReturnType call_method(const std::string_view& module_name,const std::string_view& pattern, auto... arg_list) const
         {
             static const auto* address = resolve_pattern(module_name, pattern);
             return call_method<ReturnType>(address, arg_list...);
@@ -106,24 +119,26 @@ namespace omath::rev_eng
         template<std::ptrdiff_t TableOffset, std::size_t Id, class ReturnType>
         ReturnType call_virtual_method(auto... arg_list)
         {
-            auto sub_this = reinterpret_cast<void*>(reinterpret_cast<std::uintptr_t>(this) + TableOffset);
+            auto sub_this = reinterpret_cast<void*>(
+                reinterpret_cast<std::uintptr_t>(this) + TableOffset);
             const auto vtable = *reinterpret_cast<void***>(sub_this);
 #ifdef _MSC_VER
             using Fn = ReturnType(__thiscall*)(void*, decltype(arg_list)...);
 #else
-            using Fn = ReturnType (*)(void*, decltype(arg_list)...);
+            using Fn = ReturnType(*)(void*, decltype(arg_list)...);
 #endif
             return reinterpret_cast<Fn>(vtable[Id])(sub_this, arg_list...);
         }
         template<std::ptrdiff_t TableOffset, std::size_t Id, class ReturnType>
         ReturnType call_virtual_method(auto... arg_list) const
         {
-            auto sub_this = reinterpret_cast<const void*>(reinterpret_cast<std::uintptr_t>(this) + TableOffset);
+            auto sub_this = reinterpret_cast<const void*>(
+                reinterpret_cast<std::uintptr_t>(this) + TableOffset);
             const auto vtable = *reinterpret_cast<void* const* const*>(sub_this);
 #ifdef _MSC_VER
             using Fn = ReturnType(__thiscall*)(const void*, decltype(arg_list)...);
 #else
-            using Fn = ReturnType (*)(const void*, decltype(arg_list)...);
+            using Fn = ReturnType(*)(const void*, decltype(arg_list)...);
 #endif
             return reinterpret_cast<Fn>(vtable[Id])(sub_this, arg_list...);
         }
@@ -146,8 +161,8 @@ namespace omath::rev_eng
             return reinterpret_cast<const void*>(*result);
         }
 
-        [[nodiscard("You forgot to use module base address")]]
-        static const void* get_module_base(const std::string_view module_name) noexcept
+        [[nodiscard]]
+        static const void* get_module_base(const std::string_view module_name)
         {
 #ifdef _WIN32
             return GetModuleHandleA(module_name.data());

include/omath/trigonometry/angle.hpp

@@ -3,7 +3,6 @@
 //
 
 #pragma once
-#include "omath/internal/constexpr_math.hpp"
 #include "omath/trigonometry/angles.hpp"
 #include <algorithm>
 #include <format>
@@ -71,31 +70,31 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Type sin() const noexcept
+        Type sin() const noexcept
         {
-            return internal::sin(as_radians());
+            return std::sin(as_radians());
         }
 
         [[nodiscard]]
-        constexpr Type cos() const noexcept
+        Type cos() const noexcept
         {
-            return internal::cos(as_radians());
+            return std::cos(as_radians());
         }
 
         [[nodiscard]]
-        constexpr Type tan() const noexcept
+        Type tan() const noexcept
         {
-            return internal::tan(as_radians());
+            return std::tan(as_radians());
         }
 
         [[nodiscard]]
-        constexpr Type atan() const noexcept
+        Type atan() const noexcept
         {
-            return internal::atan(as_radians());
+            return std::atan(as_radians());
         }
 
         [[nodiscard]]
-        constexpr Type cot() const noexcept
+        Type cot() const noexcept
         {
             return cos() / sin();
         }
@@ -125,7 +124,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Angle operator+(const Angle& other) const noexcept
+        constexpr Angle operator+(const Angle& other) noexcept
         {
             if constexpr (flags == AngleFlags::Normalized)
                 return Angle{angles::wrap_angle(m_angle + other.m_angle, min, max)};
@@ -140,7 +139,7 @@ namespace omath
         }
 
         [[nodiscard]]
-        constexpr Angle operator-(const Angle& other) const noexcept
+        constexpr Angle operator-(const Angle& other) noexcept
         {
             return operator+(-other);
         }
@@ -154,11 +153,10 @@ namespace omath
 } // namespace omath
 
 template<class T, T MinV, T MaxV, omath::AngleFlags F>
-struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char> final // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char> // NOLINT(*-dcl58-cpp)
 {
     using AngleT = omath::Angle<T, MinV, MaxV, F>;
 
-    [[nodiscard]]
     static constexpr auto parse(std::format_parse_context& ctx)
     {
         return ctx.begin();
@@ -175,11 +173,10 @@ struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char> final // NOLINT(*-dc
 
 // wchar_t formatter
 template<class T, T MinV, T MaxV, omath::AngleFlags F>
-struct std::formatter<omath::Angle<T, MinV, MaxV, F>, wchar_t> final // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Angle<T, MinV, MaxV, F>, wchar_t> // NOLINT(*-dcl58-cpp)
 {
     using AngleT = omath::Angle<T, MinV, MaxV, F>;
 
-    [[nodiscard]]
     static constexpr auto parse(std::wformat_parse_context& ctx)
     {
         return ctx.begin();
@@ -196,11 +193,10 @@ struct std::formatter<omath::Angle<T, MinV, MaxV, F>, wchar_t> final // NOLINT(*
 
 // wchar_t formatter
 template<class T, T MinV, T MaxV, omath::AngleFlags F>
-struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char8_t> final // NOLINT(*-dcl58-cpp)
+struct std::formatter<omath::Angle<T, MinV, MaxV, F>, char8_t> // NOLINT(*-dcl58-cpp)
 {
     using AngleT = omath::Angle<T, MinV, MaxV, F>;
 
-    [[nodiscard]]
     static constexpr auto parse(std::wformat_parse_context& ctx)
     {
         return ctx.begin();

include/omath/trigonometry/angles.hpp

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

include/omath/trigonometry/view_angles.hpp

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

include/omath/utility/color.hpp

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

include/omath/utility/elf_pattern_scan.hpp

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

include/omath/utility/macho_pattern_scan.hpp

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

include/omath/utility/pattern_scan.hpp

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

include/omath/utility/pe_pattern_scan.hpp

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

mkdocs.yml

@@ -1,6 +1,27 @@
 site_name: OMATH Docs
 theme:
-  name: darkly
+  name: material
+  font:
+    text: Roboto
+    code: Roboto Mono
+  palette:
+    scheme: slate
+    primary: black
+    accent: orange
+  features:
+    - navigation.instant
+    - navigation.tracking
+    - navigation.sections
+    - navigation.top
+    - search.highlight
+    - content.code.copy
+markdown_extensions:
+  - pymdownx.highlight:
+      anchor_linenums: true
+      line_spans: __span
+      pygments_lang_class: true
+  - pymdownx.inlinehilite
+  - pymdownx.superfences
 extra_css:
   - styles/center.css
   - styles/custom-header.css

modules/omath.cppm

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

source/engines/cry_engine/formulas.cpp

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

source/engines/cry_engine/traits/camera_trait.cpp

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

source/engines/frostbite_engine/formulas.cpp

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

source/engines/frostbite_engine/traits/camera_trait.cpp

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

source/engines/iw_engine/formulas.cpp

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

source/engines/iw_engine/traits/camera_trait.cpp

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

source/engines/opengl_engine/formulas.cpp

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

source/engines/opengl_engine/traits/camera_trait.cpp

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

source/engines/rage_engine/formulas.cpp

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

source/engines/rage_engine/traits/camera_trait.cpp

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

source/engines/source_engine/formulas.cpp

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

source/engines/source_engine/traits/camera_trait.cpp

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

source/engines/unity_engine/formulas.cpp

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

source/engines/unity_engine/traits/camera_trait.cpp

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

source/engines/unreal_engine/formulas.cpp

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

source/engines/unreal_engine/traits/camera_trait.cpp

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

source/lua/lua_collision.cpp

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

source/utility/elf_pattern_scan.cpp

@@ -304,8 +304,8 @@ namespace
                 elf_headers);
     }
 
-    template<class FileHeader, class SectionHeader, class ScanPattern>
-    std::optional<std::uintptr_t> scan_in_module_impl(const std::byte* base, const ScanPattern scan_pattern,
+    template<class FileHeader, class SectionHeader>
+    std::optional<std::uintptr_t> scan_in_module_impl(const std::byte* base, const std::string_view pattern,
                                                       const std::string_view target_section_name)
     {
         const auto* file_header = reinterpret_cast<const FileHeader*>(base);
@@ -336,14 +336,13 @@ namespace
                 continue;
 
             const auto* section_begin = base + static_cast<std::size_t>(section->sh_addr);
-            const auto scan_range =
-                    std::span<const std::byte>{section_begin, static_cast<std::size_t>(section->sh_size)};
+            const auto* section_end = section_begin + static_cast<std::size_t>(section->sh_size);
 
-            const auto target_offset = scan_pattern(scan_range);
-            if (!target_offset.has_value())
+            const auto scan_result = omath::PatternScanner::scan_for_pattern(section_begin, section_end, pattern);
+            if (scan_result == section_end)
                 return std::nullopt;
 
-            return reinterpret_cast<std::uintptr_t>(section_begin + target_offset.value());
+            return reinterpret_cast<std::uintptr_t>(scan_result);
         }
 
         return std::nullopt;
@@ -375,58 +374,15 @@ namespace omath
         if (!arch.has_value()) [[unlikely]]
             return std::nullopt;
 
-        const auto scan_pattern =
-                [&pattern](const std::span<const std::byte> section_data) -> std::optional<std::ptrdiff_t>
-        {
-            const auto scan_result =
-                    PatternScanner::scan_for_pattern(section_data.begin(), section_data.end(), pattern);
-
-            if (scan_result == section_data.end())
-                return std::nullopt;
-
-            return scan_result - section_data.begin();
-        };
-
         if (arch == FileArch::x64)
             return scan_in_module_impl<Elf64Ehdr, Elf64Shdr>(static_cast<const std::byte*>(module_base_address),
-                                                             scan_pattern, target_section_name);
+                                                             pattern, target_section_name);
         if (arch == FileArch::x32)
             return scan_in_module_impl<Elf32Ehdr, Elf32Shdr>(static_cast<const std::byte*>(module_base_address),
-                                                             scan_pattern, target_section_name);
+                                                             pattern, target_section_name);
 
         std::unreachable();
     }
-
-    std::optional<std::uintptr_t>
-    ElfPatternScanner::scan_for_pattern_in_loaded_module(const void* module_base_address,
-                                                         const std::string_view& target_section_name,
-                                                         const SectionScanFunction scan_pattern)
-    {
-        if (module_base_address == nullptr) [[unlikely]]
-            return std::nullopt;
-
-        const auto* base = static_cast<const std::byte*>(module_base_address);
-
-        constexpr std::string_view valid_elf_signature = "\x7F"
-                                                         "ELF";
-        if (std::string_view{reinterpret_cast<const char*>(base), valid_elf_signature.size()} != valid_elf_signature)
-            return std::nullopt;
-
-        const auto ei_class_value = static_cast<uint8_t>(base[ei_class]);
-        const auto arch = ei_class_value == elfclass64   ? FileArch::x64
-                          : ei_class_value == elfclass32 ? FileArch::x32
-                                                         : std::optional<FileArch>{};
-        if (!arch.has_value()) [[unlikely]]
-            return std::nullopt;
-
-        if (arch == FileArch::x64)
-            return scan_in_module_impl<Elf64Ehdr, Elf64Shdr>(base, scan_pattern, target_section_name);
-        if (arch == FileArch::x32)
-            return scan_in_module_impl<Elf32Ehdr, Elf32Shdr>(base, scan_pattern, target_section_name);
-
-        std::unreachable();
-    }
-
     std::optional<SectionScanResult>
     ElfPatternScanner::scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
                                                 const std::string_view& pattern,
@@ -449,26 +405,6 @@ namespace omath
                                  .target_offset = offset};
     }
 
-    std::optional<SectionScanResult>
-    ElfPatternScanner::scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
-                                                const std::string_view& target_section_name,
-                                                const SectionScanFunction scan_pattern)
-    {
-        const auto section = get_elf_section_by_name(path_to_file, target_section_name);
-
-        if (!section.has_value()) [[unlikely]]
-            return std::nullopt;
-
-        const auto target_offset = scan_pattern(std::span<const std::byte>{section->data.data(), section->data.size()});
-
-        if (!target_offset.has_value())
-            return std::nullopt;
-
-        return SectionScanResult{.virtual_base_addr = section->virtual_base_addr,
-                                 .raw_base_addr = section->raw_base_addr,
-                                 .target_offset = target_offset.value()};
-    }
-
     std::optional<SectionScanResult>
     ElfPatternScanner::scan_for_pattern_in_memory_file(const std::span<const std::byte> file_data,
                                                        const std::string_view& pattern,
@@ -491,24 +427,4 @@ namespace omath
                                  .raw_base_addr = section->raw_base_addr,
                                  .target_offset = offset};
     }
-
-    std::optional<SectionScanResult>
-    ElfPatternScanner::scan_for_pattern_in_memory_file(const std::span<const std::byte> file_data,
-                                                       const std::string_view& target_section_name,
-                                                       const SectionScanFunction scan_pattern)
-    {
-        const auto section = get_elf_section_by_name_from_memory(file_data, target_section_name);
-
-        if (!section.has_value()) [[unlikely]]
-            return std::nullopt;
-
-        const auto target_offset = scan_pattern(std::span<const std::byte>{section->data.data(), section->data.size()});
-
-        if (!target_offset.has_value())
-            return std::nullopt;
-
-        return SectionScanResult{.virtual_base_addr = section->virtual_base_addr,
-                                 .raw_base_addr = section->raw_base_addr,
-                                 .target_offset = target_offset.value()};
-    }
 } // namespace omath

source/utility/macho_pattern_scan.cpp

@@ -316,8 +316,8 @@ namespace
                     data, section_name);
 
         if (magic == mh_magic_32 || magic == mh_cigam_32)
-            return extract_section_from_memory_impl<MachHeader32, SegmentCommand32, Section32, lc_segment>(
-                    data, section_name);
+            return extract_section_from_memory_impl<MachHeader32, SegmentCommand32, Section32, lc_segment>(data,
+                                                                                                           section_name);
 
         return std::nullopt;
     }
@@ -344,9 +344,8 @@ namespace
         return extract_section_impl<MachHeader32, SegmentCommand32, Section32, lc_segment>(file, section_name);
     }
 
-    template<typename HeaderType, typename SegmentType, typename SectionType, std::uint32_t segment_cmd,
-             class ScanPattern>
-    std::optional<std::uintptr_t> scan_in_module_impl(const std::byte* base, const ScanPattern scan_pattern,
+    template<typename HeaderType, typename SegmentType, typename SectionType, std::uint32_t segment_cmd>
+    std::optional<std::uintptr_t> scan_in_module_impl(const std::byte* base, const std::string_view pattern,
                                                       const std::string_view target_section_name)
     {
         const auto* header = reinterpret_cast<const HeaderType*>(base);
@@ -375,13 +374,12 @@ namespace
                     continue;
                 }
                 const auto* section_begin = base + static_cast<std::size_t>(section->addr);
-                const auto scan_range =
-                        std::span<const std::byte>{section_begin, static_cast<std::size_t>(section->size)};
+                const auto* section_end = section_begin + static_cast<std::size_t>(section->size);
 
-                const auto target_offset = scan_pattern(scan_range);
+                const auto scan_result = omath::PatternScanner::scan_for_pattern(section_begin, section_end, pattern);
 
-                if (target_offset.has_value())
-                    return reinterpret_cast<std::uintptr_t>(section_begin + target_offset.value());
+                if (scan_result != section_end)
+                    return reinterpret_cast<std::uintptr_t>(scan_result);
             }
         }
 
@@ -406,48 +404,12 @@ namespace omath
         std::uint32_t magic{};
         std::memcpy(&magic, base, sizeof(magic));
 
-        const auto scan_pattern =
-                [&pattern](const std::span<const std::byte> section_data) -> std::optional<std::ptrdiff_t>
-        {
-            const auto scan_result =
-                    PatternScanner::scan_for_pattern(section_data.begin(), section_data.end(), pattern);
-
-            if (scan_result == section_data.end())
-                return std::nullopt;
-
-            return scan_result - section_data.begin();
-        };
-
         if (magic == mh_magic_64 || magic == mh_cigam_64)
-            return scan_in_module_impl<MachHeader64, SegmentCommand64, Section64, lc_segment_64>(base, scan_pattern,
+            return scan_in_module_impl<MachHeader64, SegmentCommand64, Section64, lc_segment_64>(base, pattern,
                                                                                                  target_section_name);
 
         if (magic == mh_magic_32 || magic == mh_cigam_32)
-            return scan_in_module_impl<MachHeader32, SegmentCommand32, Section32, lc_segment>(base, scan_pattern,
-                                                                                              target_section_name);
-
-        return std::nullopt;
-    }
-
-    std::optional<std::uintptr_t>
-    MachOPatternScanner::scan_for_pattern_in_loaded_module(const void* module_base_address,
-                                                           const std::string_view& target_section_name,
-                                                           const SectionScanFunction scan_pattern)
-    {
-        if (module_base_address == nullptr) [[unlikely]]
-            return std::nullopt;
-
-        const auto* base = static_cast<const std::byte*>(module_base_address);
-
-        std::uint32_t magic{};
-        std::memcpy(&magic, base, sizeof(magic));
-
-        if (magic == mh_magic_64 || magic == mh_cigam_64)
-            return scan_in_module_impl<MachHeader64, SegmentCommand64, Section64, lc_segment_64>(base, scan_pattern,
-                                                                                                 target_section_name);
-
-        if (magic == mh_magic_32 || magic == mh_cigam_32)
-            return scan_in_module_impl<MachHeader32, SegmentCommand32, Section32, lc_segment>(base, scan_pattern,
+            return scan_in_module_impl<MachHeader32, SegmentCommand32, Section32, lc_segment>(base, pattern,
                                                                                               target_section_name);
 
         return std::nullopt;
@@ -476,27 +438,6 @@ namespace omath
                                  .target_offset = offset};
     }
 
-    std::optional<SectionScanResult>
-    MachOPatternScanner::scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
-                                                  const std::string_view& target_section_name,
-                                                  const SectionScanFunction scan_pattern)
-    {
-        const auto macho_section = get_macho_section_by_name(path_to_file, target_section_name);
-
-        if (!macho_section.has_value()) [[unlikely]]
-            return std::nullopt;
-
-        const auto target_offset =
-                scan_pattern(std::span<const std::byte>{macho_section->data.data(), macho_section->data.size()});
-
-        if (!target_offset.has_value())
-            return std::nullopt;
-
-        return SectionScanResult{.virtual_base_addr = macho_section->virtual_base_addr,
-                                 .raw_base_addr = macho_section->raw_base_addr,
-                                 .target_offset = target_offset.value()};
-    }
-
     std::optional<SectionScanResult>
     MachOPatternScanner::scan_for_pattern_in_memory_file(const std::span<const std::byte> file_data,
                                                          const std::string_view& pattern,
@@ -519,24 +460,4 @@ namespace omath
                                  .raw_base_addr = section->raw_base_addr,
                                  .target_offset = offset};
     }
-
-    std::optional<SectionScanResult>
-    MachOPatternScanner::scan_for_pattern_in_memory_file(const std::span<const std::byte> file_data,
-                                                         const std::string_view& target_section_name,
-                                                         const SectionScanFunction scan_pattern)
-    {
-        const auto section = get_macho_section_by_name_from_memory(file_data, target_section_name);
-
-        if (!section.has_value()) [[unlikely]]
-            return std::nullopt;
-
-        const auto target_offset = scan_pattern(std::span<const std::byte>{section->data.data(), section->data.size()});
-
-        if (!target_offset.has_value())
-            return std::nullopt;
-
-        return SectionScanResult{.virtual_base_addr = section->virtual_base_addr,
-                                 .raw_base_addr = section->raw_base_addr,
-                                 .target_offset = target_offset.value()};
-    }
 } // namespace omath

source/utility/pe_pattern_scan.cpp

@@ -234,12 +234,8 @@ namespace
     constexpr bool invalid_nt_header_file(const NtHeaderVariant& variant)
     {
         constexpr std::uint32_t nt_hdr_magic = 0x4550;
-        return std::visit(
-                [&nt_hdr_magic](const auto& header) -> bool
-                {
-                    return header.signature != nt_hdr_magic;
-                },
-                variant);
+        return std::visit([&nt_hdr_magic](const auto& header) -> bool { return header.signature != nt_hdr_magic; },
+                          variant);
     }
 
     struct ExtractedSection final
@@ -266,7 +262,8 @@ namespace
         if (nt_off + sizeof(ImageNtHeaders<NtArchitecture::x32_bit>) > data.size())
             return std::nullopt;
 
-        const auto* x86_hdrs = reinterpret_cast<const ImageNtHeaders<NtArchitecture::x32_bit>*>(data.data() + nt_off);
+        const auto* x86_hdrs =
+                reinterpret_cast<const ImageNtHeaders<NtArchitecture::x32_bit>*>(data.data() + nt_off);
 
         NtHeaderVariant nt_headers;
         if (x86_hdrs->optional_header.magic == opt_hdr32_magic)
@@ -287,8 +284,8 @@ namespace
                 [&data, &section_name, nt_off](const auto& concrete_headers) -> std::optional<ExtractedSection>
                 {
                     constexpr std::size_t sig_size = sizeof(concrete_headers.signature);
-                    const auto section_table_off =
-                            nt_off + sig_size + sizeof(FileHeader) + concrete_headers.file_header.size_optional_header;
+                    const auto section_table_off = nt_off + sig_size + sizeof(FileHeader)
+                                                   + concrete_headers.file_header.size_optional_header;
 
                     for (std::size_t i = 0; i < concrete_headers.file_header.num_sections; ++i)
                     {
@@ -438,65 +435,6 @@ namespace omath
                 },
                 nt_header_variant.value());
     }
-
-    std::optional<std::uintptr_t>
-    PePatternScanner::scan_for_pattern_in_loaded_module(const void* module_base_address,
-                                                        const std::string_view& target_section_name,
-                                                        const SectionScanFunction scan_pattern)
-    {
-        const auto base_address = reinterpret_cast<std::uintptr_t>(module_base_address);
-        const auto* base_bytes = static_cast<const std::byte*>(module_base_address);
-
-        if (!base_address)
-            return std::nullopt;
-
-        const auto* dos_header = static_cast<const DosHeader*>(module_base_address);
-
-        if (invalid_dos_header_file(*dos_header)) [[unlikely]]
-            return std::nullopt;
-
-        const auto nt_header_variant = get_nt_header_from_loaded_module(module_base_address);
-
-        if (!nt_header_variant) [[unlikely]]
-            return std::nullopt;
-
-        return std::visit(
-                [base_bytes, base_address, lfanew = dos_header->e_lfanew, &target_section_name,
-                 scan_pattern](const auto& nt_header) -> std::optional<std::uintptr_t>
-                {
-                    constexpr std::size_t signature_size = sizeof(nt_header.signature);
-                    const auto section_table_off = static_cast<std::size_t>(lfanew) + signature_size
-                                                   + sizeof(FileHeader) + nt_header.file_header.size_optional_header;
-
-                    const auto* section_table = reinterpret_cast<const SectionHeader*>(base_bytes + section_table_off);
-
-                    for (std::size_t i = 0; i < nt_header.file_header.num_sections; ++i)
-                    {
-                        const auto* section = section_table + i;
-
-                        if (std::string_view{section->name} != target_section_name
-                            || section->size_raw_data == 0)
-                            continue;
-
-                        const auto section_size = section->virtual_size != 0
-                                                          ? static_cast<std::size_t>(section->virtual_size)
-                                                          : static_cast<std::size_t>(section->size_raw_data);
-
-                        const auto* section_begin =
-                                reinterpret_cast<const std::byte*>(base_address + section->virtual_address);
-                        const auto scan_range = std::span<const std::byte>{section_begin, section_size};
-
-                        const auto target_offset = scan_pattern(scan_range);
-
-                        if (target_offset.has_value())
-                            return reinterpret_cast<std::uintptr_t>(section_begin + target_offset.value());
-                    }
-
-                    return std::nullopt;
-                },
-                nt_header_variant.value());
-    }
-
     std::optional<SectionScanResult>
     PePatternScanner::scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
                                                const std::string_view& pattern,
@@ -519,27 +457,6 @@ namespace omath
                                  .target_offset = offset};
     }
 
-    std::optional<SectionScanResult>
-    PePatternScanner::scan_for_pattern_in_file(const std::filesystem::path& path_to_file,
-                                               const std::string_view& target_section_name,
-                                               const SectionScanFunction scan_pattern)
-    {
-        const auto pe_section = extract_section_from_pe_file(path_to_file, target_section_name);
-
-        if (!pe_section.has_value()) [[unlikely]]
-            return std::nullopt;
-
-        const auto target_offset =
-                scan_pattern(std::span<const std::byte>{pe_section->data.data(), pe_section->data.size()});
-
-        if (!target_offset.has_value())
-            return std::nullopt;
-
-        return SectionScanResult{.virtual_base_addr = pe_section->virtual_base_addr,
-                                 .raw_base_addr = pe_section->raw_base_addr,
-                                 .target_offset = target_offset.value()};
-    }
-
     std::optional<SectionScanResult>
     PePatternScanner::scan_for_pattern_in_memory_file(const std::span<const std::byte> file_data,
                                                       const std::string_view& pattern,
@@ -562,25 +479,4 @@ namespace omath
                                  .raw_base_addr = pe_section->raw_base_addr,
                                  .target_offset = offset};
     }
-
-    std::optional<SectionScanResult>
-    PePatternScanner::scan_for_pattern_in_memory_file(const std::span<const std::byte> file_data,
-                                                      const std::string_view& target_section_name,
-                                                      const SectionScanFunction scan_pattern)
-    {
-        const auto pe_section = extract_section_from_pe_memory(file_data, target_section_name);
-
-        if (!pe_section.has_value()) [[unlikely]]
-            return std::nullopt;
-
-        const auto target_offset =
-                scan_pattern(std::span<const std::byte>{pe_section->data.data(), pe_section->data.size()});
-
-        if (!target_offset.has_value())
-            return std::nullopt;
-
-        return SectionScanResult{.virtual_base_addr = pe_section->virtual_base_addr,
-                                 .raw_base_addr = pe_section->raw_base_addr,
-                                 .target_offset = target_offset.value()};
-    }
 } // namespace omath

tests/CMakeLists.txt

@@ -7,11 +7,6 @@ include(GoogleTest)
 file(GLOB_RECURSE UNIT_TESTS_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/general/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/engines/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp")
 add_executable(${PROJECT_NAME} ${UNIT_TESTS_SOURCES} main.cpp)
 
-if(OMATH_ENABLE_MODULES)
-    set_target_properties(${PROJECT_NAME} PROPERTIES CXX_SCAN_FOR_MODULES ON)
-    target_sources(${PROJECT_NAME} PRIVATE modules/unit_test_module.cpp)
-endif()
-
 set_target_properties(
     ${PROJECT_NAME}
     PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/out/${CMAKE_BUILD_TYPE}"

tests/engines/unit_test_cry_engine.cpp

@@ -9,96 +9,6 @@
 #include <ranges>
 
 using namespace omath;
-
-namespace
-{
-    constexpr bool close_to(const float actual, const float expected, const float epsilon)
-    {
-        const float diff = actual - expected;
-        return (diff < 0.0f ? -diff : diff) <= epsilon;
-    }
-
-    constexpr bool vec_close_to(const Vector3<float>& actual, const Vector3<float>& expected, const float epsilon)
-    {
-        return close_to(actual.x, expected.x, epsilon) && close_to(actual.y, expected.y, epsilon)
-               && close_to(actual.z, expected.z, epsilon);
-    }
-} // namespace
-
-static_assert(
-        []
-        {
-            constexpr omath::cry_engine::ViewAngles angles{};
-            constexpr auto forward = omath::cry_engine::forward_vector(angles);
-            constexpr auto right = omath::cry_engine::right_vector(angles);
-            constexpr auto up = omath::cry_engine::up_vector(angles);
-            constexpr auto rotation = omath::cry_engine::rotation_matrix(angles);
-
-            return vec_close_to(forward, omath::cry_engine::k_abs_forward, 1e-5f)
-                   && vec_close_to(right, omath::cry_engine::k_abs_right, 1e-5f)
-                   && vec_close_to(up, omath::cry_engine::k_abs_up, 1e-5f) && close_to(rotation.at(0, 0), 1.0f, 1e-5f)
-                   && close_to(rotation.at(1, 1), 1.0f, 1e-5f) && close_to(rotation.at(2, 2), 1.0f, 1e-5f)
-                   && close_to(rotation.at(3, 3), 1.0f, 1e-5f);
-        }(),
-        "CryEngine basis vectors should be constexpr with embedded constexpr math");
-
-static_assert(
-        []
-        {
-            constexpr auto view = omath::cry_engine::calc_view_matrix({}, {});
-            return close_to(view.at(0, 0), 1.0f, 1e-5f) && close_to(view.at(1, 2), 1.0f, 1e-5f)
-                   && close_to(view.at(2, 1), 1.0f, 1e-5f) && close_to(view.at(3, 3), 1.0f, 1e-5f);
-        }(),
-        "CryEngine view matrix should be constexpr with embedded constexpr math");
-
-static_assert(
-        []
-        {
-            constexpr auto transform = mat_translation<float, MatStoreType::ROW_MAJOR>({1.0f, 2.0f, 3.0f})
-                                       * mat_scale<float, MatStoreType::ROW_MAJOR>({2.0f, 3.0f, 4.0f});
-            constexpr auto origin = omath::cry_engine::extract_origin(transform);
-            constexpr auto scale = omath::cry_engine::extract_scale(transform);
-
-            return vec_close_to(origin, {1.0f, 2.0f, 3.0f}, 1e-5f) && vec_close_to(scale, {2.0f, 3.0f, 4.0f}, 1e-5f);
-        }(),
-        "CryEngine transform extraction should be constexpr with embedded constexpr math");
-
-static_assert(
-        []
-        {
-            constexpr auto projection = omath::cry_engine::calc_perspective_projection_matrix(
-                    90.0f, 1.0f, 1.0f, 11.0f, NDCDepthRange::ZERO_TO_ONE);
-            return close_to(projection.at(0, 0), 1.0f, 1e-5f) && close_to(projection.at(1, 1), 1.0f, 1e-5f)
-                   && close_to(projection.at(2, 2), 1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f)
-                   && close_to(projection.at(3, 2), 1.0f, 1e-5f);
-        }(),
-        "CryEngine projection matrix should be constexpr with embedded constexpr math");
-
-static_assert(
-        []
-        {
-            constexpr auto angles =
-                    omath::cry_engine::CameraTrait::calc_look_at_angle({}, omath::cry_engine::k_abs_forward);
-            constexpr auto view = omath::cry_engine::CameraTrait::calc_view_matrix(angles, {});
-            constexpr auto projection = omath::cry_engine::CameraTrait::calc_projection_matrix(
-                    projection::FieldOfView::from_degrees(90.0f), {1.0f, 1.0f}, 1.0f, 11.0f,
-                    NDCDepthRange::ZERO_TO_ONE);
-
-            return close_to(angles.pitch.as_degrees(), 0.0f, 1e-5f) && close_to(angles.yaw.as_degrees(), 0.0f, 1e-5f)
-                   && close_to(angles.roll.as_degrees(), 0.0f, 1e-5f) && close_to(view.at(0, 0), 1.0f, 1e-5f)
-                   && close_to(view.at(2, 1), 1.0f, 1e-5f) && close_to(projection.at(0, 0), 1.0f, 1e-5f)
-                   && close_to(projection.at(1, 1), 1.0f, 1e-5f) && close_to(projection.at(2, 2), 1.1f, 1e-5f)
-                   && close_to(projection.at(2, 3), -1.1f, 1e-5f) && close_to(projection.at(3, 2), 1.0f, 1e-5f);
-        }(),
-        "CryEngine CameraTrait should be constexpr with embedded constexpr math");
-
-static_assert(omath::cry_engine::units_to_centimeters(100.0f) == 1.0f);
-static_assert(omath::cry_engine::units_to_meters(2.0f) == 2.0f);
-static_assert(omath::cry_engine::units_to_kilometers(2000.0f) == 2.0f);
-static_assert(omath::cry_engine::centimeters_to_units(1.0f) == 100.0f);
-static_assert(omath::cry_engine::meters_to_units(2.0f) == 2.0f);
-static_assert(omath::cry_engine::kilometers_to_units(2.0f) == 2000.0f);
-
 TEST(unit_test_cry_engine, look_at_forward)
 {
     const auto angles = cry_engine::CameraTrait::calc_look_at_angle({}, cry_engine::k_abs_forward);
@@ -341,9 +251,11 @@ TEST(unit_test_cry_engine, ViewAnglesAsVector3Zero)
 
 TEST(unit_test_cry_engine, ViewAnglesAsVector3Values)
 {
-    const omath::cry_engine::ViewAngles angles{omath::cry_engine::PitchAngle::from_degrees(45.f),
-                                               omath::cry_engine::YawAngle::from_degrees(-90.f),
-                                               omath::cry_engine::RollAngle::from_degrees(30.f)};
+    const omath::cry_engine::ViewAngles angles{
+        omath::cry_engine::PitchAngle::from_degrees(45.f),
+        omath::cry_engine::YawAngle::from_degrees(-90.f),
+        omath::cry_engine::RollAngle::from_degrees(30.f)
+    };
     const auto vec = angles.as_vector3();
 
     EXPECT_FLOAT_EQ(vec.x, 45.f);
@@ -354,9 +266,11 @@ TEST(unit_test_cry_engine, ViewAnglesAsVector3Values)
 TEST(unit_test_cry_engine, ViewAnglesAsVector3ClampedPitch)
 {
     // Pitch is clamped to [-90, 90]
-    const omath::cry_engine::ViewAngles angles{omath::cry_engine::PitchAngle::from_degrees(120.f),
-                                               omath::cry_engine::YawAngle::from_degrees(0.f),
-                                               omath::cry_engine::RollAngle::from_degrees(0.f)};
+    const omath::cry_engine::ViewAngles angles{
+        omath::cry_engine::PitchAngle::from_degrees(120.f),
+        omath::cry_engine::YawAngle::from_degrees(0.f),
+        omath::cry_engine::RollAngle::from_degrees(0.f)
+    };
     const auto vec = angles.as_vector3();
 
     EXPECT_FLOAT_EQ(vec.x, 90.f);
@@ -365,9 +279,11 @@ TEST(unit_test_cry_engine, ViewAnglesAsVector3ClampedPitch)
 TEST(unit_test_cry_engine, ViewAnglesAsVector3NormalizedYaw)
 {
     // Yaw is normalized to [-180, 180], 270 wraps to -90
-    const omath::cry_engine::ViewAngles angles{omath::cry_engine::PitchAngle::from_degrees(0.f),
-                                               omath::cry_engine::YawAngle::from_degrees(270.f),
-                                               omath::cry_engine::RollAngle::from_degrees(0.f)};
+    const omath::cry_engine::ViewAngles angles{
+        omath::cry_engine::PitchAngle::from_degrees(0.f),
+        omath::cry_engine::YawAngle::from_degrees(270.f),
+        omath::cry_engine::RollAngle::from_degrees(0.f)
+    };
     const auto vec = angles.as_vector3();
 
     EXPECT_NEAR(vec.y, -90.f, 0.01f);

tests/engines/unit_test_traits_engines.cpp

@@ -1,32 +1,30 @@
 // Tests for engine trait headers to improve header coverage
 #include <gtest/gtest.h>
-#include <omath/engines/cry_engine/camera.hpp>
-#include <omath/engines/cry_engine/traits/camera_trait.hpp>
-#include <omath/engines/frostbite_engine/camera.hpp>
-#include <omath/engines/frostbite_engine/traits/camera_trait.hpp>
-#include <omath/engines/frostbite_engine/traits/mesh_trait.hpp>
 #include <omath/engines/frostbite_engine/traits/pred_engine_trait.hpp>
-#include <omath/engines/iw_engine/camera.hpp>
-#include <omath/engines/iw_engine/traits/camera_trait.hpp>
-#include <omath/engines/iw_engine/traits/mesh_trait.hpp>
+#include <omath/engines/frostbite_engine/traits/mesh_trait.hpp>
+#include <omath/engines/frostbite_engine/traits/camera_trait.hpp>
+
 #include <omath/engines/iw_engine/traits/pred_engine_trait.hpp>
-#include <omath/engines/opengl_engine/camera.hpp>
-#include <omath/engines/opengl_engine/traits/camera_trait.hpp>
-#include <omath/engines/opengl_engine/traits/mesh_trait.hpp>
+#include <omath/engines/iw_engine/traits/mesh_trait.hpp>
+#include <omath/engines/iw_engine/traits/camera_trait.hpp>
+
 #include <omath/engines/opengl_engine/traits/pred_engine_trait.hpp>
-#include <omath/engines/rage_engine/camera.hpp>
-#include <omath/engines/rage_engine/traits/camera_trait.hpp>
-#include <omath/engines/source_engine/camera.hpp>
-#include <omath/engines/source_engine/traits/camera_trait.hpp>
-#include <omath/engines/source_engine/traits/pred_engine_trait.hpp>
-#include <omath/engines/unity_engine/camera.hpp>
-#include <omath/engines/unity_engine/traits/camera_trait.hpp>
-#include <omath/engines/unity_engine/traits/mesh_trait.hpp>
+#include <omath/engines/opengl_engine/traits/mesh_trait.hpp>
+#include <omath/engines/opengl_engine/traits/camera_trait.hpp>
+
 #include <omath/engines/unity_engine/traits/pred_engine_trait.hpp>
-#include <omath/engines/unreal_engine/camera.hpp>
-#include <omath/engines/unreal_engine/traits/camera_trait.hpp>
-#include <omath/engines/unreal_engine/traits/mesh_trait.hpp>
+#include <omath/engines/unity_engine/traits/mesh_trait.hpp>
+#include <omath/engines/unity_engine/traits/camera_trait.hpp>
+
 #include <omath/engines/unreal_engine/traits/pred_engine_trait.hpp>
+#include <omath/engines/unreal_engine/traits/mesh_trait.hpp>
+#include <omath/engines/unreal_engine/traits/camera_trait.hpp>
+
+#include <omath/engines/source_engine/traits/pred_engine_trait.hpp>
+#include <omath/engines/source_engine/traits/camera_trait.hpp>
+
+#include <omath/engines/cry_engine/traits/camera_trait.hpp>
+
 #include <omath/projectile_prediction/projectile.hpp>
 #include <omath/projectile_prediction/target.hpp>
 #include <optional>
@@ -43,41 +41,6 @@ static void expect_matrix_near(const MatT& a, const MatT& b, float eps = 1e-5f)
 }
 
 // ── Launch offset tests for all engines ──────────────────────────────────────
-template<class MatType, class NumericType>
-constexpr bool matrix_has_non_zero_element(const MatType& mat)
-{
-    for (std::size_t r = 0; r < 4; ++r)
-        for (std::size_t c = 0; c < 4; ++c)
-            if (mat.at(r, c) != NumericType{0})
-                return true;
-
-    return false;
-}
-
-template<class CameraType, class NumericType>
-constexpr bool camera_can_calculate_matrices_at_compile_time()
-{
-    using FieldOfView = projection::FieldOfView;
-
-    CameraType camera{{}, {}, {1280.f, 720.f}, FieldOfView::from_degrees(90.f), NumericType{0.01}, NumericType{1000}};
-    const auto view = camera.get_view_matrix();
-    const auto projection = camera.get_projection_matrix();
-    const auto view_projection = camera.get_view_projection_matrix();
-
-    return matrix_has_non_zero_element<decltype(view), NumericType>(view)
-           && matrix_has_non_zero_element<decltype(projection), NumericType>(projection)
-           && matrix_has_non_zero_element<decltype(view_projection), NumericType>(view_projection);
-}
-
-static_assert(camera_can_calculate_matrices_at_compile_time<source_engine::Camera, float>());
-static_assert(camera_can_calculate_matrices_at_compile_time<iw_engine::Camera, float>());
-static_assert(camera_can_calculate_matrices_at_compile_time<frostbite_engine::Camera, float>());
-static_assert(camera_can_calculate_matrices_at_compile_time<opengl_engine::Camera, float>());
-static_assert(camera_can_calculate_matrices_at_compile_time<unity_engine::Camera, float>());
-static_assert(camera_can_calculate_matrices_at_compile_time<cry_engine::Camera, float>());
-static_assert(camera_can_calculate_matrices_at_compile_time<rage_engine::Camera, float>());
-static_assert(camera_can_calculate_matrices_at_compile_time<unreal_engine::Camera, double>());
-
 #include <omath/engines/cry_engine/traits/pred_engine_trait.hpp>
 
 // Helper: verify that zero offset matches default-initialized offset behavior
@@ -111,10 +74,8 @@ static void verify_zero_offset_matches_default()
     p2.m_launch_speed = static_cast<AT>(50);
     p2.m_gravity_scale = static_cast<AT>(1);
 
-    const auto pos1 = Trait::predict_projectile_position(p, static_cast<AT>(15), static_cast<AT>(30),
-                                                         static_cast<AT>(1), static_cast<AT>(9.81));
-    const auto pos2 = Trait::predict_projectile_position(p2, static_cast<AT>(15), static_cast<AT>(30),
-                                                         static_cast<AT>(1), static_cast<AT>(9.81));
+    const auto pos1 = Trait::predict_projectile_position(p, static_cast<AT>(15), static_cast<AT>(30), static_cast<AT>(1), static_cast<AT>(9.81));
+    const auto pos2 = Trait::predict_projectile_position(p2, static_cast<AT>(15), static_cast<AT>(30), static_cast<AT>(1), static_cast<AT>(9.81));
 #if defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__) || defined(_M_ARM64)
     constexpr double tol = 1e-6;
 #else
@@ -197,8 +158,7 @@ TEST(LaunchOffsetTests, OffsetShiftsTrajectory)
     p_with_offset.m_gravity_scale = 1.f;
 
     const auto pos1 = source_engine::PredEngineTrait::predict_projectile_position(p_no_offset, 20.f, 45.f, 2.f, 9.81f);
-    const auto pos2 =
-            source_engine::PredEngineTrait::predict_projectile_position(p_with_offset, 20.f, 45.f, 2.f, 9.81f);
+    const auto pos2 = source_engine::PredEngineTrait::predict_projectile_position(p_with_offset, 20.f, 45.f, 2.f, 9.81f);
 
     // The difference should be exactly the launch offset
     EXPECT_NEAR(pos2.x - pos1.x, 10.f, 1e-4f);
@@ -261,16 +221,12 @@ TEST(TraitTests, Frostbite_Pred_And_Mesh_And_Camera)
     // CameraTrait look at should be callable
     const auto angles = e::CameraTrait::calc_look_at_angle({0, 0, 0}, {0, 1, 1});
     (void)angles;
-    const auto proj =
-            e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f,
-                                                   1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
     const auto expected = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f);
     expect_matrix_near(proj, expected);
 
-    const auto proj_zo = e::CameraTrait::calc_projection_matrix(
-            projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
-    const auto expected_zo =
-            e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
     expect_matrix_near(proj_zo, expected_zo);
     EXPECT_NE(proj, proj_zo);
 }
@@ -316,16 +272,12 @@ TEST(TraitTests, IW_Pred_And_Mesh_And_Camera)
     e::ViewAngles va;
     expect_matrix_near(e::MeshTrait::rotation_matrix(va), e::rotation_matrix(va));
 
-    const auto proj =
-            e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(45.f), {1920.f, 1080.f}, 0.1f,
-                                                   1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(45.f), {1920.f, 1080.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
     const auto expected = e::calc_perspective_projection_matrix(45.f, 1920.f / 1080.f, 0.1f, 1000.f);
     expect_matrix_near(proj, expected);
 
-    const auto proj_zo = e::CameraTrait::calc_projection_matrix(
-            projection::FieldOfView::from_degrees(45.f), {1920.f, 1080.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
-    const auto expected_zo =
-            e::calc_perspective_projection_matrix(45.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(45.f), {1920.f, 1080.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(45.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
     expect_matrix_near(proj_zo, expected_zo);
     EXPECT_NE(proj, proj_zo);
 
@@ -375,16 +327,12 @@ TEST(TraitTests, OpenGL_Pred_And_Mesh_And_Camera)
     e::ViewAngles va;
     expect_matrix_near(e::MeshTrait::rotation_matrix(va), e::rotation_matrix(va));
 
-    const auto proj =
-            e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f,
-                                                   1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
     const auto expected = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f);
     expect_matrix_near(proj, expected);
 
-    const auto proj_zo = e::CameraTrait::calc_projection_matrix(
-            projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
-    const auto expected_zo =
-            e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
     expect_matrix_near(proj_zo, expected_zo);
     EXPECT_NE(proj, proj_zo);
 
@@ -434,16 +382,12 @@ TEST(TraitTests, Unity_Pred_And_Mesh_And_Camera)
     e::ViewAngles va;
     expect_matrix_near(e::MeshTrait::rotation_matrix(va), e::rotation_matrix(va));
 
-    const auto proj =
-            e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f,
-                                                   1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
     const auto expected = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f);
     expect_matrix_near(proj, expected);
 
-    const auto proj_zo = e::CameraTrait::calc_projection_matrix(
-            projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
-    const auto expected_zo =
-            e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
     expect_matrix_near(proj_zo, expected_zo);
     EXPECT_NE(proj, proj_zo);
 
@@ -493,16 +437,12 @@ TEST(TraitTests, Unreal_Pred_And_Mesh_And_Camera)
     e::ViewAngles va;
     expect_matrix_near(e::MeshTrait::rotation_matrix(va), e::rotation_matrix(va));
 
-    const auto proj =
-            e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f,
-                                                   1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
     const auto expected = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f);
     expect_matrix_near(proj, expected);
 
-    const auto proj_zo = e::CameraTrait::calc_projection_matrix(
-            projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
-    const auto expected_zo =
-            e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto proj_zo = e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(60.f), {1280.f, 720.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(60.f, 1280.f / 720.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
     expect_matrix_near(proj_zo, expected_zo);
     EXPECT_NE(proj, proj_zo);
 
@@ -518,17 +458,18 @@ TEST(NDCDepthRangeTests, Source_BothDepthRanges)
 {
     namespace e = omath::source_engine;
 
-    const auto proj_no =
-            e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f,
-                                                   1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
-    const auto expected_no = e::calc_perspective_projection_matrix(90.f, 1920.f / 1080.f, 0.1f, 1000.f,
-                                                                   NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj_no = e::CameraTrait::calc_projection_matrix(
+            projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f,
+            NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto expected_no = e::calc_perspective_projection_matrix(
+            90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
     expect_matrix_near(proj_no, expected_no);
 
     const auto proj_zo = e::CameraTrait::calc_projection_matrix(
-            projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
-    const auto expected_zo =
-            e::calc_perspective_projection_matrix(90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+            projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f,
+            NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(
+            90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
     expect_matrix_near(proj_zo, expected_zo);
 
     EXPECT_NE(proj_no, proj_zo);
@@ -538,17 +479,18 @@ TEST(NDCDepthRangeTests, CryEngine_BothDepthRanges)
 {
     namespace e = omath::cry_engine;
 
-    const auto proj_no =
-            e::CameraTrait::calc_projection_matrix(projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f,
-                                                   1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
-    const auto expected_no = e::calc_perspective_projection_matrix(90.f, 1920.f / 1080.f, 0.1f, 1000.f,
-                                                                   NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj_no = e::CameraTrait::calc_projection_matrix(
+            projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f,
+            NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto expected_no = e::calc_perspective_projection_matrix(
+            90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
     expect_matrix_near(proj_no, expected_no);
 
     const auto proj_zo = e::CameraTrait::calc_projection_matrix(
-            projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
-    const auto expected_zo =
-            e::calc_perspective_projection_matrix(90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
+            projection::FieldOfView::from_degrees(90.f), {1920.f, 1080.f}, 0.1f, 1000.f,
+            NDCDepthRange::ZERO_TO_ONE);
+    const auto expected_zo = e::calc_perspective_projection_matrix(
+            90.f, 1920.f / 1080.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
     expect_matrix_near(proj_zo, expected_zo);
 
     EXPECT_NE(proj_no, proj_zo);
@@ -595,8 +537,7 @@ TEST(NDCDepthRangeTests, OpenGL_ZeroToOne_ZRange)
     const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
 
     // OpenGL engine uses column-major matrices, project manually
-    auto proj_z = [&](float z)
-    {
+    auto proj_z = [&](float z) {
         auto clip = proj * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>({0, 0, z});
         return clip.at(2, 0) / clip.at(3, 0);
     };
@@ -624,8 +565,7 @@ TEST(NDCDepthRangeTests, Unity_ZeroToOne_ZRange)
     // Unity is right-handed, row-major
     const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::ZERO_TO_ONE);
 
-    auto proj_z = [&](float z)
-    {
+    auto proj_z = [&](float z) {
         auto clip = proj * mat_column_from_vector<float>({0, 0, z});
         return clip.at(2, 0) / clip.at(3, 0);
     };
@@ -663,8 +603,7 @@ TEST(NDCDepthRangeTests, CryEngine_ZeroToOne_ZRange)
 TEST(NDCDepthRangeTests, Source_NegativeOneToOne_ZRange)
 {
     namespace e = omath::source_engine;
-    const auto proj =
-            e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
 
     EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f);
     EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f);
@@ -673,8 +612,7 @@ TEST(NDCDepthRangeTests, Source_NegativeOneToOne_ZRange)
 TEST(NDCDepthRangeTests, IW_NegativeOneToOne_ZRange)
 {
     namespace e = omath::iw_engine;
-    const auto proj =
-            e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
 
     EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f);
     EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f);
@@ -683,8 +621,7 @@ TEST(NDCDepthRangeTests, IW_NegativeOneToOne_ZRange)
 TEST(NDCDepthRangeTests, Frostbite_NegativeOneToOne_ZRange)
 {
     namespace e = omath::frostbite_engine;
-    const auto proj =
-            e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
 
     EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f);
     EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f);
@@ -693,8 +630,7 @@ TEST(NDCDepthRangeTests, Frostbite_NegativeOneToOne_ZRange)
 TEST(NDCDepthRangeTests, Unreal_NegativeOneToOne_ZRange)
 {
     namespace e = omath::unreal_engine;
-    const auto proj =
-            e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
 
     EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f);
     EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f);
@@ -703,8 +639,7 @@ TEST(NDCDepthRangeTests, Unreal_NegativeOneToOne_ZRange)
 TEST(NDCDepthRangeTests, CryEngine_NegativeOneToOne_ZRange)
 {
     namespace e = omath::cry_engine;
-    const auto proj =
-            e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
 
     EXPECT_NEAR(project_z_lh(proj, 0.1f), -1.0f, 1e-3f);
     EXPECT_NEAR(project_z_lh(proj, 1000.f), 1.0f, 1e-3f);
@@ -713,11 +648,9 @@ TEST(NDCDepthRangeTests, CryEngine_NegativeOneToOne_ZRange)
 TEST(NDCDepthRangeTests, OpenGL_NegativeOneToOne_ZRange)
 {
     namespace e = omath::opengl_engine;
-    const auto proj =
-            e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
 
-    auto proj_z = [&](float z)
-    {
+    auto proj_z = [&](float z) {
         auto clip = proj * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>({0, 0, z});
         return clip.at(2, 0) / clip.at(3, 0);
     };
@@ -729,11 +662,9 @@ TEST(NDCDepthRangeTests, OpenGL_NegativeOneToOne_ZRange)
 TEST(NDCDepthRangeTests, Unity_NegativeOneToOne_ZRange)
 {
     namespace e = omath::unity_engine;
-    const auto proj =
-            e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
+    const auto proj = e::calc_perspective_projection_matrix(90.f, 16.f / 9.f, 0.1f, 1000.f, NDCDepthRange::NEGATIVE_ONE_TO_ONE);
 
-    auto proj_z = [&](float z)
-    {
+    auto proj_z = [&](float z) {
         auto clip = proj * mat_column_from_vector<float>({0, 0, z});
         return clip.at(2, 0) / clip.at(3, 0);
     };

tests/general/unit_test_aabb.cpp

@@ -4,9 +4,7 @@
 #include <gtest/gtest.h>
 #include "omath/3d_primitives/aabb.hpp"
 
-using UpAxis = omath::primitives::UpAxis;
 using AABB = omath::primitives::Aabb<float>;
-using AABBZ = omath::primitives::Aabb<float, UpAxis::Z>;
 using Vec3 = omath::Vector3<float>;
 
 // --- center() ---
@@ -67,12 +65,14 @@ TEST(AabbTests, ExtentsOfDegenerateBox)
     EXPECT_FLOAT_EQ(e.z, 0.f);
 }
 
+using UpAxis = omath::primitives::UpAxis;
+
 // --- top() ---
 
 TEST(AabbTests, TopYUpSymmetricBox)
 {
     constexpr AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
-    constexpr auto t = box.top();
+    constexpr auto t = box.top<UpAxis::Y>();
     EXPECT_FLOAT_EQ(t.x, 0.f);
     EXPECT_FLOAT_EQ(t.y, 2.f);
     EXPECT_FLOAT_EQ(t.z, 0.f);
@@ -81,7 +81,7 @@ TEST(AabbTests, TopYUpSymmetricBox)
 TEST(AabbTests, TopYUpOffsetBox)
 {
     constexpr AABB box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
-    constexpr auto t = box.top();
+    constexpr auto t = box.top<UpAxis::Y>();
     EXPECT_FLOAT_EQ(t.x, 2.f);
     EXPECT_FLOAT_EQ(t.y, 10.f);
     EXPECT_FLOAT_EQ(t.z, 4.f);
@@ -89,8 +89,8 @@ TEST(AabbTests, TopYUpOffsetBox)
 
 TEST(AabbTests, TopZUpSymmetricBox)
 {
-    constexpr AABBZ box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
-    constexpr auto t = box.top();
+    constexpr AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
+    constexpr auto t = box.top<UpAxis::Z>();
     EXPECT_FLOAT_EQ(t.x, 0.f);
     EXPECT_FLOAT_EQ(t.y, 0.f);
     EXPECT_FLOAT_EQ(t.z, 3.f);
@@ -98,8 +98,8 @@ TEST(AabbTests, TopZUpSymmetricBox)
 
 TEST(AabbTests, TopZUpOffsetBox)
 {
-    constexpr AABBZ box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
-    constexpr auto t = box.top();
+    constexpr AABB box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
+    constexpr auto t = box.top<UpAxis::Z>();
     EXPECT_FLOAT_EQ(t.x, 2.f);
     EXPECT_FLOAT_EQ(t.y, 7.f);
     EXPECT_FLOAT_EQ(t.z, 6.f);
@@ -108,8 +108,7 @@ TEST(AabbTests, TopZUpOffsetBox)
 TEST(AabbTests, TopDefaultIsYUp)
 {
     constexpr AABB box{{0.f, 0.f, 0.f}, {2.f, 4.f, 6.f}};
-    EXPECT_EQ(AABB::get_up_axis(), UpAxis::Y);
-    EXPECT_FLOAT_EQ(box.top().y, 4.f);
+    EXPECT_EQ(box.top(), box.top<UpAxis::Y>());
 }
 
 // --- bottom() ---
@@ -117,7 +116,7 @@ TEST(AabbTests, TopDefaultIsYUp)
 TEST(AabbTests, BottomYUpSymmetricBox)
 {
     constexpr AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
-    constexpr auto b = box.bottom();
+    constexpr auto b = box.bottom<UpAxis::Y>();
     EXPECT_FLOAT_EQ(b.x, 0.f);
     EXPECT_FLOAT_EQ(b.y, -2.f);
     EXPECT_FLOAT_EQ(b.z, 0.f);
@@ -126,7 +125,7 @@ TEST(AabbTests, BottomYUpSymmetricBox)
 TEST(AabbTests, BottomYUpOffsetBox)
 {
     constexpr AABB box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
-    constexpr auto b = box.bottom();
+    constexpr auto b = box.bottom<UpAxis::Y>();
     EXPECT_FLOAT_EQ(b.x, 2.f);
     EXPECT_FLOAT_EQ(b.y, 4.f);
     EXPECT_FLOAT_EQ(b.z, 4.f);
@@ -134,8 +133,8 @@ TEST(AabbTests, BottomYUpOffsetBox)
 
 TEST(AabbTests, BottomZUpSymmetricBox)
 {
-    constexpr AABBZ box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
-    constexpr auto b = box.bottom();
+    constexpr AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
+    constexpr auto b = box.bottom<UpAxis::Z>();
     EXPECT_FLOAT_EQ(b.x, 0.f);
     EXPECT_FLOAT_EQ(b.y, 0.f);
     EXPECT_FLOAT_EQ(b.z, -3.f);
@@ -143,8 +142,8 @@ TEST(AabbTests, BottomZUpSymmetricBox)
 
 TEST(AabbTests, BottomZUpOffsetBox)
 {
-    constexpr AABBZ box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
-    constexpr auto b = box.bottom();
+    constexpr AABB box{{1.f, 4.f, 2.f}, {3.f, 10.f, 6.f}};
+    constexpr auto b = box.bottom<UpAxis::Z>();
     EXPECT_FLOAT_EQ(b.x, 2.f);
     EXPECT_FLOAT_EQ(b.y, 7.f);
     EXPECT_FLOAT_EQ(b.z, 2.f);
@@ -153,33 +152,14 @@ TEST(AabbTests, BottomZUpOffsetBox)
 TEST(AabbTests, BottomDefaultIsYUp)
 {
     constexpr AABB box{{0.f, 0.f, 0.f}, {2.f, 4.f, 6.f}};
-    EXPECT_EQ(AABB::get_up_axis(), UpAxis::Y);
-    EXPECT_FLOAT_EQ(box.bottom().y, 0.f);
+    EXPECT_EQ(box.bottom(), box.bottom<UpAxis::Y>());
 }
 
 TEST(AabbTests, TopAndBottomAreSymmetric)
 {
     constexpr AABB box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
-    constexpr AABBZ z_up_box{{-1.f, -2.f, -3.f}, {1.f, 2.f, 3.f}};
-    EXPECT_FLOAT_EQ(box.top().y, -box.bottom().y);
-    EXPECT_FLOAT_EQ(z_up_box.top().z, -z_up_box.bottom().z);
-}
-
-// --- vertices() ---
-
-TEST(AabbTests, VerticesReturnsAllCorners)
-{
-    constexpr AABB box{{1.f, 2.f, 3.f}, {4.f, 6.f, 8.f}};
-    constexpr auto v = box.vertices();
-
-    EXPECT_EQ(v[0], Vec3(1.f, 2.f, 3.f));
-    EXPECT_EQ(v[1], Vec3(4.f, 2.f, 3.f));
-    EXPECT_EQ(v[2], Vec3(1.f, 6.f, 3.f));
-    EXPECT_EQ(v[3], Vec3(4.f, 6.f, 3.f));
-    EXPECT_EQ(v[4], Vec3(1.f, 2.f, 8.f));
-    EXPECT_EQ(v[5], Vec3(4.f, 2.f, 8.f));
-    EXPECT_EQ(v[6], Vec3(1.f, 6.f, 8.f));
-    EXPECT_EQ(v[7], Vec3(4.f, 6.f, 8.f));
+    EXPECT_FLOAT_EQ(box.top<UpAxis::Y>().y, -box.bottom<UpAxis::Y>().y);
+    EXPECT_FLOAT_EQ(box.top<UpAxis::Z>().z, -box.bottom<UpAxis::Z>().z);
 }
 
 // --- is_collide() ---

tests/general/unit_test_angle.cpp

@@ -2,10 +2,10 @@
 // Created by Orange on 11/30/2024.
 //
 
+#include <omath/trigonometry/angle.hpp>
 #include <cmath>
 #include <gtest/gtest.h>
 #include <numbers>
-#include <omath/trigonometry/angle.hpp>
 
 using namespace omath;
 
@@ -19,12 +19,6 @@ namespace
 
     constexpr float k_eps = 1e-5f;
 
-    constexpr bool close_to(const float actual, const float expected, const float epsilon)
-    {
-        const float diff = actual - expected;
-        return (diff < 0.0f ? -diff : diff) <= epsilon;
-    }
-
 } // namespace
 
 // ---------- Construction / factories ----------
@@ -183,7 +177,7 @@ TEST(UnitTestAngle, Formatter_PrintsDegreesWithSuffix)
 
 TEST(UnitTestAngle, BinaryPlus_ReturnsWrappedSum)
 {
-    const Angle<> a = Deg::from_degrees(350.0f);
+    Angle<> a = Deg::from_degrees(350.0f);
     const Deg b = Deg::from_degrees(20.0f);
     const Deg c = a + b; // expect 10°
     EXPECT_FLOAT_EQ(c.as_degrees(), 10.0f);
@@ -191,19 +185,8 @@ TEST(UnitTestAngle, BinaryPlus_ReturnsWrappedSum)
 
 TEST(UnitTestAngle, BinaryMinus_ReturnsWrappedDiff)
 {
-    const Angle<> a = Deg::from_degrees(10.0f);
+    Angle<> a = Deg::from_degrees(10.0f);
     const Deg b = Deg::from_degrees(30.0f);
     const Deg c = a - b; // expect 340°
     EXPECT_FLOAT_EQ(c.as_degrees(), 340.0f);
 }
-
-static_assert(close_to(Pitch::from_degrees(0.0f).sin(), 0.0f, k_eps),
-              "Sin should be constexpr with embedded constexpr math");
-static_assert(close_to(Pitch::from_degrees(0.0f).cos(), 1.0f, k_eps),
-              "Cos should be constexpr with embedded constexpr math");
-static_assert(close_to(Pitch::from_degrees(45.0f).tan(), 1.0f, 1e-4f),
-              "Tan should be constexpr with embedded constexpr math");
-static_assert(close_to(Pitch::from_degrees(45.0f).cot(), 1.0f, 1e-4f),
-              "Cot should be constexpr with embedded constexpr math");
-static_assert(close_to(Pitch::from_degrees(45.0f).atan(), 0.66577375f, 1e-6f),
-              "Atan should be constexpr with embedded constexpr math");

tests/general/unit_test_elf_scanner.cpp

@@ -35,22 +35,13 @@ static std::vector<std::byte> make_elf64_with_text_section(const std::vector<std
 
     std::vector<std::byte> buf(total_size, std::byte{0});
 
-    auto w8 = [&](std::size_t off, std::uint8_t v)
-    {
-        buf[off] = std::byte{v};
-    };
+    auto w8 = [&](std::size_t off, std::uint8_t v) { buf[off] = std::byte{v}; };
     auto w16 = [&](std::size_t off, std::uint16_t v)
-    {
-        std::memcpy(buf.data() + off, &v, 2);
-    };
+    { std::memcpy(buf.data() + off, &v, 2); };
     auto w32 = [&](std::size_t off, std::uint32_t v)
-    {
-        std::memcpy(buf.data() + off, &v, 4);
-    };
+    { std::memcpy(buf.data() + off, &v, 4); };
     auto w64 = [&](std::size_t off, std::uint64_t v)
-    {
-        std::memcpy(buf.data() + off, &v, 8);
-    };
+    { std::memcpy(buf.data() + off, &v, 8); };
 
     // --- ELF64 file header ---
     // e_ident
@@ -62,19 +53,19 @@ static std::vector<std::byte> make_elf64_with_text_section(const std::vector<std
     w8(5, 1); // ELFDATA2LSB
     w8(6, 1); // EV_CURRENT
     // rest of e_ident is 0
-    w16(16, 2); // e_type = ET_EXEC
+    w16(16, 2);  // e_type = ET_EXEC
     w16(18, 62); // e_machine = EM_X86_64
-    w32(20, 1); // e_version
-    w64(24, 0); // e_entry
-    w64(32, 0); // e_phoff
+    w32(20, 1);  // e_version
+    w64(24, 0);  // e_entry
+    w64(32, 0);  // e_phoff
     w64(40, static_cast<std::uint64_t>(shdr_table_off)); // e_shoff
-    w32(48, 0); // e_flags
+    w32(48, 0);  // e_flags
     w16(52, 64); // e_ehsize
     w16(54, 56); // e_phentsize
-    w16(56, 0); // e_phnum
+    w16(56, 0);  // e_phnum
     w16(58, static_cast<std::uint16_t>(shdr_size)); // e_shentsize
     w16(60, static_cast<std::uint16_t>(num_sections)); // e_shnum
-    w16(62, 2); // e_shstrndx = 2 (.shstrtab is section index 2)
+    w16(62, 2);  // e_shstrndx = 2 (.shstrtab is section index 2)
 
     // --- section data (.text) ---
     const std::size_t copy_len = std::min(code_bytes.size(), text_size);
@@ -113,9 +104,9 @@ static std::vector<std::byte> make_elf64_with_text_section(const std::vector<std
     // Section 1: .text
     {
         const std::size_t base = shdr_table_off + 1 * shdr_size;
-        w32(base + 0, 1); // sh_name → index 1 in shstrtab → ".text"
-        w32(base + 4, 1); // sh_type = SHT_PROGBITS
-        w64(base + 8, 6); // sh_flags = SHF_ALLOC|SHF_EXECINSTR
+        w32(base + 0, 1);  // sh_name → index 1 in shstrtab → ".text"
+        w32(base + 4, 1);  // sh_type = SHT_PROGBITS
+        w64(base + 8, 6);  // sh_flags = SHF_ALLOC|SHF_EXECINSTR
         w64(base + 16, static_cast<std::uint64_t>(text_off)); // sh_addr (same as offset in test)
         w64(base + 24, static_cast<std::uint64_t>(text_off)); // sh_offset
         w64(base + 32, static_cast<std::uint64_t>(text_size)); // sh_size
@@ -125,8 +116,8 @@ static std::vector<std::byte> make_elf64_with_text_section(const std::vector<std
     // Section 2: .shstrtab
     {
         const std::size_t base = shdr_table_off + 2 * shdr_size;
-        w32(base + 0, 0); // sh_name → index 0 → "" (good enough for scanner)
-        w32(base + 4, 3); // sh_type = SHT_STRTAB
+        w32(base + 0, 0);  // sh_name → index 0 → "" (good enough for scanner)
+        w32(base + 4, 3);  // sh_type = SHT_STRTAB
         w64(base + 24, static_cast<std::uint64_t>(shstrtab_off)); // sh_offset
         w64(base + 32, static_cast<std::uint64_t>(shstrtab_size)); // sh_size
     }
@@ -160,18 +151,6 @@ TEST(unit_test_elf_pattern_scan_memory, finds_pattern_with_wildcard)
     EXPECT_EQ(result->target_offset, 0);
 }
 
-TEST(unit_test_elf_pattern_scan_memory, consteval_finds_pattern_with_wildcard)
-{
-    const std::vector<std::uint8_t> code = {0x00, 0xDE, 0xAD, 0xBE, 0xEF};
-    const auto buf = make_elf64_with_text_section(code);
-
-    const auto result =
-            ElfPatternScanner::scan_for_pattern_in_memory_file<"DE ?? BE EF">(std::span<const std::byte>{buf}, ".text");
-
-    ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(result->target_offset, 1);
-}
-
 TEST(unit_test_elf_pattern_scan_memory, pattern_not_found_returns_nullopt)
 {
     const std::vector<std::uint8_t> code = {0x01, 0x02, 0x03, 0x04};
@@ -203,8 +182,8 @@ TEST(unit_test_elf_pattern_scan_memory, missing_section_returns_nullopt)
     const std::vector<std::uint8_t> code = {0x90, 0x90};
     const auto buf = make_elf64_with_text_section(code);
 
-    const auto result = ElfPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "90 90",
-                                                                           ".nonexistent");
+    const auto result = ElfPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf},
+                                                                            "90 90", ".nonexistent");
 
     EXPECT_FALSE(result.has_value());
 }
@@ -222,8 +201,8 @@ TEST(unit_test_elf_pattern_scan_memory, matches_file_scan)
     }
 
     const auto file_result = ElfPatternScanner::scan_for_pattern_in_file(tmp_path, "48 89 E5 DE AD", ".text");
-    const auto mem_result = ElfPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf},
-                                                                               "48 89 E5 DE AD", ".text");
+    const auto mem_result =
+            ElfPatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "48 89 E5 DE AD", ".text");
 
     std::filesystem::remove(tmp_path);
 
@@ -233,27 +212,3 @@ TEST(unit_test_elf_pattern_scan_memory, matches_file_scan)
     EXPECT_EQ(file_result->raw_base_addr, mem_result->raw_base_addr);
     EXPECT_EQ(file_result->target_offset, mem_result->target_offset);
 }
-
-TEST(unit_test_elf_pattern_scan_memory, consteval_file_scan_finds_pattern)
-{
-    const std::vector<std::uint8_t> code = {0x48, 0x89, 0xE5, 0xDE, 0xAD};
-    const auto buf = make_elf64_with_text_section(code);
-    const auto tmp_path = std::filesystem::temp_directory_path() / "omath_elf_consteval_test.elf";
-    {
-        std::ofstream out(tmp_path, std::ios::binary);
-        out.write(reinterpret_cast<const char*>(buf.data()), static_cast<std::streamsize>(buf.size()));
-    }
-
-    const auto result = ElfPatternScanner::scan_for_pattern_in_file<"48 ?? E5">(tmp_path, ".text");
-
-    std::filesystem::remove(tmp_path);
-
-    ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(result->target_offset, 0);
-}
-
-TEST(unit_test_elf_pattern_scan_memory, consteval_loaded_module_null_returns_nullopt)
-{
-    const auto result = ElfPatternScanner::scan_for_pattern_in_loaded_module<"DE AD">(nullptr);
-    EXPECT_FALSE(result.has_value());
-}

tests/general/unit_test_entity_overlay.cpp

@@ -1,33 +0,0 @@
-//
-// Created by orange on 30.06.2026.
-//
-#include <gtest/gtest.h>
-#include <memory>
-#include <omath/3d_primitives/aabb.hpp>
-#include <omath/engines/unreal_engine/camera.hpp>
-#include <omath/hud/entity_overlay.hpp>
-
-TEST(EntityOverlayTests, FromAabbSupportsDoubleCameraCoordinates)
-{
-    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    const omath::unreal_engine::Camera camera{{0.0, 0.0, 0.0}, {}, {1920.f, 1080.f}, fov, 0.01, 1000.0};
-    const omath::primitives::Aabb<double> aabb{{90.0, -1.0, -1.0}, {110.0, 1.0, 1.0}};
-
-    const auto overlay = omath::hud::EntityOverlay::from_aabb(camera, aabb, 0.5f,
-                                                              std::shared_ptr<omath::hud::HudRendererInterface>{});
-
-    ASSERT_TRUE(overlay.has_value());
-}
-
-TEST(EntityOverlayTests, FromAabbReturnsErrorCodeIfNoVertexProjects)
-{
-    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    const omath::unreal_engine::Camera camera{{0.0, 0.0, 0.0}, {}, {1920.f, 1080.f}, fov, 0.01, 1000.0};
-    const omath::primitives::Aabb<double> aabb{{-110.0, -1.0, -1.0}, {-90.0, 1.0, 1.0}};
-
-    const auto overlay = omath::hud::EntityOverlay::from_aabb(camera, aabb, 0.5f,
-                                                              std::shared_ptr<omath::hud::HudRendererInterface>{});
-
-    ASSERT_FALSE(overlay.has_value());
-    EXPECT_EQ(overlay.error(), omath::hud::EntityOverlayError::NO_PROJECTED_VERTEX);
-}

tests/general/unit_test_macho_memory_file_scan.cpp

@@ -1,7 +1,5 @@
 // Tests for MachOPatternScanner::scan_for_pattern_in_memory_file
 #include <cstring>
-#include <filesystem>
-#include <fstream>
 #include <gtest/gtest.h>
 #include <omath/utility/macho_pattern_scan.hpp>
 #include <span>
@@ -39,43 +37,38 @@ static std::vector<std::byte> make_macho64_with_text_section(const std::vector<s
     constexpr std::size_t total_size = text_raw_off + text_raw_size;
     constexpr std::uint64_t text_vmaddr = 0x1000ULL;
 
-    constexpr std::uint32_t cmd_size = static_cast<std::uint32_t>(seg_size + sect_hdr_size); // segment + 1 section
+    constexpr std::uint32_t cmd_size =
+            static_cast<std::uint32_t>(seg_size + sect_hdr_size); // segment + 1 section
 
     std::vector<std::byte> buf(total_size, std::byte{0});
 
-    auto w32 = [&](std::size_t off, std::uint32_t v)
-    {
-        std::memcpy(buf.data() + off, &v, 4);
-    };
-    auto w64 = [&](std::size_t off, std::uint64_t v)
-    {
-        std::memcpy(buf.data() + off, &v, 8);
-    };
+    auto w32 = [&](std::size_t off, std::uint32_t v) { std::memcpy(buf.data() + off, &v, 4); };
+    auto w64 = [&](std::size_t off, std::uint64_t v) { std::memcpy(buf.data() + off, &v, 8); };
 
     // MachHeader64
     w32(0, mh_magic_64);
-    w32(4, 0x0100000C); // cputype = CPU_TYPE_ARM64 (doesn't matter for scan)
-    w32(12, 2); // filetype = MH_EXECUTE
-    w32(16, 1); // ncmds = 1
-    w32(20, cmd_size); // sizeofcmds
+    w32(4, 0x0100000C);  // cputype = CPU_TYPE_ARM64 (doesn't matter for scan)
+    w32(12, 2);           // filetype = MH_EXECUTE
+    w32(16, 1);           // ncmds = 1
+    w32(20, cmd_size);    // sizeofcmds
 
     // SegmentCommand64 at 0x20
     constexpr std::size_t seg_off = hdr_size;
     w32(seg_off + 0, lc_segment_64);
     w32(seg_off + 4, cmd_size);
     std::memcpy(buf.data() + seg_off + 8, "__TEXT", 6); // segname
-    w64(seg_off + 24, text_vmaddr); // vmaddr
-    w64(seg_off + 32, text_raw_size); // vmsize
-    w64(seg_off + 40, text_raw_off); // fileoff
-    w64(seg_off + 48, text_raw_size); // filesize
-    w32(seg_off + 64, 1); // nsects
+    w64(seg_off + 24, text_vmaddr);                      // vmaddr
+    w64(seg_off + 32, text_raw_size);                    // vmsize
+    w64(seg_off + 40, text_raw_off);                     // fileoff
+    w64(seg_off + 48, text_raw_size);                    // filesize
+    w32(seg_off + 64, 1);                                // nsects
 
     // Section64 at 0x68
     constexpr std::size_t sect_off = seg_off + seg_size;
-    std::memcpy(buf.data() + sect_off + 0, "__text", 6); // sectname
+    std::memcpy(buf.data() + sect_off + 0, "__text", 6);  // sectname
     std::memcpy(buf.data() + sect_off + 16, "__TEXT", 6); // segname
-    w64(sect_off + 32, text_vmaddr); // addr
-    w64(sect_off + 40, text_raw_size); // size
+    w64(sect_off + 32, text_vmaddr);                       // addr
+    w64(sect_off + 40, text_raw_size);                     // size
     w32(sect_off + 48, static_cast<std::uint32_t>(text_raw_off)); // offset (file offset)
 
     // Section data
@@ -112,18 +105,6 @@ TEST(unit_test_macho_memory_file_scan, finds_pattern_with_wildcard)
     EXPECT_EQ(result->target_offset, 0);
 }
 
-TEST(unit_test_macho_memory_file_scan, consteval_finds_pattern_with_wildcard)
-{
-    const std::vector<std::uint8_t> code = {0x00, 0xDE, 0xAD, 0xBE, 0xEF};
-    const auto buf = make_macho64_with_text_section(code);
-
-    const auto result =
-            MachOPatternScanner::scan_for_pattern_in_memory_file<"DE ?? BE EF">(std::span<const std::byte>{buf});
-
-    ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(result->target_offset, 1);
-}
-
 TEST(unit_test_macho_memory_file_scan, pattern_not_found_returns_nullopt)
 {
     const std::vector<std::uint8_t> code = {0x01, 0x02, 0x03};
@@ -162,27 +143,3 @@ TEST(unit_test_macho_memory_file_scan, raw_addr_and_virtual_addr_correct)
     EXPECT_EQ(result->raw_base_addr, expected_raw_off);
     EXPECT_EQ(result->virtual_base_addr, 0x1000u);
 }
-
-TEST(unit_test_macho_memory_file_scan, consteval_file_scan_finds_pattern)
-{
-    const std::vector<std::uint8_t> code = {0x48, 0x89, 0xE5, 0xDE, 0xAD};
-    const auto buf = make_macho64_with_text_section(code);
-    const auto tmp_path = std::filesystem::temp_directory_path() / "omath_macho_consteval_test.bin";
-    {
-        std::ofstream out(tmp_path, std::ios::binary);
-        out.write(reinterpret_cast<const char*>(buf.data()), static_cast<std::streamsize>(buf.size()));
-    }
-
-    const auto result = MachOPatternScanner::scan_for_pattern_in_file<"48 ?? E5">(tmp_path);
-
-    std::filesystem::remove(tmp_path);
-
-    ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(result->target_offset, 0);
-}
-
-TEST(unit_test_macho_memory_file_scan, consteval_loaded_module_null_returns_nullopt)
-{
-    const auto result = MachOPatternScanner::scan_for_pattern_in_loaded_module<"DE AD">(nullptr);
-    EXPECT_FALSE(result.has_value());
-}

tests/general/unit_test_mat.cpp

@@ -1,23 +1,11 @@
 // UnitTestMat.cpp
 #include "omath/linear_algebra/mat.hpp"
 #include "omath/linear_algebra/vector3.hpp"
-#include "omath/trigonometry/angle.hpp"
 #include "omath/trigonometry/angles.hpp"
 #include <gtest/gtest.h>
 
 using namespace omath;
 
-namespace
-{
-    using Pitch = Angle<float, static_cast<float>(-90), static_cast<float>(90), AngleFlags::Clamped>;
-
-    constexpr bool close_to(const float actual, const float expected, const float epsilon)
-    {
-        const float diff = actual - expected;
-        return (diff < 0.0f ? -diff : diff) <= epsilon;
-    }
-} // namespace
-
 class UnitTestMat : public ::testing::Test
 {
 protected:
@@ -175,6 +163,7 @@ TEST_F(UnitTestMat, StaticMethod_ToScreenMat)
     EXPECT_FLOAT_EQ(screen_mat.at(3, 3), 1.0f);
 }
 
+
 // Test exception handling in At() method
 TEST_F(UnitTestMat, Method_At_OutOfRange)
 {
@@ -222,7 +211,7 @@ TEST(UnitTestMatStandalone, Transpose_NonSquare)
 TEST(UnitTestMatStandalone, Enverse)
 {
     constexpr Mat<2, 2> m{{1.0f, 3.0f}, {2.0f, 5.0f}};
-    constexpr Mat<2, 2> mv{{-5.0f, 3.0f}, {2.0f, -1.0f}};
+    constexpr Mat<2,2> mv{{-5.0f, 3.0f}, {2.0f, -1.0f}};
 
     EXPECT_EQ(mv, m.inverted());
 }
@@ -245,8 +234,9 @@ TEST(UnitTestMatStandalone, Equanity)
 }
 TEST(UnitTestMatStandalone, MatPerspectiveLeftHanded)
 {
-    const auto perspective_proj = mat_perspective_left_handed_vertical_fov(90.f, 16.f / 9.f, 0.1f, 1000.f);
-    auto projected = perspective_proj * mat_column_from_vector<float>({0, 0, 0.1001});
+    const auto perspective_proj = mat_perspective_left_handed_vertical_fov(90.f, 16.f/9.f, 0.1f, 1000.f);
+    auto projected = perspective_proj
+                             * mat_column_from_vector<float>({0, 0, 0.1001});
 
     projected /= projected.at(3, 0);
 
@@ -255,9 +245,8 @@ TEST(UnitTestMatStandalone, MatPerspectiveLeftHanded)
 
 TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedZeroToOne)
 {
-    const auto proj =
-            mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                    90.f, 16.f / 9.f, 0.1f, 1000.f);
+    const auto proj = mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+            90.f, 16.f / 9.f, 0.1f, 1000.f);
 
     // Near plane point should map to z ~ 0
     auto near_pt = proj * mat_column_from_vector<float>({0, 0, 0.1f});
@@ -278,9 +267,8 @@ TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedZeroToOne)
 
 TEST(UnitTestMatStandalone, MatPerspectiveRightHandedZeroToOne)
 {
-    const auto proj =
-            mat_perspective_right_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                    90.f, 16.f / 9.f, 0.1f, 1000.f);
+    const auto proj = mat_perspective_right_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+            90.f, 16.f / 9.f, 0.1f, 1000.f);
 
     // Near plane point (negative z for right-handed) should map to z ~ 0
     auto near_pt = proj * mat_column_from_vector<float>({0, 0, -0.1f});
@@ -304,8 +292,7 @@ TEST(UnitTestMatStandalone, MatPerspectiveNegativeOneToOneRange)
     // Verify existing [-1, 1] behavior with explicit template arg matches default
     const auto proj_default = mat_perspective_left_handed_vertical_fov(90.f, 16.f / 9.f, 0.1f, 1000.f);
     const auto proj_explicit = mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
-                                                                        NDCDepthRange::NEGATIVE_ONE_TO_ONE>(
-            90.f, 16.f / 9.f, 0.1f, 1000.f);
+            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(90.f, 16.f / 9.f, 0.1f, 1000.f);
 
     EXPECT_EQ(proj_default, proj_explicit);
 
@@ -323,8 +310,7 @@ TEST(UnitTestMatStandalone, MatPerspectiveNegativeOneToOneRange)
 TEST(UnitTestMatStandalone, MatPerspectiveRightHandedNegOneToOne)
 {
     const auto proj = mat_perspective_right_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
-                                                                NDCDepthRange::NEGATIVE_ONE_TO_ONE>(90.f, 16.f / 9.f,
-                                                                                                    0.1f, 1000.f);
+            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(90.f, 16.f / 9.f, 0.1f, 1000.f);
 
     // Near plane (negative z for RH) should map to z ~ -1
     auto near_pt = proj * mat_column_from_vector<float>({0, 0, -0.1f});
@@ -340,15 +326,14 @@ TEST(UnitTestMatStandalone, MatPerspectiveRightHandedNegOneToOne)
     auto mid_pt = proj * mat_column_from_vector<float>({0, 0, -500.f});
     mid_pt /= mid_pt.at(3, 0);
     EXPECT_GT(mid_pt.at(2, 0), -1.0f);
-    EXPECT_LT(mid_pt.at(2, 0), 1.0f);
+    EXPECT_LT(mid_pt.at(2, 0),  1.0f);
 }
 
 TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedHorizontalFovZeroToOne)
 {
     // hfov=90 deg, aspect=16/9 => tan(hfov/2)=1, so x_axis=1 and y_axis=aspect
-    const auto proj =
-            mat_perspective_left_handed_horizontal_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                    90.f, 16.f / 9.f, 0.1f, 1000.f);
+    const auto proj = mat_perspective_left_handed_horizontal_fov<float, MatStoreType::ROW_MAJOR,
+            NDCDepthRange::ZERO_TO_ONE>(90.f, 16.f / 9.f, 0.1f, 1000.f);
 
     // Near plane should map to z ~ 0
     auto near_pt = proj * mat_column_from_vector<float>({0, 0, 0.1f});
@@ -369,8 +354,7 @@ TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedHorizontalFovZeroToOne)
 TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedHorizontalFovNegOneToOne)
 {
     const auto proj = mat_perspective_left_handed_horizontal_fov<float, MatStoreType::ROW_MAJOR,
-                                                                 NDCDepthRange::NEGATIVE_ONE_TO_ONE>(90.f, 16.f / 9.f,
-                                                                                                     0.1f, 1000.f);
+            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(90.f, 16.f / 9.f, 0.1f, 1000.f);
 
     auto near_pt = proj * mat_column_from_vector<float>({0, 0, 0.1f});
     near_pt /= near_pt.at(3, 0);
@@ -387,9 +371,8 @@ TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedHorizontalFovNegOneToOne)
 
 TEST(UnitTestMatStandalone, MatPerspectiveRightHandedHorizontalFovZeroToOne)
 {
-    const auto proj =
-            mat_perspective_right_handed_horizontal_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                    90.f, 16.f / 9.f, 0.1f, 1000.f);
+    const auto proj = mat_perspective_right_handed_horizontal_fov<float, MatStoreType::ROW_MAJOR,
+            NDCDepthRange::ZERO_TO_ONE>(90.f, 16.f / 9.f, 0.1f, 1000.f);
 
     auto near_pt = proj * mat_column_from_vector<float>({0, 0, -0.1f});
     near_pt /= near_pt.at(3, 0);
@@ -407,8 +390,7 @@ TEST(UnitTestMatStandalone, MatPerspectiveRightHandedHorizontalFovZeroToOne)
 TEST(UnitTestMatStandalone, MatPerspectiveRightHandedHorizontalFovNegOneToOne)
 {
     const auto proj = mat_perspective_right_handed_horizontal_fov<float, MatStoreType::ROW_MAJOR,
-                                                                  NDCDepthRange::NEGATIVE_ONE_TO_ONE>(90.f, 16.f / 9.f,
-                                                                                                      0.1f, 1000.f);
+            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(90.f, 16.f / 9.f, 0.1f, 1000.f);
 
     auto near_pt = proj * mat_column_from_vector<float>({0, 0, -0.1f});
     near_pt /= near_pt.at(3, 0);
@@ -426,7 +408,7 @@ TEST(UnitTestMatStandalone, MatPerspectiveRightHandedHorizontalFovNegOneToOne)
 TEST(UnitTestMatStandalone, MatPerspectiveHorizontalVsVerticalFovEquivalence)
 {
     constexpr float hfov_deg = 90.f;
-    constexpr float aspect = 16.f / 9.f;
+    constexpr float aspect   = 16.f / 9.f;
     const float vfov_deg = angles::horizontal_fov_to_vertical(hfov_deg, aspect);
 
     const auto proj_h = mat_perspective_left_handed_horizontal_fov(hfov_deg, aspect, 0.1f, 1000.f);
@@ -444,11 +426,11 @@ TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedVerticalFovHandedness)
 {
     const auto proj = mat_perspective_left_handed_vertical_fov(90.f, 16.f / 9.f, 0.1f, 1000.f);
 
-    const auto in_front = proj * mat_column_from_vector<float>({0, 0, 1.f});
-    const auto behind = proj * mat_column_from_vector<float>({0, 0, -1.f});
+    const auto in_front = proj * mat_column_from_vector<float>({0, 0,  1.f});
+    const auto behind   = proj * mat_column_from_vector<float>({0, 0, -1.f});
 
     EXPECT_GT(in_front.at(3, 0), 0.0f);
-    EXPECT_LT(behind.at(3, 0), 0.0f);
+    EXPECT_LT(behind.at(3, 0),   0.0f);
 }
 
 TEST(UnitTestMatStandalone, MatPerspectiveRightHandedVerticalFovHandedness)
@@ -456,21 +438,21 @@ TEST(UnitTestMatStandalone, MatPerspectiveRightHandedVerticalFovHandedness)
     const auto proj = mat_perspective_right_handed_vertical_fov(90.f, 16.f / 9.f, 0.1f, 1000.f);
 
     const auto in_front = proj * mat_column_from_vector<float>({0, 0, -1.f});
-    const auto behind = proj * mat_column_from_vector<float>({0, 0, 1.f});
+    const auto behind   = proj * mat_column_from_vector<float>({0, 0,  1.f});
 
     EXPECT_GT(in_front.at(3, 0), 0.0f);
-    EXPECT_LT(behind.at(3, 0), 0.0f);
+    EXPECT_LT(behind.at(3, 0),   0.0f);
 }
 
 TEST(UnitTestMatStandalone, MatPerspectiveLeftHandedHorizontalFovHandedness)
 {
     const auto proj = mat_perspective_left_handed_horizontal_fov(90.f, 16.f / 9.f, 0.1f, 1000.f);
 
-    const auto in_front = proj * mat_column_from_vector<float>({0, 0, 1.f});
-    const auto behind = proj * mat_column_from_vector<float>({0, 0, -1.f});
+    const auto in_front = proj * mat_column_from_vector<float>({0, 0,  1.f});
+    const auto behind   = proj * mat_column_from_vector<float>({0, 0, -1.f});
 
     EXPECT_GT(in_front.at(3, 0), 0.0f);
-    EXPECT_LT(behind.at(3, 0), 0.0f);
+    EXPECT_LT(behind.at(3, 0),   0.0f);
 }
 
 TEST(UnitTestMatStandalone, MatPerspectiveRightHandedHorizontalFovHandedness)
@@ -478,10 +460,10 @@ TEST(UnitTestMatStandalone, MatPerspectiveRightHandedHorizontalFovHandedness)
     const auto proj = mat_perspective_right_handed_horizontal_fov(90.f, 16.f / 9.f, 0.1f, 1000.f);
 
     const auto in_front = proj * mat_column_from_vector<float>({0, 0, -1.f});
-    const auto behind = proj * mat_column_from_vector<float>({0, 0, 1.f});
+    const auto behind   = proj * mat_column_from_vector<float>({0, 0,  1.f});
 
     EXPECT_GT(in_front.at(3, 0), 0.0f);
-    EXPECT_LT(behind.at(3, 0), 0.0f);
+    EXPECT_LT(behind.at(3, 0),   0.0f);
 }
 
 TEST(UnitTestMatStandalone, MatPerspectiveZeroToOneEquanity)
@@ -490,12 +472,10 @@ TEST(UnitTestMatStandalone, MatPerspectiveZeroToOneEquanity)
     constexpr omath::Vector3<float> left_handed = {0, 2, 10};
     constexpr omath::Vector3<float> right_handed = {0, 2, -10};
 
-    const auto proj_lh =
-            mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                    90.f, 16.f / 9.f, 0.1f, 1000.f);
-    const auto proj_rh =
-            mat_perspective_right_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
-                    90.f, 16.f / 9.f, 0.1f, 1000.f);
+    const auto proj_lh = mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+            90.f, 16.f / 9.f, 0.1f, 1000.f);
+    const auto proj_rh = mat_perspective_right_handed_vertical_fov<float, MatStoreType::ROW_MAJOR, NDCDepthRange::ZERO_TO_ONE>(
+            90.f, 16.f / 9.f, 0.1f, 1000.f);
 
     auto ndc_lh = proj_lh * mat_column_from_vector(left_handed);
     auto ndc_rh = proj_rh * mat_column_from_vector(right_handed);
@@ -538,51 +518,8 @@ TEST(UnitTestMatStandalone, MatOrthoNegativeOneToOneDefault)
 {
     // Verify explicit [-1, 1] matches default
     const auto ortho_default = mat_ortho_left_handed(-1.f, 1.f, -1.f, 1.f, 0.1f, 100.f);
-    const auto ortho_explicit =
-            mat_ortho_left_handed<float, MatStoreType::ROW_MAJOR, NDCDepthRange::NEGATIVE_ONE_TO_ONE>(-1.f, 1.f, -1.f,
-                                                                                                      1.f, 0.1f, 100.f);
+    const auto ortho_explicit = mat_ortho_left_handed<float, MatStoreType::ROW_MAJOR,
+            NDCDepthRange::NEGATIVE_ONE_TO_ONE>(-1.f, 1.f, -1.f, 1.f, 0.1f, 100.f);
 
     EXPECT_EQ(ortho_default, ortho_explicit);
 }
-
-static_assert(
-        []
-        {
-            constexpr auto scale = mat_extract_scale(mat_scale(Vector3{2.0f, 3.0f, 4.0f}));
-            return close_to(scale.x, 2.0f, 1e-5f) && close_to(scale.y, 3.0f, 1e-5f) && close_to(scale.z, 4.0f, 1e-5f);
-        }(),
-        "Mat scale extraction should be constexpr with embedded constexpr math");
-
-static_assert(
-        []
-        {
-            constexpr auto rotation = mat_rotation_axis_z<float>(Pitch::from_degrees(90.0f));
-            return close_to(rotation.at(0, 0), 0.0f, 1e-5f) && close_to(rotation.at(0, 1), -1.0f, 1e-5f)
-                   && close_to(rotation.at(1, 0), 1.0f, 1e-5f) && close_to(rotation.at(1, 1), 0.0f, 1e-5f)
-                   && close_to(rotation.at(2, 2), 1.0f, 1e-5f) && close_to(rotation.at(3, 3), 1.0f, 1e-5f);
-        }(),
-        "Mat rotation should be constexpr with embedded constexpr math");
-
-static_assert(
-        []
-        {
-            constexpr auto projection =
-                    mat_perspective_left_handed_vertical_fov<float, MatStoreType::ROW_MAJOR,
-                                                             NDCDepthRange::ZERO_TO_ONE>(90.0f, 1.0f, 1.0f, 11.0f);
-            return close_to(projection.at(0, 0), 1.0f, 1e-5f) && close_to(projection.at(1, 1), 1.0f, 1e-5f)
-                   && close_to(projection.at(2, 2), 1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f)
-                   && close_to(projection.at(3, 2), 1.0f, 1e-5f);
-        }(),
-        "Mat vertical-FOV perspective should be constexpr with embedded constexpr math");
-
-static_assert(
-        []
-        {
-            constexpr auto projection =
-                    mat_perspective_right_handed_horizontal_fov<float, MatStoreType::ROW_MAJOR,
-                                                                NDCDepthRange::ZERO_TO_ONE>(90.0f, 2.0f, 1.0f, 11.0f);
-            return close_to(projection.at(0, 0), 1.0f, 1e-5f) && close_to(projection.at(1, 1), 2.0f, 1e-5f)
-                   && close_to(projection.at(2, 2), -1.1f, 1e-5f) && close_to(projection.at(2, 3), -1.1f, 1e-5f)
-                   && close_to(projection.at(3, 2), -1.0f, 1e-5f);
-        }(),
-        "Mat horizontal-FOV perspective should be constexpr with embedded constexpr math");

tests/general/unit_test_pattern_scan.cpp

@@ -4,8 +4,8 @@
 #include "omath/utility/pe_pattern_scan.hpp"
 #include "gtest/gtest.h"
 #include <omath/utility/pattern_scan.hpp>
-#include <print>
 #include <source_location>
+#include <print>
 TEST(unit_test_pattern_scan, read_test)
 {
     const auto result = omath::PatternScanner::parse_pattern("FF ? ?? E9");
@@ -51,37 +51,3 @@ TEST(unit_test_pattern_scan, corner_case_4)
     const auto result = omath::PatternScanner::parse_pattern("X ? ?? E9 ");
     EXPECT_FALSE(result.has_value());
 }
-
-TEST(unit_test_pattern_scan, consteval_read_test)
-{
-    constexpr auto result = omath::PatternScanner::parse_pattern<"FF ? ?? E9">();
-
-    static_assert(result.size() == 4);
-    static_assert(result[0] == static_cast<std::byte>(0xFF));
-    static_assert(result[1] == std::nullopt);
-    static_assert(result[2] == std::nullopt);
-    static_assert(result[3] == static_cast<std::byte>(0xE9));
-
-    EXPECT_EQ(result[0], static_cast<std::byte>(0xFF));
-    EXPECT_EQ(result[1], std::nullopt);
-    EXPECT_EQ(result[2], std::nullopt);
-    EXPECT_EQ(result[3], static_cast<std::byte>(0xE9));
-}
-
-TEST(unit_test_pattern_scan, consteval_spacing_and_case)
-{
-    constexpr auto result = omath::PatternScanner::parse_pattern<" \tde\nAD\r?? ? ef ">();
-
-    static_assert(result.size() == 5);
-    static_assert(result[0] == static_cast<std::byte>(0xDE));
-    static_assert(result[1] == static_cast<std::byte>(0xAD));
-    static_assert(result[2] == std::nullopt);
-    static_assert(result[3] == std::nullopt);
-    static_assert(result[4] == static_cast<std::byte>(0xEF));
-
-    EXPECT_EQ(result[0], static_cast<std::byte>(0xDE));
-    EXPECT_EQ(result[1], static_cast<std::byte>(0xAD));
-    EXPECT_EQ(result[2], std::nullopt);
-    EXPECT_EQ(result[3], std::nullopt);
-    EXPECT_EQ(result[4], static_cast<std::byte>(0xEF));
-}

tests/general/unit_test_pattern_scan_extra.cpp

@@ -14,16 +14,6 @@ TEST(unit_test_pattern_scan_extra, IteratorScanFound)
     EXPECT_EQ(std::distance(buf.begin(), it), 0);
 }
 
-TEST(unit_test_pattern_scan_extra, ConstevalIteratorScan)
-{
-    std::vector<std::byte> buf = {static_cast<std::byte>(0x00), static_cast<std::byte>(0xDE),
-                                  static_cast<std::byte>(0xAD), static_cast<std::byte>(0xBE),
-                                  static_cast<std::byte>(0xEF), static_cast<std::byte>(0x11)};
-    const auto it = PatternScanner::scan_for_pattern<"DE ?? BE EF">(buf.begin(), buf.end());
-    EXPECT_NE(it, buf.end());
-    EXPECT_EQ(std::distance(buf.begin(), it), 1);
-}
-
 TEST(unit_test_pattern_scan_extra, IteratorScanNotFound)
 {
     std::vector<std::byte> buf = {static_cast<std::byte>(0x00), static_cast<std::byte>(0x11),

tests/general/unit_test_pe_memory_file_scan.cpp

@@ -1,7 +1,5 @@
 // Tests for PePatternScanner::scan_for_pattern_in_memory_file
 #include <cstring>
-#include <filesystem>
-#include <fstream>
 #include <gtest/gtest.h>
 #include <omath/utility/pe_pattern_scan.hpp>
 #include <span>
@@ -12,7 +10,8 @@ using namespace omath;
 // Reuse the fake-module builder from unit_test_pe_pattern_scan_loaded.cpp but
 // lay out the buffer as a raw PE *file* (ptr_raw_data != virtual_address).
 static std::vector<std::byte> make_fake_pe_file(std::uint32_t virtual_address, std::uint32_t ptr_raw_data,
-                                                std::uint32_t section_size, const std::vector<std::uint8_t>& code_bytes)
+                                                std::uint32_t section_size,
+                                                const std::vector<std::uint8_t>& code_bytes)
 {
     constexpr std::uint32_t e_lfanew = 0x80;
     constexpr std::uint32_t nt_sig = 0x4550;
@@ -25,18 +24,9 @@ static std::vector<std::byte> make_fake_pe_file(std::uint32_t virtual_address, s
     const std::uint32_t total_size = ptr_raw_data + section_size + 0x100;
     std::vector<std::byte> buf(total_size, std::byte{0});
 
-    auto w16 = [&](std::size_t off, std::uint16_t v)
-    {
-        std::memcpy(buf.data() + off, &v, 2);
-    };
-    auto w32 = [&](std::size_t off, std::uint32_t v)
-    {
-        std::memcpy(buf.data() + off, &v, 4);
-    };
-    auto w64 = [&](std::size_t off, std::uint64_t v)
-    {
-        std::memcpy(buf.data() + off, &v, 8);
-    };
+    auto w16 = [&](std::size_t off, std::uint16_t v) { std::memcpy(buf.data() + off, &v, 2); };
+    auto w32 = [&](std::size_t off, std::uint32_t v) { std::memcpy(buf.data() + off, &v, 4); };
+    auto w64 = [&](std::size_t off, std::uint64_t v) { std::memcpy(buf.data() + off, &v, 8); };
 
     // DOS header
     w16(0x00, 0x5A4D);
@@ -58,10 +48,10 @@ static std::vector<std::byte> make_fake_pe_file(std::uint32_t virtual_address, s
     // Section header (.text)
     const std::size_t sh_off = section_table_off;
     std::memcpy(buf.data() + sh_off, ".text", 5);
-    w32(sh_off + 8, section_size); // VirtualSize
-    w32(sh_off + 12, virtual_address); // VirtualAddress
-    w32(sh_off + 16, section_size); // SizeOfRawData
-    w32(sh_off + 20, ptr_raw_data); // PointerToRawData
+    w32(sh_off + 8, section_size);        // VirtualSize
+    w32(sh_off + 12, virtual_address);    // VirtualAddress
+    w32(sh_off + 16, section_size);       // SizeOfRawData
+    w32(sh_off + 20, ptr_raw_data);       // PointerToRawData
 
     // Place code at raw file offset
     const std::size_t copy_len = std::min(code_bytes.size(), static_cast<std::size_t>(section_size));
@@ -97,24 +87,13 @@ TEST(unit_test_pe_memory_file_scan, finds_pattern_with_wildcard)
     EXPECT_EQ(result->target_offset, 0);
 }
 
-TEST(unit_test_pe_memory_file_scan, consteval_finds_pattern_with_wildcard)
-{
-    const std::vector<std::uint8_t> code = {0x00, 0xDE, 0xAD, 0xBE, 0xEF};
-    const auto buf = make_fake_pe_file(0x2000, 0x600, static_cast<std::uint32_t>(code.size()), code);
-
-    const auto result =
-            PePatternScanner::scan_for_pattern_in_memory_file<"DE ?? BE EF">(std::span<const std::byte>{buf});
-
-    ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(result->target_offset, 1);
-}
-
 TEST(unit_test_pe_memory_file_scan, pattern_not_found_returns_nullopt)
 {
     const std::vector<std::uint8_t> code = {0x01, 0x02, 0x03};
     const auto buf = make_fake_pe_file(0x1000, 0x400, static_cast<std::uint32_t>(code.size()), code);
 
-    const auto result = PePatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "AA BB CC");
+    const auto result =
+            PePatternScanner::scan_for_pattern_in_memory_file(std::span<const std::byte>{buf}, "AA BB CC");
 
     EXPECT_FALSE(result.has_value());
 }
@@ -147,27 +126,3 @@ TEST(unit_test_pe_memory_file_scan, raw_addr_differs_from_virtual_address)
     // virtual_base_addr = virtual_address + image_base (image_base = 0)
     EXPECT_EQ(result->virtual_base_addr, 0x3000u);
 }
-
-TEST(unit_test_pe_memory_file_scan, consteval_file_scan_finds_pattern)
-{
-    const std::vector<std::uint8_t> code = {0x48, 0x89, 0xE5, 0xDE, 0xAD};
-    const auto buf = make_fake_pe_file(0x2000, 0x600, static_cast<std::uint32_t>(code.size()), code);
-    const auto tmp_path = std::filesystem::temp_directory_path() / "omath_pe_consteval_test.exe";
-    {
-        std::ofstream out(tmp_path, std::ios::binary);
-        out.write(reinterpret_cast<const char*>(buf.data()), static_cast<std::streamsize>(buf.size()));
-    }
-
-    const auto result = PePatternScanner::scan_for_pattern_in_file<"48 ?? E5">(tmp_path);
-
-    std::filesystem::remove(tmp_path);
-
-    ASSERT_TRUE(result.has_value());
-    EXPECT_EQ(result->target_offset, 0);
-}
-
-TEST(unit_test_pe_memory_file_scan, consteval_loaded_module_null_returns_nullopt)
-{
-    const auto result = PePatternScanner::scan_for_pattern_in_loaded_module<"DE AD">(nullptr);
-    EXPECT_FALSE(result.has_value());
-}

tests/general/unit_test_projection.cpp

@@ -1,7 +1,6 @@
 //
 // Created by Vlad on 27.08.2024.
 //
-#include "omath/algorithm/radar.hpp"
 #include "omath/engines/unity_engine/camera.hpp"
 #include <complex>
 #include <gtest/gtest.h>
@@ -61,34 +60,15 @@ static void verify_random_look_at_targets_project_to_screen_center(const omath::
     }
 }
 
-constexpr bool source_camera_constexpr_projection_round_trip()
-{
-    constexpr auto fov = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>::from_degrees(90.f);
-    constexpr auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f},
-                                                      fov, 0.01f, 1000.f);
-
-    constexpr auto projected = cam.world_to_screen({1000.f, 0, 50.f});
-    constexpr auto result = cam.screen_to_world(projected.value());
-    constexpr auto result2 = cam.world_to_screen(result.value());
-
-    return projected.has_value() && result.has_value() && result2.has_value()
-           && static_cast<omath::Vector2<float>>(projected.value())
-                      == static_cast<omath::Vector2<float>>(result2.value())
-           && omath::internal::abs(projected->x - 960.f) < 0.001f && omath::internal::abs(projected->y - 504.f) < 0.001f
-           && omath::internal::abs(projected->z - 1.f) < 0.001f;
-}
-
-static_assert(source_camera_constexpr_projection_round_trip());
-
 TEST(UnitTestProjection, Projection)
 {
     constexpr auto fov = omath::Angle<float, 0.f, 180.f, omath::AngleFlags::Clamped>::from_degrees(90.f);
-    constexpr auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f},
-                                                      fov, 0.01f, 1000.f);
+    const auto cam = omath::source_engine::Camera({0, 0, 0}, omath::source_engine::ViewAngles{}, {1920.f, 1080.f}, fov,
+                                                  0.01f, 1000.f);
 
-    constexpr auto projected = cam.world_to_screen({1000.f, 0, 50.f});
-    constexpr auto result = cam.screen_to_world(projected.value());
-    constexpr auto result2 = cam.world_to_screen(result.value());
+    const auto projected = cam.world_to_screen({1000.f, 0, 50.f});
+    const auto result = cam.screen_to_world(projected.value());
+    const auto result2 = cam.world_to_screen(result.value());
 
     EXPECT_EQ(static_cast<omath::Vector2<float>>(projected.value()),
               static_cast<omath::Vector2<float>>(result2.value()));
@@ -581,55 +561,15 @@ TEST(UnitTestProjection, AabbUnityEngineStraddlesNearNotCulled)
     EXPECT_FALSE(cam.is_aabb_culled_by_frustum(aabb));
 }
 
-TEST(UnitTestProjection, WorldToViewCoordinates_TranslatedSourceCamera)
-{
-    constexpr float k_eps = 1e-4f;
-    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    auto cam = omath::source_engine::Camera({10.f, 20.f, 30.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
-
-    const auto view_coordinates = cam.world_to_view_coordinates({15.f, 12.f, 37.f});
-
-    EXPECT_NEAR(view_coordinates.x, 8.f, k_eps);
-    EXPECT_NEAR(view_coordinates.y, 7.f, k_eps);
-    EXPECT_NEAR(view_coordinates.z, 5.f, k_eps);
-}
-
-TEST(UnitTestProjection, WorldToViewCoordinates_RotatedSourceCamera)
-{
-    constexpr float k_eps = 1e-4f;
-    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(0.f),
-                                                  omath::source_engine::YawAngle::from_degrees(90.f),
-                                                  omath::source_engine::RollAngle::from_degrees(0.f)};
-    auto cam = omath::source_engine::Camera({10.f, 20.f, 30.f}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
-
-    const auto view_coordinates = cam.world_to_view_coordinates({14.f, 26.f, 38.f});
-
-    EXPECT_NEAR(view_coordinates.x, 4.f, k_eps);
-    EXPECT_NEAR(view_coordinates.y, 8.f, k_eps);
-    EXPECT_NEAR(view_coordinates.z, 6.f, k_eps);
-}
-
-TEST(UnitTestProjection, WorldToViewCoordinates_ColumnMajorOpenGlCamera)
-{
-    constexpr float k_eps = 1e-4f;
-    constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    auto cam = omath::opengl_engine::Camera({10.f, 20.f, 30.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
-
-    const auto view_coordinates = cam.world_to_view_coordinates({14.f, 26.f, 22.f});
-
-    EXPECT_NEAR(view_coordinates.x, 4.f, k_eps);
-    EXPECT_NEAR(view_coordinates.y, 6.f, k_eps);
-    EXPECT_NEAR(view_coordinates.z, -8.f, k_eps);
-}
-
 TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_LookingForward)
 {
     constexpr float k_eps = 1e-4f;
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(0.f),
-                                                  omath::source_engine::YawAngle::from_degrees(0.f),
-                                                  omath::source_engine::RollAngle::from_degrees(0.f)};
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(0.f),
+        omath::source_engine::YawAngle::from_degrees(0.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
     const auto cam = omath::source_engine::Camera({0, 0, 0}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
@@ -642,9 +582,11 @@ TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_PositivePitchAndYaw)
 {
     constexpr float k_eps = 1e-4f;
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(30.f),
-                                                  omath::source_engine::YawAngle::from_degrees(45.f),
-                                                  omath::source_engine::RollAngle::from_degrees(0.f)};
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(30.f),
+        omath::source_engine::YawAngle::from_degrees(45.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
     const auto cam = omath::source_engine::Camera({0, 0, 0}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
@@ -657,9 +599,11 @@ TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_NegativePitchAndYaw)
 {
     constexpr float k_eps = 1e-4f;
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(-45.f),
-                                                  omath::source_engine::YawAngle::from_degrees(-90.f),
-                                                  omath::source_engine::RollAngle::from_degrees(0.f)};
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(-45.f),
+        omath::source_engine::YawAngle::from_degrees(-90.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
     const auto cam = omath::source_engine::Camera({0, 0, 0}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
@@ -674,9 +618,11 @@ TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_OffOriginCameraIgnored)
     // so the same angles should be recovered regardless of position.
     constexpr float k_eps = 1e-4f;
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(20.f),
-                                                  omath::source_engine::YawAngle::from_degrees(60.f),
-                                                  omath::source_engine::RollAngle::from_degrees(0.f)};
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(20.f),
+        omath::source_engine::YawAngle::from_degrees(60.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
     const auto cam = omath::source_engine::Camera({100.f, 200.f, -50.f}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
@@ -689,9 +635,11 @@ TEST(UnitTestProjection, CalcViewAnglesFromViewMatrix_RollAlwaysZero)
 {
     // Roll cannot be encoded in the forward vector, so it is always 0 in the result.
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(10.f),
-                                                  omath::source_engine::YawAngle::from_degrees(30.f),
-                                                  omath::source_engine::RollAngle::from_degrees(15.f)};
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(10.f),
+        omath::source_engine::YawAngle::from_degrees(30.f),
+        omath::source_engine::RollAngle::from_degrees(15.f)
+    };
     const auto cam = omath::source_engine::Camera({0, 0, 0}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     const auto result = omath::source_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
@@ -716,9 +664,11 @@ TEST(UnitTestProjection, CalcOriginFromViewMatrix_ArbitraryPosition)
 {
     constexpr float k_eps = 1e-3f;
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(0.f),
-                                                  omath::source_engine::YawAngle::from_degrees(0.f),
-                                                  omath::source_engine::RollAngle::from_degrees(0.f)};
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(0.f),
+        omath::source_engine::YawAngle::from_degrees(0.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
     const auto cam = omath::source_engine::Camera({100.f, 200.f, -50.f}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     const auto origin = omath::source_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix());
@@ -733,9 +683,11 @@ TEST(UnitTestProjection, CalcOriginFromViewMatrix_WithRotation)
     // Origin recovery must work even when the camera is rotated.
     constexpr float k_eps = 1e-3f;
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    const omath::source_engine::ViewAngles angles{omath::source_engine::PitchAngle::from_degrees(30.f),
-                                                  omath::source_engine::YawAngle::from_degrees(45.f),
-                                                  omath::source_engine::RollAngle::from_degrees(0.f)};
+    const omath::source_engine::ViewAngles angles{
+        omath::source_engine::PitchAngle::from_degrees(30.f),
+        omath::source_engine::YawAngle::from_degrees(45.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
     const auto cam = omath::source_engine::Camera({300.f, -100.f, 75.f}, angles, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     const auto origin = omath::source_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix());
@@ -752,12 +704,16 @@ TEST(UnitTestProjection, CalcOriginFromViewMatrix_IndependentOfAngles)
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
     constexpr omath::Vector3<float> expected_origin{50.f, 50.f, 50.f};
 
-    const omath::source_engine::ViewAngles angles_a{omath::source_engine::PitchAngle::from_degrees(0.f),
-                                                    omath::source_engine::YawAngle::from_degrees(0.f),
-                                                    omath::source_engine::RollAngle::from_degrees(0.f)};
-    const omath::source_engine::ViewAngles angles_b{omath::source_engine::PitchAngle::from_degrees(-60.f),
-                                                    omath::source_engine::YawAngle::from_degrees(135.f),
-                                                    omath::source_engine::RollAngle::from_degrees(0.f)};
+    const omath::source_engine::ViewAngles angles_a{
+        omath::source_engine::PitchAngle::from_degrees(0.f),
+        omath::source_engine::YawAngle::from_degrees(0.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
+    const omath::source_engine::ViewAngles angles_b{
+        omath::source_engine::PitchAngle::from_degrees(-60.f),
+        omath::source_engine::YawAngle::from_degrees(135.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
 
     const auto cam_a = omath::source_engine::Camera(expected_origin, angles_a, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
     const auto cam_b = omath::source_engine::Camera(expected_origin, angles_b, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
@@ -780,9 +736,11 @@ TEST(UnitTestProjection, Unity_CalcViewAnglesFromViewMatrix_LookingForward)
 {
     constexpr float k_eps = 1e-4f;
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
-    const omath::unity_engine::ViewAngles angles{omath::unity_engine::PitchAngle::from_degrees(0.f),
-                                                 omath::unity_engine::YawAngle::from_degrees(0.f),
-                                                 omath::unity_engine::RollAngle::from_degrees(0.f)};
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(0.f),
+        omath::unity_engine::YawAngle::from_degrees(0.f),
+        omath::unity_engine::RollAngle::from_degrees(0.f)
+    };
     const auto cam = omath::unity_engine::Camera({0, 0, 0}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f);
 
     const auto result = omath::unity_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
@@ -795,9 +753,11 @@ TEST(UnitTestProjection, Unity_CalcViewAnglesFromViewMatrix_PositivePitchAndYaw)
 {
     constexpr float k_eps = 1e-4f;
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
-    const omath::unity_engine::ViewAngles angles{omath::unity_engine::PitchAngle::from_degrees(30.f),
-                                                 omath::unity_engine::YawAngle::from_degrees(45.f),
-                                                 omath::unity_engine::RollAngle::from_degrees(0.f)};
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(30.f),
+        omath::unity_engine::YawAngle::from_degrees(45.f),
+        omath::unity_engine::RollAngle::from_degrees(0.f)
+    };
     const auto cam = omath::unity_engine::Camera({0, 0, 0}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f);
 
     const auto result = omath::unity_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
@@ -810,9 +770,11 @@ TEST(UnitTestProjection, Unity_CalcViewAnglesFromViewMatrix_NegativePitchAndYaw)
 {
     constexpr float k_eps = 1e-4f;
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
-    const omath::unity_engine::ViewAngles angles{omath::unity_engine::PitchAngle::from_degrees(-45.f),
-                                                 omath::unity_engine::YawAngle::from_degrees(-90.f),
-                                                 omath::unity_engine::RollAngle::from_degrees(0.f)};
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(-45.f),
+        omath::unity_engine::YawAngle::from_degrees(-90.f),
+        omath::unity_engine::RollAngle::from_degrees(0.f)
+    };
     const auto cam = omath::unity_engine::Camera({0, 0, 0}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f);
 
     const auto result = omath::unity_engine::Camera::calc_view_angles_from_view_matrix(cam.get_view_matrix());
@@ -838,9 +800,11 @@ TEST(UnitTestProjection, Unity_CalcOriginFromViewMatrix_ArbitraryPosition)
 {
     constexpr float k_eps = 1e-3f;
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
-    const omath::unity_engine::ViewAngles angles{omath::unity_engine::PitchAngle::from_degrees(0.f),
-                                                 omath::unity_engine::YawAngle::from_degrees(0.f),
-                                                 omath::unity_engine::RollAngle::from_degrees(0.f)};
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(0.f),
+        omath::unity_engine::YawAngle::from_degrees(0.f),
+        omath::unity_engine::RollAngle::from_degrees(0.f)
+    };
     const auto cam = omath::unity_engine::Camera({100.f, 200.f, -50.f}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f);
 
     const auto origin = omath::unity_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix());
@@ -854,9 +818,11 @@ TEST(UnitTestProjection, Unity_CalcOriginFromViewMatrix_WithRotation)
 {
     constexpr float k_eps = 1e-3f;
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(60.f);
-    const omath::unity_engine::ViewAngles angles{omath::unity_engine::PitchAngle::from_degrees(30.f),
-                                                 omath::unity_engine::YawAngle::from_degrees(45.f),
-                                                 omath::unity_engine::RollAngle::from_degrees(0.f)};
+    const omath::unity_engine::ViewAngles angles{
+        omath::unity_engine::PitchAngle::from_degrees(30.f),
+        omath::unity_engine::YawAngle::from_degrees(45.f),
+        omath::unity_engine::RollAngle::from_degrees(0.f)
+    };
     const auto cam = omath::unity_engine::Camera({300.f, -100.f, 75.f}, angles, {1280.f, 720.f}, fov, 0.03f, 1000.f);
 
     const auto origin = omath::unity_engine::Camera::calc_origin_from_view_matrix(cam.get_view_matrix());
@@ -872,21 +838,21 @@ TEST(UnitTestProjection, SourceEngine_ZeroAngles_BasisVectors)
     constexpr float k_eps = 1e-5f;
     const auto cam = omath::source_engine::Camera({}, {}, {1920.f, 1080.f},
                                                   omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
-    const auto fwd = cam.get_abs_forward();
+    const auto fwd   = cam.get_abs_forward();
     const auto right = cam.get_abs_right();
-    const auto up = cam.get_abs_up();
+    const auto up    = cam.get_abs_up();
 
-    EXPECT_NEAR(fwd.x, omath::source_engine::k_abs_forward.x, k_eps);
-    EXPECT_NEAR(fwd.y, omath::source_engine::k_abs_forward.y, k_eps);
-    EXPECT_NEAR(fwd.z, omath::source_engine::k_abs_forward.z, k_eps);
+    EXPECT_NEAR(fwd.x,   omath::source_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::source_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::source_engine::k_abs_forward.z, k_eps);
 
     EXPECT_NEAR(right.x, omath::source_engine::k_abs_right.x, k_eps);
     EXPECT_NEAR(right.y, omath::source_engine::k_abs_right.y, k_eps);
     EXPECT_NEAR(right.z, omath::source_engine::k_abs_right.z, k_eps);
 
-    EXPECT_NEAR(up.x, omath::source_engine::k_abs_up.x, k_eps);
-    EXPECT_NEAR(up.y, omath::source_engine::k_abs_up.y, k_eps);
-    EXPECT_NEAR(up.z, omath::source_engine::k_abs_up.z, k_eps);
+    EXPECT_NEAR(up.x,    omath::source_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::source_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::source_engine::k_abs_up.z, k_eps);
 }
 
 TEST(UnitTestProjection, UnityEngine_ZeroAngles_BasisVectors)
@@ -894,21 +860,21 @@ TEST(UnitTestProjection, UnityEngine_ZeroAngles_BasisVectors)
     constexpr float k_eps = 1e-5f;
     const auto cam = omath::unity_engine::Camera({}, {}, {1280.f, 720.f},
                                                  omath::projection::FieldOfView::from_degrees(60.f), 0.03f, 1000.f);
-    const auto fwd = cam.get_abs_forward();
+    const auto fwd   = cam.get_abs_forward();
     const auto right = cam.get_abs_right();
-    const auto up = cam.get_abs_up();
+    const auto up    = cam.get_abs_up();
 
-    EXPECT_NEAR(fwd.x, omath::unity_engine::k_abs_forward.x, k_eps);
-    EXPECT_NEAR(fwd.y, omath::unity_engine::k_abs_forward.y, k_eps);
-    EXPECT_NEAR(fwd.z, omath::unity_engine::k_abs_forward.z, k_eps);
+    EXPECT_NEAR(fwd.x,   omath::unity_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::unity_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::unity_engine::k_abs_forward.z, k_eps);
 
     EXPECT_NEAR(right.x, omath::unity_engine::k_abs_right.x, k_eps);
     EXPECT_NEAR(right.y, omath::unity_engine::k_abs_right.y, k_eps);
     EXPECT_NEAR(right.z, omath::unity_engine::k_abs_right.z, k_eps);
 
-    EXPECT_NEAR(up.x, omath::unity_engine::k_abs_up.x, k_eps);
-    EXPECT_NEAR(up.y, omath::unity_engine::k_abs_up.y, k_eps);
-    EXPECT_NEAR(up.z, omath::unity_engine::k_abs_up.z, k_eps);
+    EXPECT_NEAR(up.x,    omath::unity_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::unity_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::unity_engine::k_abs_up.z, k_eps);
 }
 
 TEST(UnitTestProjection, OpenGLEngine_ZeroAngles_BasisVectors)
@@ -916,21 +882,21 @@ TEST(UnitTestProjection, OpenGLEngine_ZeroAngles_BasisVectors)
     constexpr float k_eps = 1e-5f;
     const auto cam = omath::opengl_engine::Camera({}, {}, {1920.f, 1080.f},
                                                   omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
-    const auto fwd = cam.get_abs_forward();
+    const auto fwd   = cam.get_abs_forward();
     const auto right = cam.get_abs_right();
-    const auto up = cam.get_abs_up();
+    const auto up    = cam.get_abs_up();
 
-    EXPECT_NEAR(fwd.x, omath::opengl_engine::k_abs_forward.x, k_eps);
-    EXPECT_NEAR(fwd.y, omath::opengl_engine::k_abs_forward.y, k_eps);
-    EXPECT_NEAR(fwd.z, omath::opengl_engine::k_abs_forward.z, k_eps);
+    EXPECT_NEAR(fwd.x,   omath::opengl_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::opengl_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::opengl_engine::k_abs_forward.z, k_eps);
 
     EXPECT_NEAR(right.x, omath::opengl_engine::k_abs_right.x, k_eps);
     EXPECT_NEAR(right.y, omath::opengl_engine::k_abs_right.y, k_eps);
     EXPECT_NEAR(right.z, omath::opengl_engine::k_abs_right.z, k_eps);
 
-    EXPECT_NEAR(up.x, omath::opengl_engine::k_abs_up.x, k_eps);
-    EXPECT_NEAR(up.y, omath::opengl_engine::k_abs_up.y, k_eps);
-    EXPECT_NEAR(up.z, omath::opengl_engine::k_abs_up.z, k_eps);
+    EXPECT_NEAR(up.x,    omath::opengl_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::opengl_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::opengl_engine::k_abs_up.z, k_eps);
 }
 
 TEST(UnitTestProjection, UnrealEngine_ZeroAngles_BasisVectors)
@@ -938,21 +904,21 @@ TEST(UnitTestProjection, UnrealEngine_ZeroAngles_BasisVectors)
     constexpr float k_eps = 1e-5f;
     const auto cam = omath::unreal_engine::Camera({}, {}, {1920.f, 1080.f},
                                                   omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
-    const auto fwd = cam.get_abs_forward();
+    const auto fwd   = cam.get_abs_forward();
     const auto right = cam.get_abs_right();
-    const auto up = cam.get_abs_up();
+    const auto up    = cam.get_abs_up();
 
-    EXPECT_NEAR(fwd.x, omath::unreal_engine::k_abs_forward.x, k_eps);
-    EXPECT_NEAR(fwd.y, omath::unreal_engine::k_abs_forward.y, k_eps);
-    EXPECT_NEAR(fwd.z, omath::unreal_engine::k_abs_forward.z, k_eps);
+    EXPECT_NEAR(fwd.x,   omath::unreal_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::unreal_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::unreal_engine::k_abs_forward.z, k_eps);
 
     EXPECT_NEAR(right.x, omath::unreal_engine::k_abs_right.x, k_eps);
     EXPECT_NEAR(right.y, omath::unreal_engine::k_abs_right.y, k_eps);
     EXPECT_NEAR(right.z, omath::unreal_engine::k_abs_right.z, k_eps);
 
-    EXPECT_NEAR(up.x, omath::unreal_engine::k_abs_up.x, k_eps);
-    EXPECT_NEAR(up.y, omath::unreal_engine::k_abs_up.y, k_eps);
-    EXPECT_NEAR(up.z, omath::unreal_engine::k_abs_up.z, k_eps);
+    EXPECT_NEAR(up.x,    omath::unreal_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::unreal_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::unreal_engine::k_abs_up.z, k_eps);
 }
 
 TEST(UnitTestProjection, FrostbiteEngine_ZeroAngles_BasisVectors)
@@ -960,21 +926,21 @@ TEST(UnitTestProjection, FrostbiteEngine_ZeroAngles_BasisVectors)
     constexpr float k_eps = 1e-5f;
     const auto cam = omath::frostbite_engine::Camera({}, {}, {1920.f, 1080.f},
                                                      omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
-    const auto fwd = cam.get_abs_forward();
+    const auto fwd   = cam.get_abs_forward();
     const auto right = cam.get_abs_right();
-    const auto up = cam.get_abs_up();
+    const auto up    = cam.get_abs_up();
 
-    EXPECT_NEAR(fwd.x, omath::frostbite_engine::k_abs_forward.x, k_eps);
-    EXPECT_NEAR(fwd.y, omath::frostbite_engine::k_abs_forward.y, k_eps);
-    EXPECT_NEAR(fwd.z, omath::frostbite_engine::k_abs_forward.z, k_eps);
+    EXPECT_NEAR(fwd.x,   omath::frostbite_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::frostbite_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::frostbite_engine::k_abs_forward.z, k_eps);
 
     EXPECT_NEAR(right.x, omath::frostbite_engine::k_abs_right.x, k_eps);
     EXPECT_NEAR(right.y, omath::frostbite_engine::k_abs_right.y, k_eps);
     EXPECT_NEAR(right.z, omath::frostbite_engine::k_abs_right.z, k_eps);
 
-    EXPECT_NEAR(up.x, omath::frostbite_engine::k_abs_up.x, k_eps);
-    EXPECT_NEAR(up.y, omath::frostbite_engine::k_abs_up.y, k_eps);
-    EXPECT_NEAR(up.z, omath::frostbite_engine::k_abs_up.z, k_eps);
+    EXPECT_NEAR(up.x,    omath::frostbite_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::frostbite_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::frostbite_engine::k_abs_up.z, k_eps);
 }
 
 TEST(UnitTestProjection, CryEngine_ZeroAngles_BasisVectors)
@@ -982,21 +948,21 @@ TEST(UnitTestProjection, CryEngine_ZeroAngles_BasisVectors)
     constexpr float k_eps = 1e-5f;
     const auto cam = omath::cry_engine::Camera({}, {}, {1920.f, 1080.f},
                                                omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
-    const auto fwd = cam.get_abs_forward();
+    const auto fwd   = cam.get_abs_forward();
     const auto right = cam.get_abs_right();
-    const auto up = cam.get_abs_up();
+    const auto up    = cam.get_abs_up();
 
-    EXPECT_NEAR(fwd.x, omath::cry_engine::k_abs_forward.x, k_eps);
-    EXPECT_NEAR(fwd.y, omath::cry_engine::k_abs_forward.y, k_eps);
-    EXPECT_NEAR(fwd.z, omath::cry_engine::k_abs_forward.z, k_eps);
+    EXPECT_NEAR(fwd.x,   omath::cry_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::cry_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::cry_engine::k_abs_forward.z, k_eps);
 
     EXPECT_NEAR(right.x, omath::cry_engine::k_abs_right.x, k_eps);
     EXPECT_NEAR(right.y, omath::cry_engine::k_abs_right.y, k_eps);
     EXPECT_NEAR(right.z, omath::cry_engine::k_abs_right.z, k_eps);
 
-    EXPECT_NEAR(up.x, omath::cry_engine::k_abs_up.x, k_eps);
-    EXPECT_NEAR(up.y, omath::cry_engine::k_abs_up.y, k_eps);
-    EXPECT_NEAR(up.z, omath::cry_engine::k_abs_up.z, k_eps);
+    EXPECT_NEAR(up.x,    omath::cry_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::cry_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::cry_engine::k_abs_up.z, k_eps);
 }
 
 TEST(UnitTestProjection, IWEngine_ZeroAngles_BasisVectors)
@@ -1004,21 +970,21 @@ TEST(UnitTestProjection, IWEngine_ZeroAngles_BasisVectors)
     constexpr float k_eps = 1e-5f;
     const auto cam = omath::iw_engine::Camera({}, {}, {1920.f, 1080.f},
                                               omath::projection::FieldOfView::from_degrees(90.f), 0.01f, 1000.f);
-    const auto fwd = cam.get_abs_forward();
+    const auto fwd   = cam.get_abs_forward();
     const auto right = cam.get_abs_right();
-    const auto up = cam.get_abs_up();
+    const auto up    = cam.get_abs_up();
 
-    EXPECT_NEAR(fwd.x, omath::iw_engine::k_abs_forward.x, k_eps);
-    EXPECT_NEAR(fwd.y, omath::iw_engine::k_abs_forward.y, k_eps);
-    EXPECT_NEAR(fwd.z, omath::iw_engine::k_abs_forward.z, k_eps);
+    EXPECT_NEAR(fwd.x,   omath::iw_engine::k_abs_forward.x, k_eps);
+    EXPECT_NEAR(fwd.y,   omath::iw_engine::k_abs_forward.y, k_eps);
+    EXPECT_NEAR(fwd.z,   omath::iw_engine::k_abs_forward.z, k_eps);
 
     EXPECT_NEAR(right.x, omath::iw_engine::k_abs_right.x, k_eps);
     EXPECT_NEAR(right.y, omath::iw_engine::k_abs_right.y, k_eps);
     EXPECT_NEAR(right.z, omath::iw_engine::k_abs_right.z, k_eps);
 
-    EXPECT_NEAR(up.x, omath::iw_engine::k_abs_up.x, k_eps);
-    EXPECT_NEAR(up.y, omath::iw_engine::k_abs_up.y, k_eps);
-    EXPECT_NEAR(up.z, omath::iw_engine::k_abs_up.z, k_eps);
+    EXPECT_NEAR(up.x,    omath::iw_engine::k_abs_up.x, k_eps);
+    EXPECT_NEAR(up.y,    omath::iw_engine::k_abs_up.y, k_eps);
+    EXPECT_NEAR(up.z,    omath::iw_engine::k_abs_up.z, k_eps);
 }
 
 // ---- extract_projection_params ----
@@ -1154,9 +1120,11 @@ TEST(UnitTestProjection, SetViewAngles_InvalidatesViewMatrix)
     auto cam = omath::source_engine::Camera({}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     const auto view_before = cam.get_view_matrix();
-    const omath::source_engine::ViewAngles rotated{omath::source_engine::PitchAngle::from_degrees(30.f),
-                                                   omath::source_engine::YawAngle::from_degrees(45.f),
-                                                   omath::source_engine::RollAngle::from_degrees(0.f)};
+    const omath::source_engine::ViewAngles rotated{
+        omath::source_engine::PitchAngle::from_degrees(30.f),
+        omath::source_engine::YawAngle::from_degrees(45.f),
+        omath::source_engine::RollAngle::from_degrees(0.f)
+    };
     cam.set_view_angles(rotated);
     const auto view_after = cam.get_view_matrix();
 
@@ -1174,7 +1142,7 @@ TEST(UnitTestProjection, CalcLookAtAngles_ForwardTarget)
     const auto angles = cam.calc_look_at_angles({100.f, 0.f, 0.f});
 
     EXPECT_NEAR(angles.pitch.as_degrees(), 0.f, 1e-4f);
-    EXPECT_NEAR(angles.yaw.as_degrees(), 0.f, 1e-4f);
+    EXPECT_NEAR(angles.yaw.as_degrees(),   0.f, 1e-4f);
 }
 
 TEST(UnitTestProjection, LookAt_ForwardVectorPointsAtTarget)
@@ -1247,7 +1215,11 @@ TEST(UnitTestProjection, TriangleInsideFrustumNotCulled)
     const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     // Small triangle directly in front (Source: +X forward)
-    const omath::Triangle<omath::Vector3<float>> tri{{100.f, 0.f, 1.f}, {100.f, 1.f, -1.f}, {100.f, -1.f, -1.f}};
+    const omath::Triangle<omath::Vector3<float>> tri{
+        {100.f,  0.f,  1.f},
+        {100.f,  1.f, -1.f},
+        {100.f, -1.f, -1.f}
+    };
     EXPECT_FALSE(cam.is_culled_by_frustum(tri));
 }
 
@@ -1257,7 +1229,11 @@ TEST(UnitTestProjection, TriangleBehindCameraCulled)
     const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     // Triangle entirely behind the camera (-X)
-    const omath::Triangle<omath::Vector3<float>> tri{{-100.f, 0.f, 1.f}, {-100.f, 1.f, -1.f}, {-100.f, -1.f, -1.f}};
+    const omath::Triangle<omath::Vector3<float>> tri{
+        {-100.f,  0.f,  1.f},
+        {-100.f,  1.f, -1.f},
+        {-100.f, -1.f, -1.f}
+    };
     EXPECT_TRUE(cam.is_culled_by_frustum(tri));
 }
 
@@ -1267,7 +1243,11 @@ TEST(UnitTestProjection, TriangleBeyondFarPlaneCulled)
     const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     // Triangle beyond the 1000-unit far plane
-    const omath::Triangle<omath::Vector3<float>> tri{{2000.f, 0.f, 1.f}, {2000.f, 1.f, -1.f}, {2000.f, -1.f, -1.f}};
+    const omath::Triangle<omath::Vector3<float>> tri{
+        {2000.f,  0.f,  1.f},
+        {2000.f,  1.f, -1.f},
+        {2000.f, -1.f, -1.f}
+    };
     EXPECT_TRUE(cam.is_culled_by_frustum(tri));
 }
 
@@ -1277,17 +1257,24 @@ TEST(UnitTestProjection, TriangleFarToSideCulled)
     const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
     // Triangle far outside the side frustum planes
-    const omath::Triangle<omath::Vector3<float>> tri{{100.f, 5000.f, 0.f}, {100.f, 5001.f, 1.f}, {100.f, 5001.f, -1.f}};
+    const omath::Triangle<omath::Vector3<float>> tri{
+        {100.f, 5000.f,  0.f},
+        {100.f, 5001.f,  1.f},
+        {100.f, 5001.f, -1.f}
+    };
     EXPECT_TRUE(cam.is_culled_by_frustum(tri));
 }
 
 TEST(UnitTestProjection, TriangleStraddlingFrustumNotCulled)
 {
     constexpr auto fov = omath::projection::FieldOfView::from_degrees(90.f);
-    constexpr auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
+    const auto cam = omath::source_engine::Camera({0.f, 0.f, 0.f}, {}, {1920.f, 1080.f}, fov, 0.01f, 1000.f);
 
-    constexpr auto position = omath::algorithm::world_to_radar(cam, {-1.f, 0.f, 0.f}, 0.1f);
     // Large triangle with vertices on both sides of the frustum — should not be culled
-    const omath::Triangle<omath::Vector3<float>> tri{{100.f, 0.f, 0.f}, {100.f, 5000.f, 0.f}, {100.f, 0.f, 5000.f}};
+    const omath::Triangle<omath::Vector3<float>> tri{
+        { 100.f,    0.f,   0.f},
+        { 100.f, 5000.f,   0.f},
+        { 100.f,    0.f, 5000.f}
+    };
     EXPECT_FALSE(cam.is_culled_by_frustum(tri));
 }

tests/general/unit_test_radar.cpp

@@ -1,164 +0,0 @@
-#include <gtest/gtest.h>
-#include <omath/algorithm/radar.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>
-
-using namespace omath;
-
-template<class CameraType, class NumericType>
-static void verify_world_to_radar_uses_engine_world_axes(const Vector3<NumericType>& world_forward,
-                                                         const Vector3<NumericType>& world_right)
-{
-    const Vector3<NumericType> origin{NumericType{10}, NumericType{-20}, NumericType{5}};
-    const NumericType world_distance = NumericType{20};
-    const NumericType scale = NumericType{0.5};
-    const auto radar_distance = static_cast<float>(world_distance * scale);
-
-    CameraType camera{
-            origin,           {}, {1280.f, 720.f}, projection::FieldOfView::from_degrees(90.f), NumericType{0.01},
-            NumericType{1000}};
-
-    const auto forward_position = origin + world_forward * world_distance;
-    const auto forward_radar = algorithm::world_to_radar(camera, forward_position, scale);
-
-    EXPECT_NEAR(forward_radar.x, 0.f, 1e-4f);
-    EXPECT_NEAR(forward_radar.y, -radar_distance, 1e-4f);
-
-    const auto right_position = origin + world_right * world_distance;
-    const auto right_radar = algorithm::world_to_radar(camera, right_position, scale);
-
-    EXPECT_NEAR(right_radar.x, radar_distance, 1e-4f);
-    EXPECT_NEAR(right_radar.y, 0.f, 1e-4f);
-}
-
-template<class CameraType, class NumericType>
-static void verify_world_to_radar_uses_changed_camera_yaw(const float yaw_degrees,
-                                                          const Vector3<NumericType>& world_forward,
-                                                          const Vector3<NumericType>& world_right)
-{
-    const Vector3<NumericType> origin{NumericType{10}, NumericType{-20}, NumericType{5}};
-    const NumericType world_distance = NumericType{20};
-    const NumericType scale = NumericType{0.5};
-    const auto radar_distance = static_cast<float>(world_distance * scale);
-
-    CameraType camera{
-            origin,           {}, {1280.f, 720.f}, projection::FieldOfView::from_degrees(90.f), NumericType{0.01},
-            NumericType{1000}};
-
-    auto angles = camera.get_view_angles();
-    angles.yaw = decltype(angles.yaw)::from_degrees(yaw_degrees);
-    camera.set_view_angles(angles);
-
-    const auto forward_position = origin + world_right * world_distance;
-    const auto forward_radar = algorithm::world_to_radar(camera, forward_position, scale);
-
-    EXPECT_NEAR(forward_radar.x, 0.f, 1e-4f);
-    EXPECT_NEAR(forward_radar.y, -radar_distance, 1e-4f);
-
-    const auto left_position = origin + world_forward * world_distance;
-    const auto left_radar = algorithm::world_to_radar(camera, left_position, scale);
-
-    EXPECT_NEAR(left_radar.x, -radar_distance, 1e-4f);
-    EXPECT_NEAR(left_radar.y, 0.f, 1e-4f);
-}
-
-template<class CameraType, class NumericType>
-static void verify_world_to_radar_ignores_camera_pitch(const Vector3<NumericType>& world_forward)
-{
-    const Vector3<NumericType> origin{NumericType{10}, NumericType{-20}, NumericType{5}};
-    const NumericType world_distance = NumericType{20};
-    const NumericType scale = NumericType{0.5};
-    const auto radar_distance = static_cast<float>(world_distance * scale);
-
-    CameraType camera{
-            origin,           {}, {1280.f, 720.f}, projection::FieldOfView::from_degrees(90.f), NumericType{0.01},
-            NumericType{1000}};
-
-    auto angles = camera.get_view_angles();
-    angles.pitch = decltype(angles.pitch)::from_degrees(45.f);
-    camera.set_view_angles(angles);
-
-    const auto forward_position = origin + world_forward * world_distance;
-    const auto forward_radar = algorithm::world_to_radar(camera, forward_position, scale);
-
-    EXPECT_NEAR(forward_radar.x, 0.f, 1e-4f);
-    EXPECT_NEAR(forward_radar.y, -radar_distance, 1e-4f);
-}
-
-TEST(WorldToRadarTests, SourceEngineCamera)
-{
-    verify_world_to_radar_uses_engine_world_axes<source_engine::Camera, float>(source_engine::k_abs_forward,
-                                                                               source_engine::k_abs_right);
-    verify_world_to_radar_uses_changed_camera_yaw<source_engine::Camera, float>(-90.f, source_engine::k_abs_forward,
-                                                                                source_engine::k_abs_right);
-    verify_world_to_radar_ignores_camera_pitch<source_engine::Camera, float>(source_engine::k_abs_forward);
-}
-
-TEST(WorldToRadarTests, IWEngineCamera)
-{
-    verify_world_to_radar_uses_engine_world_axes<iw_engine::Camera, float>(iw_engine::k_abs_forward,
-                                                                           iw_engine::k_abs_right);
-    verify_world_to_radar_uses_changed_camera_yaw<iw_engine::Camera, float>(-90.f, iw_engine::k_abs_forward,
-                                                                            iw_engine::k_abs_right);
-    verify_world_to_radar_ignores_camera_pitch<iw_engine::Camera, float>(iw_engine::k_abs_forward);
-}
-
-TEST(WorldToRadarTests, FrostbiteEngineCamera)
-{
-    verify_world_to_radar_uses_engine_world_axes<frostbite_engine::Camera, float>(frostbite_engine::k_abs_forward,
-                                                                                  frostbite_engine::k_abs_right);
-    verify_world_to_radar_uses_changed_camera_yaw<frostbite_engine::Camera, float>(
-            90.f, frostbite_engine::k_abs_forward, frostbite_engine::k_abs_right);
-    verify_world_to_radar_ignores_camera_pitch<frostbite_engine::Camera, float>(frostbite_engine::k_abs_forward);
-}
-
-TEST(WorldToRadarTests, OpenGLEngineCamera)
-{
-    verify_world_to_radar_uses_engine_world_axes<opengl_engine::Camera, float>(opengl_engine::k_abs_forward,
-                                                                               opengl_engine::k_abs_right);
-    verify_world_to_radar_uses_changed_camera_yaw<opengl_engine::Camera, float>(-90.f, opengl_engine::k_abs_forward,
-                                                                                opengl_engine::k_abs_right);
-    verify_world_to_radar_ignores_camera_pitch<opengl_engine::Camera, float>(opengl_engine::k_abs_forward);
-}
-
-TEST(WorldToRadarTests, UnityEngineCamera)
-{
-    verify_world_to_radar_uses_engine_world_axes<unity_engine::Camera, float>(unity_engine::k_abs_forward,
-                                                                              unity_engine::k_abs_right);
-    verify_world_to_radar_uses_changed_camera_yaw<unity_engine::Camera, float>(90.f, unity_engine::k_abs_forward,
-                                                                               unity_engine::k_abs_right);
-    verify_world_to_radar_ignores_camera_pitch<unity_engine::Camera, float>(unity_engine::k_abs_forward);
-}
-
-TEST(WorldToRadarTests, CryEngineCamera)
-{
-    verify_world_to_radar_uses_engine_world_axes<cry_engine::Camera, float>(cry_engine::k_abs_forward,
-                                                                            cry_engine::k_abs_right);
-    verify_world_to_radar_uses_changed_camera_yaw<cry_engine::Camera, float>(-90.f, cry_engine::k_abs_forward,
-                                                                             cry_engine::k_abs_right);
-    verify_world_to_radar_ignores_camera_pitch<cry_engine::Camera, float>(cry_engine::k_abs_forward);
-}
-
-TEST(WorldToRadarTests, RageEngineCamera)
-{
-    verify_world_to_radar_uses_engine_world_axes<rage_engine::Camera, float>(rage_engine::k_abs_forward,
-                                                                             rage_engine::k_abs_right);
-    verify_world_to_radar_uses_changed_camera_yaw<rage_engine::Camera, float>(-90.f, rage_engine::k_abs_forward,
-                                                                              rage_engine::k_abs_right);
-    verify_world_to_radar_ignores_camera_pitch<rage_engine::Camera, float>(rage_engine::k_abs_forward);
-}
-
-TEST(WorldToRadarTests, UnrealEngineCamera)
-{
-    verify_world_to_radar_uses_engine_world_axes<unreal_engine::Camera, double>(unreal_engine::k_abs_forward,
-                                                                                unreal_engine::k_abs_right);
-    verify_world_to_radar_uses_changed_camera_yaw<unreal_engine::Camera, double>(90.f, unreal_engine::k_abs_forward,
-                                                                                 unreal_engine::k_abs_right);
-    verify_world_to_radar_ignores_camera_pitch<unreal_engine::Camera, double>(unreal_engine::k_abs_forward);
-}

tests/general/unit_test_triangle.cpp

@@ -8,15 +8,6 @@
 
 using namespace omath;
 
-namespace
-{
-    constexpr bool close_to(const float actual, const float expected, const float epsilon)
-    {
-        const float diff = actual - expected;
-        return (diff < 0.0f ? -diff : diff) <= epsilon;
-    }
-} // namespace
-
 class UnitTestTriangle : public ::testing::Test
 {
 protected:
@@ -28,21 +19,36 @@ protected:
     constexpr void SetUp() override
     {
         // Triangle with vertices (0, 0, 0), (1, 0, 0), (0, 1, 0)
-        t1 = Triangle<Vector3<float>>(Vector3(0.0f, 0.0f, 0.0f), Vector3(1.0f, 0.0f, 0.0f), Vector3(0.0f, 1.0f, 0.0f));
+        t1 = Triangle<Vector3<float>>(
+            Vector3(0.0f, 0.0f, 0.0f),
+            Vector3(1.0f, 0.0f, 0.0f),
+            Vector3(0.0f, 1.0f, 0.0f)
+        );
 
         // Triangle with vertices (1, 2, 3), (4, 5, 6), (7, 8, 9)
-        t2 = Triangle<Vector3<float>>(Vector3(1.0f, 2.0f, 3.0f), Vector3(4.0f, 5.0f, 6.0f), Vector3(7.0f, 8.0f, 9.0f));
+        t2 = Triangle<Vector3<float>>(
+            Vector3(1.0f, 2.0f, 3.0f),
+            Vector3(4.0f, 5.0f, 6.0f),
+            Vector3(7.0f, 8.0f, 9.0f)
+        );
 
         // An isosceles right triangle
-        t3 = Triangle<Vector3<float>>(Vector3(0.0f, 0.0f, 0.0f), Vector3(2.0f, 0.0f, 0.0f), Vector3(0.0f, 2.0f, 0.0f));
+        t3 = Triangle<Vector3<float>>(
+            Vector3(0.0f, 0.0f, 0.0f),
+            Vector3(2.0f, 0.0f, 0.0f),
+            Vector3(0.0f, 2.0f, 0.0f)
+        );
     }
 };
 
 // Test constructor and vertices
 TEST_F(UnitTestTriangle, Constructor)
 {
-    constexpr Triangle<Vector3<float>> t(Vector3(1.0f, 2.0f, 3.0f), Vector3(4.0f, 5.0f, 6.0f),
-                                         Vector3(7.0f, 8.0f, 9.0f));
+    constexpr Triangle<Vector3<float>> t(
+        Vector3(1.0f, 2.0f, 3.0f),
+        Vector3(4.0f, 5.0f, 6.0f),
+        Vector3(7.0f, 8.0f, 9.0f)
+    );
 
     EXPECT_FLOAT_EQ(t.m_vertex1.x, 1.0f);
     EXPECT_FLOAT_EQ(t.m_vertex1.y, 2.0f);
@@ -66,6 +72,7 @@ TEST_F(UnitTestTriangle, CalculateNormal)
     EXPECT_NEAR(std::fabs(normal_t1.z), 1.0f, 1e-5f);
     EXPECT_NEAR(normal_t1.length(), 1.0f, 1e-5f);
 
+
     // For t3, we expect the normal to be along +Z as well
     const Vector3 normal_t3 = t3.calculate_normal();
     EXPECT_NEAR(std::fabs(normal_t3.z), 1.0f, 1e-5f);
@@ -76,10 +83,7 @@ TEST_F(UnitTestTriangle, SideLengths)
 {
     // For t1 side lengths
     EXPECT_FLOAT_EQ(t1.side_a_length(), std::sqrt(1.0f)); // distance between (0,0,0) and (1,0,0)
-    EXPECT_FLOAT_EQ(
-            t1.side_b_length(),
-            std::sqrt(1.0f
-                      + 1.0f)); // distance between (4,5,6) & (7,8,9)... but we are testing t1, so let's be accurate:
+    EXPECT_FLOAT_EQ(t1.side_b_length(), std::sqrt(1.0f + 1.0f)); // distance between (4,5,6) & (7,8,9)... but we are testing t1, so let's be accurate:
     // Actually, for t1: vertex2=(1,0,0), vertex3=(0,1,0)
     // Dist between (0,1,0) and (1,0,0) = sqrt((1-0)^2 + (0-1)^2) = sqrt(1 + 1) = sqrt(2)
     EXPECT_FLOAT_EQ(t1.side_b_length(), std::sqrt(2.0f));
@@ -108,7 +112,7 @@ TEST_F(UnitTestTriangle, SideVectors)
 
 TEST_F(UnitTestTriangle, IsRectangular)
 {
-    EXPECT_TRUE(Triangle<Vector3<float>>({2, 0, 0}, {}, {0, 2, 0}).is_rectangular());
+    EXPECT_TRUE(Triangle<Vector3<float>>({2,0,0}, {}, {0,2,0}).is_rectangular());
 }
 // Test midpoint
 TEST_F(UnitTestTriangle, MidPoint)
@@ -125,18 +129,3 @@ TEST_F(UnitTestTriangle, MidPoint)
     EXPECT_FLOAT_EQ(mid2.y, (2.0f + 5.0f + 8.0f) / 3.0f);
     EXPECT_FLOAT_EQ(mid2.z, (3.0f + 6.0f + 9.0f) / 3.0f);
 }
-
-static_assert(
-        []
-        {
-            constexpr Triangle<Vector3<float>> triangle{{3.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 4.0f, 0.0f}};
-            constexpr auto normal = triangle.calculate_normal();
-            constexpr auto mid_point = triangle.mid_point();
-
-            return close_to(triangle.side_a_length(), 3.0f, 1e-5f) && close_to(triangle.side_b_length(), 4.0f, 1e-5f)
-                   && close_to(triangle.hypot(), 5.0f, 1e-5f) && triangle.is_rectangular()
-                   && close_to(normal.length(), 1.0f, 1e-5f) && close_to(normal.z, -1.0f, 1e-5f)
-                   && close_to(mid_point.x, 1.0f, 1e-5f) && close_to(mid_point.y, 4.0f / 3.0f, 1e-5f)
-                   && close_to(mid_point.z, 0.0f, 1e-5f);
-        }(),
-        "Triangle helpers should be constexpr with embedded constexpr math");